Long live Qt 4.5!

1 files changed, 2378 insertions, 0 deletions

diff --git a/src/qt3support/network/q3ftp.cpp b/src/qt3support/network/q3ftp.cpp
new file mode 100644
index 0000000..5ab84cc
--- /dev/null
+++ b/src/qt3support/network/q3ftp.cpp
@@ -0,0 +1,2378 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "q3ftp.h"
+
+#ifndef QT_NO_NETWORKPROTOCOL_FTP
+
+#include "q3socket.h"
+#include "q3socketdevice.h"
+#include "qurlinfo.h"
+#include "q3urloperator.h"
+#include "qstringlist.h"
+#include "qregexp.h"
+#include "qtimer.h"
+#include "qfileinfo.h"
+#include "q3ptrdict.h"
+#include "q3cstring.h"
+#include "qcoreapplication.h"
+#include "qftp.h"
+
+#ifndef QT_NO_TEXTCODEC
+#include "qtextcodec.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+//#define Q3FTPPI_DEBUG
+//#define Q3FTPDTP_DEBUG
+
+class Q3FtpPI;
+
+class Q3FtpDTP : public QObject
+{
+    Q_OBJECT
+
+public:
+    enum ConnectState {
+	CsHostFound,
+	CsConnected,
+	CsClosed,
+	CsHostNotFound,
+	CsConnectionRefused
+    };
+
+    Q3FtpDTP( Q3FtpPI *p, QObject *parent=0, const char *name=0 );
+
+    void setData( QByteArray * );
+    void setDevice( QIODevice * );
+    void writeData();
+
+    void setBytesTotal( int bytes )
+    {
+	bytesTotal = bytes;
+	bytesDone = 0;
+	emit dataTransferProgress( bytesDone, bytesTotal );
+    }
+
+    bool hasError() const;
+    QString errorMessage() const;
+    void clearError();
+
+    void connectToHost( const QString & host, Q_UINT16 port )
+    { socket.connectToHost( host, port ); }
+
+    Q3Socket::State socketState() const
+    { return socket.state(); }
+
+    Q_ULONG bytesAvailable() const
+    { return socket.bytesAvailable(); }
+
+    Q_LONG readBlock( char *data, Q_ULONG maxlen )
+    {
+	Q_LONG read = socket.readBlock( data, maxlen );
+	bytesDone += read;
+	return read;
+    }
+
+    QByteArray readAll()
+    {
+	QByteArray tmp = socket.readAll();
+	bytesDone += tmp.size();
+	return tmp;
+    }
+
+    void abortConnection();
+
+    static bool parseDir( const QString &buffer, const QString &userName, QUrlInfo *info );
+
+signals:
+    void listInfo( const QUrlInfo& );
+    void readyRead();
+    void dataTransferProgress( int, int );
+
+    void connectState( int );
+
+private slots:
+    void socketConnected();
+    void socketReadyRead();
+    void socketError( int );
+    void socketConnectionClosed();
+    void socketBytesWritten( int );
+
+private:
+    void clearData()
+    {
+	is_ba = false;
+	data.dev = 0;
+    }
+
+    Q3Socket socket;
+    Q3FtpPI *pi;
+    QString err;
+    int bytesDone;
+    int bytesTotal;
+    bool callWriteData;
+
+    // If is_ba is true, ba is used; ba is never 0.
+    // Otherwise dev is used; dev can be 0 or not.
+    union {
+	QByteArray *ba;
+	QIODevice *dev;
+    } data;
+    bool is_ba;
+};
+
+class Q3FtpPI : public QObject
+{
+    Q_OBJECT
+
+public:
+    Q3FtpPI( QObject *parent = 0 );
+
+    void connectToHost( const QString &host, Q_UINT16 port );
+
+    bool sendCommands( const QStringList &cmds );
+    bool sendCommand( const QString &cmd )
+    { return sendCommands( QStringList( cmd ) ); }
+
+    void clearPendingCommands();
+    void abort();
+
+    QString currentCommand() const
+    { return currentCmd; }
+
+    bool rawCommand;
+
+    Q3FtpDTP dtp; // the PI has a DTP which is not the design of RFC 959, but it
+		 // makes the design simpler this way
+signals:
+    void connectState( int );
+    void finished( const QString& );
+    void error( int, const QString& );
+    void rawFtpReply( int, const QString& );
+
+private slots:
+    void hostFound();
+    void connected();
+    void connectionClosed();
+    void delayedCloseFinished();
+    void readyRead();
+    void error( int );
+
+    void dtpConnectState( int );
+
+private:
+    // the states are modelled after the generalized state diagram of RFC 959,
+    // page 58
+    enum State {
+	Begin,
+	Idle,
+	Waiting,
+	Success,
+	Failure
+    };
+
+    enum AbortState {
+	None,
+	AbortStarted,
+	WaitForAbortToFinish
+    };
+
+    bool processReply();
+    bool startNextCmd();
+
+    Q3Socket commandSocket;
+    QString replyText;
+    signed char replyCode[3];
+    State state;
+    AbortState abortState;
+    QStringList pendingCommands;
+    QString currentCmd;
+
+    bool waitForDtpToConnect;
+    bool waitForDtpToClose;
+};
+
+/**********************************************************************
+ *
+ * Q3FtpCommand implemenatation
+ *
+ *********************************************************************/
+class Q3FtpCommand
+{
+public:
+    Q3FtpCommand( Q3Ftp::Command cmd, QStringList raw );
+    Q3FtpCommand( Q3Ftp::Command cmd, QStringList raw, const QByteArray &ba );
+    Q3FtpCommand( Q3Ftp::Command cmd, QStringList raw, QIODevice *dev );
+    ~Q3FtpCommand();
+
+    int id;
+    Q3Ftp::Command command;
+    QStringList rawCmds;
+
+    // If is_ba is true, ba is used; ba is never 0.
+    // Otherwise dev is used; dev can be 0 or not.
+    union {
+	QByteArray *ba;
+	QIODevice *dev;
+    } data;
+    bool is_ba;
+
+    static int idCounter;
+};
+
+int Q3FtpCommand::idCounter = 0;
+
+Q3FtpCommand::Q3FtpCommand( Q3Ftp::Command cmd, QStringList raw )
+    : command(cmd), rawCmds(raw), is_ba(false)
+{
+    id = ++idCounter;
+    data.dev = 0;
+}
+
+Q3FtpCommand::Q3FtpCommand( Q3Ftp::Command cmd, QStringList raw, const QByteArray &ba )
+    : command(cmd), rawCmds(raw), is_ba(true)
+{
+    id = ++idCounter;
+    data.ba = new QByteArray( ba );
+}
+
+Q3FtpCommand::Q3FtpCommand( Q3Ftp::Command cmd, QStringList raw, QIODevice *dev )
+    : command(cmd), rawCmds(raw), is_ba(false)
+{
+    id = ++idCounter;
+    data.dev = dev;
+}
+
+Q3FtpCommand::~Q3FtpCommand()
+{
+    if ( is_ba )
+	delete data.ba;
+}
+
+/**********************************************************************
+ *
+ * Q3FtpDTP implemenatation
+ *
+ *********************************************************************/
+Q3FtpDTP::Q3FtpDTP( Q3FtpPI *p, QObject *parent, const char *name ) :
+    QObject( parent, name ),
+    socket( 0, "Q3FtpDTP_socket" ),
+    pi( p ),
+    callWriteData( false )
+{
+    clearData();
+
+    connect( &socket, SIGNAL(connected()),
+	     SLOT(socketConnected()) );
+    connect( &socket, SIGNAL(readyRead()),
+	     SLOT(socketReadyRead()) );
+    connect( &socket, SIGNAL(error(int)),
+	     SLOT(socketError(int)) );
+    connect( &socket, SIGNAL(connectionClosed()),
+	     SLOT(socketConnectionClosed()) );
+    connect( &socket, SIGNAL(bytesWritten(int)),
+	     SLOT(socketBytesWritten(int)) );
+}
+
+void Q3FtpDTP::setData( QByteArray *ba )
+{
+    is_ba = true;
+    data.ba = ba;
+}
+
+void Q3FtpDTP::setDevice( QIODevice *dev )
+{
+    is_ba = false;
+    data.dev = dev;
+}
+
+void Q3FtpDTP::writeData()
+{
+    if ( is_ba ) {
+#if defined(Q3FTPDTP_DEBUG)
+	qDebug( "Q3FtpDTP::writeData: write %d bytes", data.ba->size() );
+#endif
+	if ( data.ba->size() == 0 )
+	    emit dataTransferProgress( 0, bytesTotal );
+	else
+	    socket.writeBlock( data.ba->data(), data.ba->size() );
+	socket.close();
+	clearData();
+    } else if ( data.dev ) {
+	callWriteData = false;
+	const int blockSize = 16*1024;
+	char buf[blockSize];
+	while ( !data.dev->atEnd() && socket.bytesToWrite()==0 ) {
+	    Q_LONG read = data.dev->readBlock( buf, blockSize );
+#if defined(Q3FTPDTP_DEBUG)
+	    qDebug( "Q3FtpDTP::writeData: writeBlock() of size %d bytes", (int)read );
+#endif
+	    socket.writeBlock( buf, read );
+	    if ( !data.dev )
+		return; // this can happen when a command is aborted
+	}
+	if ( data.dev->atEnd() ) {
+	    if ( bytesDone==0 && socket.bytesToWrite()==0 )
+		emit dataTransferProgress( 0, bytesTotal );
+	    socket.close();
+	    clearData();
+	} else {
+	    callWriteData = true;
+	}
+    }
+}
+
+inline bool Q3FtpDTP::hasError() const
+{
+    return !err.isNull();
+}
+
+inline QString Q3FtpDTP::errorMessage() const
+{
+    return err;
+}
+
+inline void Q3FtpDTP::clearError()
+{
+    err.clear();
+}
+
+void Q3FtpDTP::abortConnection()
+{
+#if defined(Q3FTPDTP_DEBUG)
+    qDebug( "Q3FtpDTP::abortConnection" );
+#endif
+    callWriteData = false;
+    clearData();
+
+    socket.clearPendingData();
+    socket.close();
+}
+
+bool Q3FtpDTP::parseDir( const QString &buffer, const QString &userName, QUrlInfo *info )
+{
+    QStringList lst = QStringList::split( QLatin1String(" "), buffer );
+
+    if ( lst.count() < 9 )
+	return false;
+
+    QString tmp;
+
+    // permissions
+    tmp = lst[ 0 ];
+
+    if ( tmp[ 0 ] == QChar( QLatin1Char('d') ) ) {
+	info->setDir( true );
+	info->setFile( false );
+	info->setSymLink( false );
+    } else if ( tmp[ 0 ] == QChar( QLatin1Char('-') ) ) {
+	info->setDir( false );
+	info->setFile( true );
+	info->setSymLink( false );
+    } else if ( tmp[ 0 ] == QChar( QLatin1Char('l') ) ) {
+	info->setDir( true ); // #### todo
+	info->setFile( false );
+	info->setSymLink( true );
+    } else {
+	return false;
+    }
+
+    static int user = 0;
+    static int group = 1;
+    static int other = 2;
+    static int readable = 0;
+    static int writable = 1;
+    static int executable = 2;
+
+    bool perms[ 3 ][ 3 ];
+    perms[0][0] = (tmp[ 1 ] == QLatin1Char('r'));
+    perms[0][1] = (tmp[ 2 ] == QLatin1Char('w'));
+    perms[0][2] = (tmp[ 3 ] == QLatin1Char('x'));
+    perms[1][0] = (tmp[ 4 ] == QLatin1Char('r'));
+    perms[1][1] = (tmp[ 5 ] == QLatin1Char('w'));
+    perms[1][2] = (tmp[ 6 ] == QLatin1Char('x'));
+    perms[2][0] = (tmp[ 7 ] == QLatin1Char('r'));
+    perms[2][1] = (tmp[ 8 ] == QLatin1Char('w'));
+    perms[2][2] = (tmp[ 9 ] == QLatin1Char('x'));
+
+    // owner
+    tmp = lst[ 2 ];
+    info->setOwner( tmp );
+
+    // group
+    tmp = lst[ 3 ];
+    info->setGroup( tmp );
+
+    // ### not correct
+    info->setWritable( ( userName == info->owner() && perms[ user ][ writable ] ) ||
+	perms[ other ][ writable ] );
+    info->setReadable( ( userName == info->owner() && perms[ user ][ readable ] ) ||
+	perms[ other ][ readable ] );
+
+    int p = 0;
+    if ( perms[ user ][ readable ] )
+	p |= QUrlInfo::ReadOwner;
+    if ( perms[ user ][ writable ] )
+	p |= QUrlInfo::WriteOwner;
+    if ( perms[ user ][ executable ] )
+	p |= QUrlInfo::ExeOwner;
+    if ( perms[ group ][ readable ] )
+	p |= QUrlInfo::ReadGroup;
+    if ( perms[ group ][ writable ] )
+	p |= QUrlInfo::WriteGroup;
+    if ( perms[ group ][ executable ] )
+	p |= QUrlInfo::ExeGroup;
+    if ( perms[ other ][ readable ] )
+	p |= QUrlInfo::ReadOther;
+    if ( perms[ other ][ writable ] )
+	p |= QUrlInfo::WriteOther;
+    if ( perms[ other ][ executable ] )
+	p |= QUrlInfo::ExeOther;
+    info->setPermissions( p );
+
+    // size
+    tmp = lst[ 4 ];
+    info->setSize( tmp.toInt() );
+
+    // date and time
+    QTime time;
+    QString dateStr;
+    dateStr += QLatin1String("Sun ");
+    lst[ 5 ][ 0 ] = lst[ 5 ][ 0 ].upper();
+    dateStr += lst[ 5 ];
+    dateStr += QLatin1Char(' ');
+    dateStr += lst[ 6 ];
+    dateStr += QLatin1Char(' ');
+
+    if ( lst[ 7 ].contains( QLatin1String(":") ) ) {
+	time = QTime( lst[ 7 ].left( 2 ).toInt(), lst[ 7 ].right( 2 ).toInt() );
+	dateStr += QString::number( QDate::currentDate().year() );
+    } else {
+	dateStr += lst[ 7 ];
+    }
+
+    QDate date = QDate::fromString( dateStr );
+    info->setLastModified( QDateTime( date, time ) );
+
+    if ( lst[ 7 ].contains( QLatin1String(":") ) ) {
+	const int futureTolerance = 600;
+	if( info->lastModified().secsTo( QDateTime::currentDateTime() ) < -futureTolerance ) {
+	    QDateTime dt = info->lastModified();
+	    QDate d = dt.date();
+	    d.setYMD(d.year()-1, d.month(), d.day());
+	    dt.setDate(d);
+	    info->setLastModified(dt);
+	}
+    }
+
+    // name
+    if ( info->isSymLink() )
+	info->setName( lst[ 8 ].stripWhiteSpace() );
+    else {
+	QString n;
+	for ( uint i = 8; i < (uint) lst.count(); ++i )
+	    n += lst[ i ] + QLatin1String(" ");
+	n = n.stripWhiteSpace();
+	info->setName( n );
+    }
+    return true;
+}
+
+void Q3FtpDTP::socketConnected()
+{
+#if !defined (Q_WS_QWS)
+    // Use a large send buffer to reduce the number
+    // of writeBlocks when download and uploading files.
+    // The actual size used here (128k) is default on most
+    // Unixes.
+    socket.socketDevice()->setSendBufferSize(128 * 1024);
+    socket.socketDevice()->setReceiveBufferSize(128 * 1024);
+#endif
+
+    bytesDone = 0;
+#if defined(Q3FTPDTP_DEBUG)
+    qDebug( "Q3FtpDTP::connectState( CsConnected )" );
+#endif
+    emit connectState( Q3FtpDTP::CsConnected );
+}
+
+void Q3FtpDTP::socketReadyRead()
+{
+    if ( pi->currentCommand().isEmpty() ) {
+	socket.close();
+#if defined(Q3FTPDTP_DEBUG)
+	qDebug( "Q3FtpDTP::connectState( CsClosed )" );
+#endif
+	emit connectState( Q3FtpDTP::CsClosed );
+	return;
+    }
+
+    if ( pi->currentCommand().startsWith(QLatin1String("LIST")) ) {
+	while ( socket.canReadLine() ) {
+	    QUrlInfo i;
+	    QString line = QLatin1String(socket.readLine());
+#if defined(Q3FTPDTP_DEBUG)
+	    qDebug( "Q3FtpDTP read (list): '%s'", line.latin1() );
+#endif
+	    if ( parseDir( line, QLatin1String(""), &i ) ) {
+		emit listInfo( i );
+	    } else {
+		// some FTP servers don't return a 550 if the file or directory
+		// does not exist, but rather write a text to the data socket
+		// -- try to catch these cases
+		if ( line.endsWith( QLatin1String("No such file or directory\r\n") ) )
+		    err = line;
+	    }
+	}
+    } else {
+	if ( !is_ba && data.dev ) {
+	    QByteArray ba( socket.bytesAvailable() );
+	    Q_LONG bytesRead = socket.readBlock( ba.data(), ba.size() );
+	    if ( bytesRead < 0 ) {
+		// ### error handling
+		return;
+	    }
+	    ba.resize( bytesRead );
+	    bytesDone += bytesRead;
+#if defined(Q3FTPDTP_DEBUG)
+	    qDebug( "Q3FtpDTP read: %d bytes (total %d bytes)", (int)bytesRead, bytesDone );
+#endif
+	    emit dataTransferProgress( bytesDone, bytesTotal );
+            if (data.dev)       // make sure it wasn't deleted in the slot
+                data.dev->writeBlock( ba );
+	} else {
+#if defined(Q3FTPDTP_DEBUG)
+	    qDebug( "Q3FtpDTP readyRead: %d bytes available (total %d bytes read)", (int)bytesAvailable(), bytesDone );
+#endif
+	    emit dataTransferProgress( bytesDone+socket.bytesAvailable(), bytesTotal );
+	    emit readyRead();
+	}
+    }
+}
+
+void Q3FtpDTP::socketError( int e )
+{
+    if ( e == Q3Socket::ErrHostNotFound ) {
+#if defined(Q3FTPDTP_DEBUG)
+	qDebug( "Q3FtpDTP::connectState( CsHostNotFound )" );
+#endif
+	emit connectState( Q3FtpDTP::CsHostNotFound );
+    } else if ( e == Q3Socket::ErrConnectionRefused ) {
+#if defined(Q3FTPDTP_DEBUG)
+	qDebug( "Q3FtpDTP::connectState( CsConnectionRefused )" );
+#endif
+	emit connectState( Q3FtpDTP::CsConnectionRefused );
+    }
+}
+
+void Q3FtpDTP::socketConnectionClosed()
+{
+    if ( !is_ba && data.dev ) {
+	clearData();
+    }
+#if defined(Q3FTPDTP_DEBUG)
+    qDebug( "Q3FtpDTP::connectState( CsClosed )" );
+#endif
+    emit connectState( Q3FtpDTP::CsClosed );
+}
+
+void Q3FtpDTP::socketBytesWritten( int bytes )
+{
+    bytesDone += bytes;
+#if defined(Q3FTPDTP_DEBUG)
+    qDebug( "Q3FtpDTP::bytesWritten( %d )", bytesDone );
+#endif
+    emit dataTransferProgress( bytesDone, bytesTotal );
+    if ( callWriteData )
+	writeData();
+}
+
+/**********************************************************************
+ *
+ * Q3FtpPI implemenatation
+ *
+ *********************************************************************/
+Q3FtpPI::Q3FtpPI( QObject *parent ) :
+    QObject( parent ),
+    rawCommand(false),
+    dtp( this ),
+    commandSocket( 0, "Q3FtpPI_socket" ),
+    state( Begin ), abortState( None ),
+    currentCmd( QString() ),
+    waitForDtpToConnect( false ),
+    waitForDtpToClose( false )
+{
+    connect( &commandSocket, SIGNAL(hostFound()),
+	    SLOT(hostFound()) );
+    connect( &commandSocket, SIGNAL(connected()),
+	    SLOT(connected()) );
+    connect( &commandSocket, SIGNAL(connectionClosed()),
+	    SLOT(connectionClosed()) );
+    connect( &commandSocket, SIGNAL(delayedCloseFinished()),
+	    SLOT(delayedCloseFinished()) );
+    connect( &commandSocket, SIGNAL(readyRead()),
+	    SLOT(readyRead()) );
+    connect( &commandSocket, SIGNAL(error(int)),
+	    SLOT(error(int)) );
+
+    connect( &dtp, SIGNAL(connectState(int)),
+	     SLOT(dtpConnectState(int)) );
+}
+
+void Q3FtpPI::connectToHost( const QString &host, Q_UINT16 port )
+{
+    emit connectState( Q3Ftp::HostLookup );
+    commandSocket.connectToHost( host, port );
+}
+
+/*
+  Sends the sequence of commands \a cmds to the FTP server. When the commands
+  are all done the finished() signal is emitted. When an error occurs, the
+  error() signal is emitted.
+
+  If there are pending commands in the queue this functions returns false and
+  the \a cmds are not added to the queue; otherwise it returns true.
+*/
+bool Q3FtpPI::sendCommands( const QStringList &cmds )
+{
+    if ( !pendingCommands.isEmpty() )
+	return false;
+
+    if ( commandSocket.state()!=Q3Socket::Connected || state!=Idle ) {
+	emit error( Q3Ftp::NotConnected, QFtp::tr( "Not connected" ) );
+	return true; // there are no pending commands
+    }
+
+    pendingCommands = cmds;
+    startNextCmd();
+    return true;
+}
+
+void Q3FtpPI::clearPendingCommands()
+{
+    pendingCommands.clear();
+    dtp.abortConnection();
+    currentCmd.clear();
+    state = Idle;
+}
+
+void Q3FtpPI::abort()
+{
+    pendingCommands.clear();
+
+    if ( abortState != None )
+	// ABOR already sent
+	return;
+
+    abortState = AbortStarted;
+#if defined(Q3FTPPI_DEBUG)
+    qDebug( "Q3FtpPI send: ABOR" );
+#endif
+    commandSocket.writeBlock( "ABOR\r\n", 6 );
+
+    if ( currentCmd.startsWith(QLatin1String("STOR ")) )
+	dtp.abortConnection();
+}
+
+void Q3FtpPI::hostFound()
+{
+    emit connectState( Q3Ftp::Connecting );
+}
+
+void Q3FtpPI::connected()
+{
+    state = Begin;
+#if defined(Q3FTPPI_DEBUG)
+//    qDebug( "Q3FtpPI state: %d [connected()]", state );
+#endif
+    emit connectState( Q3Ftp::Connected );
+}
+
+void Q3FtpPI::connectionClosed()
+{
+    commandSocket.close();
+    emit connectState( Q3Ftp::Unconnected );
+}
+
+void Q3FtpPI::delayedCloseFinished()
+{
+    emit connectState( Q3Ftp::Unconnected );
+}
+
+void Q3FtpPI::error( int e )
+{
+    if ( e == Q3Socket::ErrHostNotFound ) {
+	emit connectState( Q3Ftp::Unconnected );
+	emit error( Q3Ftp::HostNotFound,
+		    QFtp::tr( "Host %1 not found" ).arg( commandSocket.peerName() ) );
+    } else if ( e == Q3Socket::ErrConnectionRefused ) {
+	emit connectState( Q3Ftp::Unconnected );
+	emit error( Q3Ftp::ConnectionRefused,
+		    QFtp::tr( "Connection refused to host %1" ).arg( commandSocket.peerName() ) );
+    }
+}
+
+void Q3FtpPI::readyRead()
+{
+    if ( waitForDtpToClose )
+	return;
+
+    while ( commandSocket.canReadLine() ) {
+	// read line with respect to line continuation
+	QString line = QLatin1String(commandSocket.readLine());
+	if ( replyText.isEmpty() ) {
+	    if ( line.length() < 3 ) {
+		// ### protocol error
+		return;
+	    }
+	    const int lowerLimit[3] = {1,0,0};
+	    const int upperLimit[3] = {5,5,9};
+	    for ( int i=0; i<3; i++ ) {
+		replyCode[i] = line[i].digitValue();
+		if ( replyCode[i]<lowerLimit[i] || replyCode[i]>upperLimit[i] ) {
+		    // ### protocol error
+		    return;
+		}
+	    }
+	}
+	QString endOfMultiLine;
+	endOfMultiLine[0] = '0' + replyCode[0];
+	endOfMultiLine[1] = '0' + replyCode[1];
+	endOfMultiLine[2] = '0' + replyCode[2];
+	endOfMultiLine[3] = ' ';
+	QString lineCont( endOfMultiLine );
+	lineCont[3] = '-';
+	QString lineLeft4 = line.left(4);
+
+	while ( lineLeft4 != endOfMultiLine ) {
+	    if ( lineLeft4 == lineCont )
+		replyText += line.mid( 4 ); // strip 'xyz-'
+	    else
+		replyText += line;
+	    if ( !commandSocket.canReadLine() )
+		return;
+	    line = QLatin1String(commandSocket.readLine());
+	    lineLeft4 = line.left(4);
+	}
+	replyText += line.mid( 4 ); // strip reply code 'xyz '
+	if ( replyText.endsWith(QLatin1String("\r\n")) )
+	    replyText.truncate( replyText.length()-2 );
+
+	if ( processReply() )
+	    replyText = QLatin1String("");
+    }
+}
+
+/*
+  Process a reply from the FTP server.
+
+  Returns true if the reply was processed or false if the reply has to be
+  processed at a later point.
+*/
+bool Q3FtpPI::processReply()
+{
+#if defined(Q3FTPPI_DEBUG)
+//    qDebug( "Q3FtpPI state: %d [processReply() begin]", state );
+    if ( replyText.length() < 400 )
+	qDebug( "Q3FtpPI recv: %d %s", 100*replyCode[0]+10*replyCode[1]+replyCode[2], replyText.latin1() );
+    else
+	qDebug( "Q3FtpPI recv: %d (text skipped)", 100*replyCode[0]+10*replyCode[1]+replyCode[2] );
+#endif
+
+    // process 226 replies ("Closing Data Connection") only when the data
+    // connection is really closed to avoid short reads of the DTP
+    if ( 100*replyCode[0]+10*replyCode[1]+replyCode[2] == 226 ) {
+	if ( dtp.socketState() != Q3Socket::Idle ) {
+	    waitForDtpToClose = true;
+	    return false;
+	}
+    }
+
+    switch ( abortState ) {
+	case AbortStarted:
+	    abortState = WaitForAbortToFinish;
+	    break;
+	case WaitForAbortToFinish:
+	    abortState = None;
+	    return true;
+	default:
+	    break;
+    }
+
+    // get new state
+    static const State table[5] = {
+	/* 1yz   2yz      3yz   4yz      5yz */
+	Waiting, Success, Idle, Failure, Failure
+    };
+    switch ( state ) {
+	case Begin:
+	    if ( replyCode[0] == 1 ) {
+		return true;
+	    } else if ( replyCode[0] == 2 ) {
+		state = Idle;
+		emit finished( QFtp::tr( "Connected to host %1" ).arg( commandSocket.peerName() ) );
+		break;
+	    }
+	    // ### error handling
+	    return true;
+	case Waiting:
+	    if ( replyCode[0]<0 || replyCode[0]>5 )
+		state = Failure;
+	    else
+#if defined(Q_OS_IRIX) && defined(Q_CC_GNU)
+            {
+                // work around a crash on 64 bit gcc IRIX
+                State *t = (State *) table;
+                state = t[replyCode[0] - 1];
+            }
+#else
+            state = table[replyCode[0] - 1];
+#endif
+	    break;
+	default:
+	    // ### spontaneous message
+	    return true;
+    }
+#if defined(Q3FTPPI_DEBUG)
+//    qDebug( "Q3FtpPI state: %d [processReply() intermediate]", state );
+#endif
+
+    // special actions on certain replies
+    int replyCodeInt = 100*replyCode[0] + 10*replyCode[1] + replyCode[2];
+    emit rawFtpReply( replyCodeInt, replyText );
+    if ( rawCommand ) {
+	rawCommand = false;
+    } else if ( replyCodeInt == 227 ) {
+	// 227 Entering Passive Mode (h1,h2,h3,h4,p1,p2)
+        // rfc959 does not define this response precisely, and gives
+        // both examples where the parenthesis are used, and where
+        // they are missing. We need to scan for the address and host
+        // info.
+	QRegExp addrPortPattern(QLatin1String("(\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)"));
+	if (addrPortPattern.search(replyText) == -1) {
+#if defined(Q3FTPPI_DEBUG)
+	    qDebug( "Q3Ftp: bad 227 response -- address and port information missing" );
+#endif
+	    // ### error handling
+	} else {
+	    QStringList lst = addrPortPattern.capturedTexts();
+	    QString host = lst[1] + QLatin1String(".") + lst[2] + QLatin1String(".") + lst[3] + QLatin1String(".") + lst[4];
+	    Q_UINT16 port = ( lst[5].toUInt() << 8 ) + lst[6].toUInt();
+	    waitForDtpToConnect = true;
+	    dtp.connectToHost( host, port );
+	}
+    } else if ( replyCodeInt == 230 ) {
+	if ( currentCmd.startsWith(QLatin1String("USER ")) && pendingCommands.count()>0 &&
+		pendingCommands.first().startsWith(QLatin1String("PASS ")) ) {
+	    // no need to send the PASS -- we are already logged in
+	    pendingCommands.pop_front();
+	}
+	// 230 User logged in, proceed.
+	emit connectState( Q3Ftp::LoggedIn );
+    } else if ( replyCodeInt == 213 ) {
+	// 213 File status.
+	if ( currentCmd.startsWith(QLatin1String("SIZE ")) )
+	    dtp.setBytesTotal( replyText.simplifyWhiteSpace().toInt() );
+    } else if ( replyCode[0]==1 && currentCmd.startsWith(QLatin1String("STOR ")) ) {
+	dtp.writeData();
+    }
+
+    // react on new state
+    switch ( state ) {
+	case Begin:
+	    // ### should never happen
+	    break;
+	case Success:
+	    // ### success handling
+	    state = Idle;
+	    // no break!
+	case Idle:
+	    if ( dtp.hasError() ) {
+		emit error( Q3Ftp::UnknownError, dtp.errorMessage() );
+		dtp.clearError();
+	    }
+	    startNextCmd();
+	    break;
+	case Waiting:
+	    // ### do nothing
+	    break;
+	case Failure:
+	    emit error( Q3Ftp::UnknownError, replyText );
+	    state = Idle;
+	    startNextCmd();
+	    break;
+    }
+#if defined(Q3FTPPI_DEBUG)
+//    qDebug( "Q3FtpPI state: %d [processReply() end]", state );
+#endif
+    return true;
+}
+
+#ifndef QT_NO_TEXTCODEC
+Q_COMPAT_EXPORT QTextCodec *qt_ftp_filename_codec = 0;
+#endif
+
+/*
+  Starts next pending command. Returns false if there are no pending commands,
+  otherwise it returns true.
+*/
+bool Q3FtpPI::startNextCmd()
+{
+    if ( waitForDtpToConnect )
+	// don't process any new commands until we are connected
+	return true;
+
+#if defined(Q3FTPPI_DEBUG)
+    if ( state != Idle )
+	qDebug( "Q3FtpPI startNextCmd: Internal error! Q3FtpPI called in non-Idle state %d", state );
+#endif
+    if ( pendingCommands.isEmpty() ) {
+	currentCmd.clear();
+	emit finished( replyText );
+	return false;
+    }
+    currentCmd = pendingCommands.first();
+    pendingCommands.pop_front();
+#if defined(Q3FTPPI_DEBUG)
+    qDebug( "Q3FtpPI send: %s", currentCmd.left( currentCmd.length()-2 ).latin1() );
+#endif
+    state = Waiting;
+#ifndef QT_NO_TEXTCODEC
+    if ( qt_ftp_filename_codec ) {
+	int len;
+	Q3CString enc = qt_ftp_filename_codec->fromUnicode(currentCmd,len);
+	commandSocket.writeBlock( enc.data(), len );
+    } else
+#endif
+    {
+	commandSocket.writeBlock( currentCmd.latin1(), currentCmd.length() );
+    }
+    return true;
+}
+
+void Q3FtpPI::dtpConnectState( int s )
+{
+    switch ( s ) {
+	case Q3FtpDTP::CsClosed:
+	    if ( waitForDtpToClose ) {
+		// there is an unprocessed reply
+		if ( processReply() )
+		    replyText = QLatin1String("");
+		else
+		    return;
+	    }
+	    waitForDtpToClose = false;
+	    readyRead();
+	    return;
+	case Q3FtpDTP::CsConnected:
+	    waitForDtpToConnect = false;
+	    startNextCmd();
+	    return;
+	case Q3FtpDTP::CsHostNotFound:
+	case Q3FtpDTP::CsConnectionRefused:
+	    emit error( Q3Ftp::ConnectionRefused,
+			QFtp::tr( "Connection refused for data connection" ) );
+	    startNextCmd();
+	    return;
+	default:
+	    return;
+    }
+}
+
+/**********************************************************************
+ *
+ * Q3FtpPrivate
+ *
+ *********************************************************************/
+class Q3FtpPrivate
+{
+public:
+    Q3FtpPrivate() :
+	close_waitForStateChange(false),
+	state( Q3Ftp::Unconnected ),
+	error( Q3Ftp::NoError ),
+	npWaitForLoginDone( false )
+    { pending.setAutoDelete( true ); }
+
+    Q3FtpPI pi;
+    Q3PtrList<Q3FtpCommand> pending;
+    bool close_waitForStateChange;
+    Q3Ftp::State state;
+    Q3Ftp::Error error;
+    QString errorString;
+
+    bool npWaitForLoginDone;
+};
+
+static Q3PtrDict<Q3FtpPrivate> *d_ptr = 0;
+static void cleanup_d_ptr()
+{
+    delete d_ptr;
+    d_ptr = 0;
+}
+static Q3FtpPrivate* dHelper( const Q3Ftp* foo )
+{
+    if ( !d_ptr ) {
+	d_ptr = new Q3PtrDict<Q3FtpPrivate>;
+	d_ptr->setAutoDelete( true );
+	qAddPostRoutine( cleanup_d_ptr );
+    }
+    Q3FtpPrivate* ret = d_ptr->find( (void*)foo );
+    if ( ! ret ) {
+	ret = new Q3FtpPrivate;
+	d_ptr->replace( (void*) foo, ret );
+    }
+    return ret;
+}
+
+static void delete_d( const Q3Ftp* foo )
+{
+    if ( d_ptr )
+	d_ptr->remove( (void*) foo );
+}
+
+/**********************************************************************
+ *
+ * Q3Ftp implementation
+ *
+ *********************************************************************/
+/*!
+    \class Q3Ftp
+    \brief The Q3Ftp class provides an implementation of the FTP protocol.
+
+    \compat
+
+    This class provides two different interfaces: one is the
+    QNetworkProtocol interface that allows you to use FTP through the
+    QUrlOperator abstraction. The other is a direct interface to FTP
+    that gives you lower-level access to the FTP protocol for finer
+    control. Using the direct interface you can also execute arbitrary
+    FTP commands.
+
+    Don't mix the two interfaces, since the behavior is not
+    well-defined.
+
+    If you want to use Q3Ftp with the QNetworkProtocol interface, you
+    do not use it directly, but rather through a QUrlOperator, for
+    example:
+
+    \snippet doc/src/snippets/code/src_qt3support_network_q3ftp.cpp 0
+
+    This code will only work if the Q3Ftp class is registered; to
+    register the class, you must call q3InitNetworkProtocols() before
+    using a QUrlOperator with Q3Ftp.
+
+    The rest of this descrption describes the direct interface to FTP.
+
+    The class works asynchronously, so there are no blocking
+    functions. If an operation cannot be executed immediately, the
+    function will still return straight away and the operation will be
+    scheduled for later execution. The results of scheduled operations
+    are reported via signals. This approach depends on the event loop
+    being in operation.
+
+    The operations that can be scheduled (they are called "commands"
+    in the rest of the documentation) are the following:
+    connectToHost(), login(), close(), list(), cd(), get(), put(),
+    remove(), mkdir(), rmdir(), rename() and rawCommand().
+
+    All of these commands return a unique identifier that allows you
+    to keep track of the command that is currently being executed.
+    When the execution of a command starts, the commandStarted()
+    signal with the command's identifier is emitted. When the command
+    is finished, the commandFinished() signal is emitted with the
+    command's identifier and a bool that indicates whether the command
+    finished with an error.
+
+    In some cases, you might want to execute a sequence of commands,
+    e.g. if you want to connect and login to a FTP server. This is
+    simply achieved:
+
+    \snippet doc/src/snippets/code/src_qt3support_network_q3ftp.cpp 1
+
+    In this case two FTP commands have been scheduled. When the last
+    scheduled command has finished, a done() signal is emitted with
+    a bool argument that tells you whether the sequence finished with
+    an error.
+
+    If an error occurs during the execution of one of the commands in
+    a sequence of commands, all the pending commands (i.e. scheduled,
+    but not yet executed commands) are cleared and no signals are
+    emitted for them.
+
+    Some commands, e.g. list(), emit additional signals to report
+    their results.
+
+    Example: If you want to download the INSTALL file from Trolltech's
+    FTP server, you would write this:
+
+    \snippet doc/src/snippets/code/src_qt3support_network_q3ftp.cpp 2
+
+    For this example the following sequence of signals is emitted
+    (with small variations, depending on network traffic, etc.):
+
+    \snippet doc/src/snippets/code/src_qt3support_network_q3ftp.cpp 3
+
+    The dataTransferProgress() signal in the above example is useful
+    if you want to show a \link QProgressBar progress bar \endlink to
+    inform the user about the progress of the download. The
+    readyRead() signal tells you that there is data ready to be read.
+    The amount of data can be queried then with the bytesAvailable()
+    function and it can be read with the readBlock() or readAll()
+    function.
+
+    If the login fails for the above example, the signals would look
+    like this:
+
+    \snippet doc/src/snippets/code/src_qt3support_network_q3ftp.cpp 4
+
+    You can then get details about the error with the error() and
+    errorString() functions.
+
+    The functions currentId() and currentCommand() provide more
+    information about the currently executing command.
+
+    The functions hasPendingCommands() and clearPendingCommands()
+    allow you to query and clear the list of pending commands.
+
+    The safest and easiest way to use the FTP protocol is to use
+    QUrlOperator() or the FTP commands described above. If you are an
+    experienced network programmer and want to have complete control
+    you can use rawCommand() to execute arbitrary FTP commands.
+
+    \sa Q3NetworkProtocol, Q3UrlOperator Q3Http
+*/
+
+/*!
+    Constructs a Q3Ftp object.
+*/
+Q3Ftp::Q3Ftp() : Q3NetworkProtocol()
+{
+    init();
+}
+
+/*!
+    Constructs a Q3Ftp object. The \a parent and \a name parameters
+    are passed to the QObject constructor.
+*/
+Q3Ftp::Q3Ftp( QObject *parent, const char *name ) : Q3NetworkProtocol()
+{
+    if ( parent )
+	parent->insertChild( this );
+    setName( name );
+    init();
+}
+
+void Q3Ftp::init()
+{
+    Q3FtpPrivate *d = dHelper( this );
+    d->errorString = QFtp::tr( "Unknown error" );
+
+    connect( &d->pi, SIGNAL(connectState(int)),
+	    SLOT(piConnectState(int)) );
+    connect( &d->pi, SIGNAL(finished(QString)),
+	    SLOT(piFinished(QString)) );
+    connect( &d->pi, SIGNAL(error(int,QString)),
+	    SLOT(piError(int,QString)) );
+    connect( &d->pi, SIGNAL(rawFtpReply(int,QString)),
+	    SLOT(piFtpReply(int,QString)) );
+
+    connect( &d->pi.dtp, SIGNAL(readyRead()),
+	    SIGNAL(readyRead()) );
+    connect( &d->pi.dtp, SIGNAL(dataTransferProgress(int,int)),
+	    SIGNAL(dataTransferProgress(int,int)) );
+    connect( &d->pi.dtp, SIGNAL(listInfo(QUrlInfo)),
+	    SIGNAL(listInfo(QUrlInfo)) );
+}
+
+/*!
+    \enum Q3Ftp::State
+
+    This enum defines the connection state:
+
+    \value Unconnected There is no connection to the host.
+    \value HostLookup A host name lookup is in progress.
+    \value Connecting An attempt to connect to the host is in progress.
+    \value Connected Connection to the host has been achieved.
+    \value LoggedIn Connection and user login have been achieved.
+    \value Closing The connection is closing down, but it is not yet
+    closed. (The state will be \c Unconnected when the connection is
+    closed.)
+
+    \sa stateChanged() state()
+*/
+/*!
+    \enum Q3Ftp::Error
+
+    This enum identifies the error that occurred.
+
+    \value NoError No error occurred.
+    \value HostNotFound The host name lookup failed.
+    \value ConnectionRefused The server refused the connection.
+    \value NotConnected Tried to send a command, but there is no connection to
+    a server.
+    \value UnknownError An error other than those specified above
+    occurred.
+
+    \sa error()
+*/
+
+/*!
+    \enum Q3Ftp::Command
+
+    This enum is used as the return value for the currentCommand() function.
+    This allows you to perform specific actions for particular
+    commands, e.g. in a FTP client, you might want to clear the
+    directory view when a list() command is started; in this case you
+    can simply check in the slot connected to the start() signal if
+    the currentCommand() is \c List.
+
+    \value None No command is being executed.
+    \value ConnectToHost connectToHost() is being executed.
+    \value Login login() is being executed.
+    \value Close close() is being executed.
+    \value List list() is being executed.
+    \value Cd cd() is being executed.
+    \value Get get() is being executed.
+    \value Put put() is being executed.
+    \value Remove remove() is being executed.
+    \value Mkdir mkdir() is being executed.
+    \value Rmdir rmdir() is being executed.
+    \value Rename rename() is being executed.
+    \value RawCommand rawCommand() is being executed.
+
+    \sa currentCommand()
+*/
+
+/*!
+    \fn void Q3Ftp::stateChanged( int state )
+
+    This signal is emitted when the state of the connection changes.
+    The argument \a state is the new state of the connection; it is
+    one of the \l State values.
+
+    It is usually emitted in response to a connectToHost() or close()
+    command, but it can also be emitted "spontaneously", e.g. when the
+    server closes the connection unexpectedly.
+
+    \sa connectToHost() close() state() State
+*/
+
+/*!
+    \fn void Q3Ftp::listInfo( const QUrlInfo &i );
+
+    This signal is emitted for each directory entry the list() command
+    finds. The details of the entry are stored in \a i.
+
+    \sa list()
+*/
+
+/*!
+    \fn void Q3Ftp::commandStarted( int id )
+
+    This signal is emitted when processing the command identified by
+    \a id starts.
+
+    \sa commandFinished() done()
+*/
+
+/*!
+    \fn void Q3Ftp::commandFinished( int id, bool error )
+
+    This signal is emitted when processing the command identified by
+    \a id has finished. \a error is true if an error occurred during
+    the processing; otherwise \a error is false.
+
+    \sa commandStarted() done() error() errorString()
+*/
+
+/*!
+    \fn void Q3Ftp::done( bool error )
+
+    This signal is emitted when the last pending command has finished;
+    (it is emitted after the last command's commandFinished() signal).
+    \a error is true if an error occurred during the processing;
+    otherwise \a error is false.
+
+    \sa commandFinished() error() errorString()
+*/
+
+/*!
+    \fn void Q3Ftp::readyRead()
+
+    This signal is emitted in response to a get() command when there
+    is new data to read.
+
+    If you specify a device as the second argument in the get()
+    command, this signal is \e not emitted; instead the data is
+    written directly to the device.
+
+    You can read the data with the readAll() or readBlock() functions.
+
+    This signal is useful if you want to process the data in chunks as
+    soon as it becomes available. If you are only interested in the
+    complete data, just connect to the commandFinished() signal and
+    read the data then instead.
+
+    \sa get() readBlock() readAll() bytesAvailable()
+*/
+
+/*!
+    \fn void Q3Ftp::dataTransferProgress( int done, int total )
+
+    This signal is emitted in response to a get() or put() request to
+    indicate the current progress of the download or upload.
+
+    \a done is the amount of data that has already been transferred
+    and \a total is the total amount of data to be read or written. It
+    is possible that the Q3Ftp class is not able to determine the total
+    amount of data that should be transferred, in which case \a total
+    is 0. (If you connect this signal to a QProgressBar, the progress
+    bar shows a busy indicator if the total is 0).
+
+    \warning \a done and \a total are not necessarily the size in
+    bytes, since for large files these values might need to be
+    "scaled" to avoid overflow.
+
+    \sa get() put()
+*/
+
+/*!
+    \fn void Q3Ftp::rawCommandReply( int replyCode, const QString &detail );
+
+    This signal is emitted in response to the rawCommand() function.
+    \a replyCode is the 3 digit reply code and \a detail is the text
+    that follows the reply code.
+
+    \sa rawCommand()
+*/
+
+/*!
+    Connects to the FTP server \a host using port \a port.
+
+    The stateChanged() signal is emitted when the state of the
+    connecting process changes, e.g. to \c HostLookup, then \c
+    Connecting, then \c Connected.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa stateChanged() commandStarted() commandFinished()
+*/
+int Q3Ftp::connectToHost( const QString &host, Q_UINT16 port )
+{
+    QStringList cmds;
+    cmds << host;
+    cmds << QString::number( (uint)port );
+    return addCommand( new Q3FtpCommand( ConnectToHost, cmds ) );
+}
+
+/*!
+    Logs in to the FTP server with the username \a user and the
+    password \a password.
+
+    The stateChanged() signal is emitted when the state of the
+    connecting process changes, e.g. to \c LoggedIn.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa commandStarted() commandFinished()
+*/
+int Q3Ftp::login( const QString &user, const QString &password )
+{
+    QStringList cmds;
+    cmds << ( QString(QLatin1String("USER ")) + ( user.isNull() ? QString(QLatin1String("anonymous")) : user ) + QLatin1String("\r\n") );
+    cmds << ( QString(QLatin1String("PASS ")) + ( password.isNull() ? QString(QLatin1String("anonymous@")) : password ) + QLatin1String("\r\n") );
+    return addCommand( new Q3FtpCommand( Login, cmds ) );
+}
+
+/*!
+    Closes the connection to the FTP server.
+
+    The stateChanged() signal is emitted when the state of the
+    connecting process changes, e.g. to \c Closing, then \c
+    Unconnected.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa stateChanged() commandStarted() commandFinished()
+*/
+int Q3Ftp::close()
+{
+    return addCommand( new Q3FtpCommand( Close, QStringList(QLatin1String("QUIT\r\n")) ) );
+}
+
+/*!
+    Lists the contents of directory \a dir on the FTP server. If \a
+    dir is empty, it lists the contents of the current directory.
+
+    The listInfo() signal is emitted for each directory entry found.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa listInfo() commandStarted() commandFinished()
+*/
+int Q3Ftp::list( const QString &dir )
+{
+    QStringList cmds;
+    cmds << QLatin1String("TYPE A\r\n");
+    cmds << QLatin1String("PASV\r\n");
+    if ( dir.isEmpty() )
+	cmds << QLatin1String("LIST\r\n");
+    else
+	cmds << ( QLatin1String("LIST ") + dir + QLatin1String("\r\n") );
+    return addCommand( new Q3FtpCommand( List, cmds ) );
+}
+
+/*!
+    Changes the working directory of the server to \a dir.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa commandStarted() commandFinished()
+*/
+int Q3Ftp::cd( const QString &dir )
+{
+    return addCommand( new Q3FtpCommand( Cd, QStringList(QLatin1String("CWD ")+dir+QLatin1String("\r\n")) ) );
+}
+
+/*!
+    Downloads the file \a file from the server.
+
+    If \a dev is 0, then the readyRead() signal is emitted when there
+    is data available to read. You can then read the data with the
+    readBlock() or readAll() functions.
+
+    If \a dev is not 0, the data is written directly to the device \a
+    dev. Make sure that the \a dev pointer is valid for the duration
+    of the operation (it is safe to delete it when the
+    commandFinished() signal is emitted). In this case the readyRead()
+    signal is \e not emitted and you cannot read data with the
+    readBlock() or readAll() functions.
+
+    If you don't read the data immediately it becomes available, i.e.
+    when the readyRead() signal is emitted, it is still available
+    until the next command is started.
+
+    For example, if you want to present the data to the user as soon
+    as there is something available, connect to the readyRead() signal
+    and read the data immediately. On the other hand, if you only want
+    to work with the complete data, you can connect to the
+    commandFinished() signal and read the data when the get() command
+    is finished.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa readyRead() dataTransferProgress() commandStarted()
+    commandFinished()
+*/
+int Q3Ftp::get( const QString &file, QIODevice *dev )
+{
+    QStringList cmds;
+    cmds << ( QLatin1String("SIZE ") + file + QLatin1String("\r\n") );
+    cmds << QLatin1String("TYPE I\r\n");
+    cmds << QLatin1String("PASV\r\n");
+    cmds << ( QLatin1String("RETR ") + file + QLatin1String("\r\n") );
+    if ( dev )
+	return addCommand( new Q3FtpCommand( Get, cmds, dev ) );
+    return addCommand( new Q3FtpCommand( Get, cmds ) );
+}
+
+/*!
+    \overload
+
+    Writes the data \a data to the file called \a file on the server.
+    The progress of the upload is reported by the
+    dataTransferProgress() signal.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa dataTransferProgress() commandStarted() commandFinished()
+*/
+int Q3Ftp::put( const QByteArray &data, const QString &file )
+{
+    QStringList cmds;
+    cmds << QLatin1String("TYPE I\r\n");
+    cmds << QLatin1String("PASV\r\n");
+    cmds << ( QLatin1String("ALLO ") + QString::number(data.size()) + QLatin1String("\r\n") );
+    cmds << ( QLatin1String("STOR ") + file + QLatin1String("\r\n") );
+    return addCommand( new Q3FtpCommand( Put, cmds, data ) );
+}
+
+/*!
+    Reads the data from the IO device \a dev, and writes it to the
+    file called \a file on the server. The data is read in chunks from
+    the IO device, so this overload allows you to transmit large
+    amounts of data without the need to read all the data into memory
+    at once.
+
+    Make sure that the \a dev pointer is valid for the duration of the
+    operation (it is safe to delete it when the commandFinished() is
+    emitted).
+*/
+int Q3Ftp::put( QIODevice *dev, const QString &file )
+{
+    QStringList cmds;
+    cmds << QLatin1String("TYPE I\r\n");
+    cmds << QLatin1String("PASV\r\n");
+    if ( !dev->isSequentialAccess() )
+	cmds << ( QLatin1String("ALLO ") + QString::number(dev->size()) + QLatin1String("\r\n") );
+    cmds << ( QLatin1String("STOR ") + file + QLatin1String("\r\n") );
+    return addCommand( new Q3FtpCommand( Put, cmds, dev ) );
+}
+
+/*!
+    Deletes the file called \a file from the server.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa commandStarted() commandFinished()
+*/
+int Q3Ftp::remove( const QString &file )
+{
+    return addCommand( new Q3FtpCommand( Remove, QStringList(QLatin1String("DELE ")+file+QLatin1String("\r\n")) ) );
+}
+
+/*!
+    Creates a directory called \a dir on the server.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa commandStarted() commandFinished()
+*/
+int Q3Ftp::mkdir( const QString &dir )
+{
+    return addCommand( new Q3FtpCommand( Mkdir, QStringList(QLatin1String("MKD ")+dir+QLatin1String("\r\n")) ) );
+}
+
+/*!
+    Removes the directory called \a dir from the server.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa commandStarted() commandFinished()
+*/
+int Q3Ftp::rmdir( const QString &dir )
+{
+    return addCommand( new Q3FtpCommand( Rmdir, QStringList(QLatin1String("RMD ")+dir+QLatin1String("\r\n")) ) );
+}
+
+/*!
+    Renames the file called \a oldname to \a newname on the server.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa commandStarted() commandFinished()
+*/
+int Q3Ftp::rename( const QString &oldname, const QString &newname )
+{
+    QStringList cmds;
+    cmds << ( QLatin1String("RNFR ") + oldname + QLatin1String("\r\n") );
+    cmds << ( QLatin1String("RNTO ") + newname + QLatin1String("\r\n") );
+    return addCommand( new Q3FtpCommand( Rename, cmds ) );
+}
+
+/*!
+    Sends the raw FTP command \a command to the FTP server. This is
+    useful for low-level FTP access. If the operation you wish to
+    perform has an equivalent Q3Ftp function, we recommend using the
+    function instead of raw FTP commands since the functions are
+    easier and safer.
+
+    The function does not block and returns immediately. The command
+    is scheduled, and its execution is performed asynchronously. The
+    function returns a unique identifier which is passed by
+    commandStarted() and commandFinished().
+
+    When the command is started the commandStarted() signal is
+    emitted. When it is finished the commandFinished() signal is
+    emitted.
+
+    \sa rawCommandReply() commandStarted() commandFinished()
+*/
+int Q3Ftp::rawCommand( const QString &command )
+{
+    QString cmd = command.stripWhiteSpace() + QLatin1String("\r\n");
+    return addCommand( new Q3FtpCommand( RawCommand, QStringList(cmd) ) );
+}
+
+/*!
+    Returns the number of bytes that can be read from the data socket
+    at the moment.
+
+    \sa get() readyRead() readBlock() readAll()
+*/
+Q_ULONG Q3Ftp::bytesAvailable() const
+{
+    Q3FtpPrivate *d = dHelper( this );
+    return d->pi.dtp.bytesAvailable();
+}
+
+/*!
+    Reads \a maxlen bytes from the data socket into \a data and
+    returns the number of bytes read. Returns -1 if an error occurred.
+
+    \sa get() readyRead() bytesAvailable() readAll()
+*/
+Q_LONG Q3Ftp::readBlock( char *data, Q_ULONG maxlen )
+{
+    Q3FtpPrivate *d = dHelper( this );
+    return d->pi.dtp.readBlock( data, maxlen );
+}
+
+/*!
+    Reads all the bytes available from the data socket and returns
+    them.
+
+    \sa get() readyRead() bytesAvailable() readBlock()
+*/
+QByteArray Q3Ftp::readAll()
+{
+    Q3FtpPrivate *d = dHelper( this );
+    return d->pi.dtp.readAll();
+}
+
+/*!
+    Aborts the current command and deletes all scheduled commands.
+
+    If there is an unfinished command (i.e. a command for which the
+    commandStarted() signal has been emitted, but for which the
+    commandFinished() signal has not been emitted), this function
+    sends an \c ABORT command to the server. When the server replies
+    that the command is aborted, the commandFinished() signal with the
+    \c error argument set to \c true is emitted for the command. Due
+    to timing issues, it is possible that the command had already
+    finished before the abort request reached the server, in which
+    case, the commandFinished() signal is emitted with the \c error
+    argument set to \c false.
+
+    For all other commands that are affected by the abort(), no
+    signals are emitted.
+
+    If you don't start further FTP commands directly after the
+    abort(), there won't be any scheduled commands and the done()
+    signal is emitted.
+
+    \warning Some FTP servers, for example the BSD FTP daemon (version
+    0.3), wrongly return a positive reply even when an abort has
+    occurred. For these servers the commandFinished() signal has its
+    error flag set to \c false, even though the command did not
+    complete successfully.
+
+    \sa clearPendingCommands()
+*/
+void Q3Ftp::abort()
+{
+    Q3FtpPrivate *d = dHelper( this );
+    if ( d->pending.isEmpty() )
+	return;
+
+    clearPendingCommands();
+    d->pi.abort();
+}
+
+/*!
+    Returns the identifier of the FTP command that is being executed
+    or 0 if there is no command being executed.
+
+    \sa currentCommand()
+*/
+int Q3Ftp::currentId() const
+{
+    Q3FtpPrivate *d = dHelper( this );
+    Q3FtpCommand *c = d->pending.getFirst();
+    if ( c == 0 )
+	return 0;
+    return c->id;
+}
+
+/*!
+    Returns the command type of the FTP command being executed or \c
+    None if there is no command being executed.
+
+    \sa currentId()
+*/
+Q3Ftp::Command Q3Ftp::currentCommand() const
+{
+    Q3FtpPrivate *d = dHelper( this );
+    Q3FtpCommand *c = d->pending.getFirst();
+    if ( c == 0 )
+	return None;
+    return c->command;
+}
+
+/*!
+    Returns the QIODevice pointer that is used by the FTP command to read data
+    from or store data to. If there is no current FTP command being executed or
+    if the command does not use an IO device, this function returns 0.
+
+    This function can be used to delete the QIODevice in the slot connected to
+    the commandFinished() signal.
+
+    \sa get() put()
+*/
+QIODevice* Q3Ftp::currentDevice() const
+{
+    Q3FtpPrivate *d = dHelper( this );
+    Q3FtpCommand *c = d->pending.getFirst();
+    if ( !c )
+	return 0;
+    if ( c->is_ba )
+	return 0;
+    return c->data.dev;
+}
+
+/*!
+    Returns true if there are any commands scheduled that have not yet
+    been executed; otherwise returns false.
+
+    The command that is being executed is \e not considered as a
+    scheduled command.
+
+    \sa clearPendingCommands() currentId() currentCommand()
+*/
+bool Q3Ftp::hasPendingCommands() const
+{
+    Q3FtpPrivate *d = dHelper( this );
+    return d->pending.count() > 1;
+}
+
+/*!
+    Deletes all pending commands from the list of scheduled commands.
+    This does not affect the command that is being executed. If you
+    want to stop this as well, use abort().
+
+    \sa hasPendingCommands() abort()
+*/
+void Q3Ftp::clearPendingCommands()
+{
+    Q3FtpPrivate *d = dHelper( this );
+    Q3FtpCommand *c = 0;
+    if ( d->pending.count() > 0 )
+	c = d->pending.take( 0 );
+    d->pending.clear();
+    if ( c )
+	d->pending.append( c );
+}
+
+/*!
+    Returns the current state of the object. When the state changes,
+    the stateChanged() signal is emitted.
+
+    \sa State stateChanged()
+*/
+Q3Ftp::State Q3Ftp::state() const
+{
+    Q3FtpPrivate *d = dHelper( this );
+    return d->state;
+}
+
+/*!
+    Returns the last error that occurred. This is useful to find out
+    what when wrong when receiving a commandFinished() or a done()
+    signal with the \c error argument set to \c true.
+
+    If you start a new command, the error status is reset to \c NoError.
+*/
+Q3Ftp::Error Q3Ftp::error() const
+{
+    Q3FtpPrivate *d = dHelper( this );
+    return d->error;
+}
+
+/*!
+    Returns a human-readable description of the last error that
+    occurred. This is useful for presenting a error message to the
+    user when receiving a commandFinished() or a done() signal with
+    the \c error argument set to \c true.
+
+    The error string is often (but not always) the reply from the
+    server, so it is not always possible to translate the string. If
+    the message comes from Qt, the string has already passed through
+    tr().
+*/
+QString Q3Ftp::errorString() const
+{
+    Q3FtpPrivate *d = dHelper( this );
+    return d->errorString;
+}
+
+int Q3Ftp::addCommand( Q3FtpCommand *cmd )
+{
+    Q3FtpPrivate *d = dHelper( this );
+    d->pending.append( cmd );
+
+    if ( d->pending.count() == 1 )
+	// don't emit the commandStarted() signal before the id is returned
+	QTimer::singleShot( 0, this, SLOT(startNextCommand()) );
+
+    return cmd->id;
+}
+
+void Q3Ftp::startNextCommand()
+{
+    Q3FtpPrivate *d = dHelper( this );
+
+    Q3FtpCommand *c = d->pending.getFirst();
+    if ( c == 0 )
+	return;
+
+    d->error = NoError;
+    d->errorString = QFtp::tr( "Unknown error" );
+
+    if ( bytesAvailable() )
+	readAll(); // clear the data
+    emit commandStarted( c->id );
+
+    if ( c->command == ConnectToHost ) {
+	d->pi.connectToHost( c->rawCmds[0], c->rawCmds[1].toUInt() );
+    } else {
+	if ( c->command == Put ) {
+	    if ( c->is_ba ) {
+		d->pi.dtp.setData( c->data.ba );
+		d->pi.dtp.setBytesTotal( c->data.ba->size() );
+	    } else if ( c->data.dev && (c->data.dev->isOpen() || c->data.dev->open(QIODevice::ReadOnly)) ) {
+		d->pi.dtp.setDevice( c->data.dev );
+		if ( c->data.dev->isSequentialAccess() )
+		    d->pi.dtp.setBytesTotal( 0 );
+		else
+		    d->pi.dtp.setBytesTotal( c->data.dev->size() );
+	    }
+	} else if ( c->command == Get ) {
+	    if ( !c->is_ba && c->data.dev ) {
+		d->pi.dtp.setDevice( c->data.dev );
+	    }
+	} else if ( c->command == Close ) {
+	    d->state = Q3Ftp::Closing;
+	    emit stateChanged( d->state );
+	}
+	if ( !d->pi.sendCommands( c->rawCmds ) ) {
+	    // ### error handling (this case should not happen)
+	}
+    }
+}
+
+void Q3Ftp::piFinished( const QString& )
+{
+    Q3FtpPrivate *d = dHelper( this );
+    Q3FtpCommand *c = d->pending.getFirst();
+    if ( c == 0 )
+	return;
+
+    if ( c->command == Close ) {
+	// The order of in which the slots are called is arbitrary, so
+	// disconnect the SIGNAL-SIGNAL temporary to make sure that we
+	// don't get the commandFinished() signal before the stateChanged()
+	// signal.
+	if ( d->state != Q3Ftp::Unconnected ) {
+	    d->close_waitForStateChange = true;
+	    return;
+	}
+    }
+    emit commandFinished( c->id, false );
+
+    d->pending.removeFirst();
+    if ( d->pending.isEmpty() ) {
+	emit done( false );
+    } else {
+	startNextCommand();
+    }
+}
+
+void Q3Ftp::piError( int errorCode, const QString &text )
+{
+    Q3FtpPrivate *d = dHelper( this );
+    Q3FtpCommand *c = d->pending.getFirst();
+
+    // non-fatal errors
+    if ( c->command==Get && d->pi.currentCommand().startsWith(QLatin1String("SIZE ")) ) {
+	d->pi.dtp.setBytesTotal( -1 );
+	return;
+    } else if ( c->command==Put && d->pi.currentCommand().startsWith(QLatin1String("ALLO ")) ) {
+	return;
+    }
+
+    d->error = (Error)errorCode;
+    switch ( currentCommand() ) {
+	case ConnectToHost:
+	    d->errorString = QFtp::tr( "Connecting to host failed:\n%1" ).arg( text );
+	    break;
+	case Login:
+	    d->errorString = QFtp::tr( "Login failed:\n%1" ).arg( text );
+	    break;
+	case List:
+	    d->errorString = QFtp::tr( "Listing directory failed:\n%1" ).arg( text );
+	    break;
+	case Cd:
+	    d->errorString = QFtp::tr( "Changing directory failed:\n%1" ).arg( text );
+	    break;
+	case Get:
+	    d->errorString = QFtp::tr( "Downloading file failed:\n%1" ).arg( text );
+	    break;
+	case Put:
+	    d->errorString = QFtp::tr( "Uploading file failed:\n%1" ).arg( text );
+	    break;
+	case Remove:
+	    d->errorString = QFtp::tr( "Removing file failed:\n%1" ).arg( text );
+	    break;
+	case Mkdir:
+	    d->errorString = QFtp::tr( "Creating directory failed:\n%1" ).arg( text );
+	    break;
+	case Rmdir:
+	    d->errorString = QFtp::tr( "Removing directory failed:\n%1" ).arg( text );
+	    break;
+	default:
+	    d->errorString = text;
+	    break;
+    }
+
+    d->pi.clearPendingCommands();
+    clearPendingCommands();
+    emit commandFinished( c->id, true );
+
+    d->pending.removeFirst();
+    if ( d->pending.isEmpty() )
+	emit done( true );
+    else
+	startNextCommand();
+}
+
+void Q3Ftp::piConnectState( int state )
+{
+    Q3FtpPrivate *d = dHelper( this );
+    d->state = (State)state;
+    emit stateChanged( d->state );
+    if ( d->close_waitForStateChange ) {
+	d->close_waitForStateChange = false;
+	piFinished( QFtp::tr( "Connection closed" ) );
+    }
+}
+
+void Q3Ftp::piFtpReply( int code, const QString &text )
+{
+    if ( currentCommand() == RawCommand ) {
+	Q3FtpPrivate *d = dHelper( this );
+	d->pi.rawCommand = true;
+	emit rawCommandReply( code, text );
+    }
+}
+
+/*!
+    Destructor.
+*/
+Q3Ftp::~Q3Ftp()
+{
+    abort();
+    close();
+    delete_d( this );
+}
+
+/**********************************************************************
+ *
+ * Q3Ftp implementation of the Q3NetworkProtocol interface
+ *
+ *********************************************************************/
+/*!  \reimp
+*/
+void Q3Ftp::operationListChildren( Q3NetworkOperation *op )
+{
+    op->setState( StInProgress );
+
+    cd( ( url()->path().isEmpty() ? QString( QLatin1String("/") ) : url()->path() ) );
+    list();
+    emit start( op );
+}
+
+/*!  \reimp
+*/
+void Q3Ftp::operationMkDir( Q3NetworkOperation *op )
+{
+    op->setState( StInProgress );
+
+    mkdir( op->arg( 0 ) );
+}
+
+/*!  \reimp
+*/
+void Q3Ftp::operationRemove( Q3NetworkOperation *op )
+{
+    op->setState( StInProgress );
+
+    cd( ( url()->path().isEmpty() ? QString( QLatin1String("/") ) : url()->path() ) );
+    remove( Q3Url( op->arg( 0 ) ).path() );
+}
+
+/*!  \reimp
+*/
+void Q3Ftp::operationRename( Q3NetworkOperation *op )
+{
+    op->setState( StInProgress );
+
+    cd( ( url()->path().isEmpty() ? QString( QLatin1String("/") ) : url()->path() ) );
+    rename( op->arg( 0 ), op->arg( 1 ));
+}
+
+/*!  \reimp
+*/
+void Q3Ftp::operationGet( Q3NetworkOperation *op )
+{
+    op->setState( StInProgress );
+
+    Q3Url u( op->arg( 0 ) );
+    get( u.path() );
+}
+
+/*!  \reimp
+*/
+void Q3Ftp::operationPut( Q3NetworkOperation *op )
+{
+    op->setState( StInProgress );
+
+    Q3Url u( op->arg( 0 ) );
+    put( op->rawArg(1), u.path() );
+}
+
+/*!  \reimp
+*/
+bool Q3Ftp::checkConnection( Q3NetworkOperation *op )
+{
+    Q3FtpPrivate *d = dHelper( this );
+    if ( state() == Unconnected && !d->npWaitForLoginDone ) {
+	connect( this, SIGNAL(listInfo(QUrlInfo)),
+		this, SLOT(npListInfo(QUrlInfo)) );
+	connect( this, SIGNAL(done(bool)),
+		this, SLOT(npDone(bool)) );
+	connect( this, SIGNAL(stateChanged(int)),
+		this, SLOT(npStateChanged(int)) );
+	connect( this, SIGNAL(dataTransferProgress(int,int)),
+		this, SLOT(npDataTransferProgress(int,int)) );
+	connect( this, SIGNAL(readyRead()),
+		this, SLOT(npReadyRead()) );
+
+	d->npWaitForLoginDone = true;
+	switch ( op->operation() ) {
+	    case OpGet:
+	    case OpPut:
+		{
+		    Q3Url u( op->arg( 0 ) );
+		    connectToHost( u.host(), u.port() != -1 ? u.port() : 21 );
+		}
+		break;
+	    default:
+		connectToHost( url()->host(), url()->port() != -1 ? url()->port() : 21 );
+		break;
+	}
+	QString user = url()->user().isEmpty() ? QString( QLatin1String("anonymous") ) : url()->user();
+	QString pass = url()->password().isEmpty() ? QString( QLatin1String("anonymous@") ) : url()->password();
+	login( user, pass );
+    }
+
+    if ( state() == LoggedIn )
+	return true;
+    return false;
+}
+
+/*!  \reimp
+*/
+int Q3Ftp::supportedOperations() const
+{
+    return OpListChildren | OpMkDir | OpRemove | OpRename | OpGet | OpPut;
+}
+
+/*! \internal
+    Parses the string, \a buffer, which is one line of a directory
+    listing which came from the FTP server, and sets the values which
+    have been parsed to the url info object, \a info.
+*/
+void Q3Ftp::parseDir( const QString &buffer, QUrlInfo &info )
+{
+    Q3FtpDTP::parseDir( buffer, url()->user(), &info );
+}
+
+void Q3Ftp::npListInfo( const QUrlInfo & i )
+{
+    if ( url() ) {
+	QRegExp filt( url()->nameFilter(), false, true );
+	if ( i.isDir() || filt.search( i.name() ) != -1 ) {
+	    emit newChild( i, operationInProgress() );
+	}
+    } else {
+	emit newChild( i, operationInProgress() );
+    }
+}
+
+void Q3Ftp::npDone( bool err )
+{
+    Q3FtpPrivate *d = dHelper( this );
+
+    bool emitFinishedSignal = false;
+    Q3NetworkOperation *op = operationInProgress();
+    if ( op ) {
+	if ( err ) {
+	    op->setProtocolDetail( errorString() );
+	    op->setState( StFailed );
+	    if ( error() == HostNotFound ) {
+		op->setErrorCode( (int)ErrHostNotFound );
+	    } else {
+		switch ( op->operation() ) {
+		    case OpListChildren:
+			op->setErrorCode( (int)ErrListChildren );
+			break;
+		    case OpMkDir:
+			op->setErrorCode( (int)ErrMkDir );
+			break;
+		    case OpRemove:
+			op->setErrorCode( (int)ErrRemove );
+			break;
+		    case OpRename:
+			op->setErrorCode( (int)ErrRename );
+			break;
+		    case OpGet:
+			op->setErrorCode( (int)ErrGet );
+			break;
+		    case OpPut:
+			op->setErrorCode( (int)ErrPut );
+			break;
+		}
+	    }
+	    emitFinishedSignal = true;
+	} else if ( !d->npWaitForLoginDone ) {
+	    switch ( op->operation() ) {
+		case OpRemove:
+		    emit removed( op );
+		    break;
+		case OpMkDir:
+		    {
+			QUrlInfo inf( op->arg( 0 ), 0, QLatin1String(""), QLatin1String(""), 0, QDateTime(),
+				QDateTime(), true, false, false, true, true, true );
+			emit newChild( inf, op );
+			emit createdDirectory( inf, op );
+		    }
+		    break;
+		case OpRename:
+		    emit itemChanged( operationInProgress() );
+		    break;
+		default:
+		    break;
+	    }
+	    op->setState( StDone );
+	    emitFinishedSignal = true;
+	}
+    }
+    d->npWaitForLoginDone = false;
+
+    if ( state() == Unconnected ) {
+	disconnect( this, SIGNAL(listInfo(QUrlInfo)),
+		    this, SLOT(npListInfo(QUrlInfo)) );
+	disconnect( this, SIGNAL(done(bool)),
+		    this, SLOT(npDone(bool)) );
+	disconnect( this, SIGNAL(stateChanged(int)),
+		    this, SLOT(npStateChanged(int)) );
+	disconnect( this, SIGNAL(dataTransferProgress(int,int)),
+		    this, SLOT(npDataTransferProgress(int,int)) );
+	disconnect( this, SIGNAL(readyRead()),
+		    this, SLOT(npReadyRead()) );
+    }
+
+    // emit the finished() signal at the very end to avoid reentrance problems
+    if ( emitFinishedSignal )
+	emit finished( op );
+}
+
+void Q3Ftp::npStateChanged( int state )
+{
+    if ( url() ) {
+	if ( state == Connecting )
+	    emit connectionStateChanged( ConHostFound, QFtp::tr( "Host %1 found" ).arg( url()->host() ) );
+	else if ( state == Connected )
+	    emit connectionStateChanged( ConConnected, QFtp::tr( "Connected to host %1" ).arg( url()->host() ) );
+	else if ( state == Unconnected )
+	    emit connectionStateChanged( ConClosed, QFtp::tr( "Connection to %1 closed" ).arg( url()->host() ) );
+    } else {
+	if ( state == Connecting )
+	    emit connectionStateChanged( ConHostFound, QFtp::tr( "Host found" ) );
+	else if ( state == Connected )
+	    emit connectionStateChanged( ConConnected, QFtp::tr( "Connected to host" ) );
+	else if ( state == Unconnected )
+	    emit connectionStateChanged( ConClosed, QFtp::tr( "Connection closed" ) );
+    }
+}
+
+void Q3Ftp::npDataTransferProgress( int bDone, int bTotal )
+{
+    emit Q3NetworkProtocol::dataTransferProgress( bDone, bTotal, operationInProgress() );
+}
+
+void Q3Ftp::npReadyRead()
+{
+    emit data( readAll(), operationInProgress() );
+}
+
+/*!  \internal
+*/
+void Q3Ftp::hostFound()
+{
+}
+/*!  \internal
+*/
+void Q3Ftp::connected()
+{
+}
+/*!  \internal
+*/
+void Q3Ftp::closed()
+{
+}
+/*!  \internal
+*/
+void Q3Ftp::dataHostFound()
+{
+}
+/*!  \internal
+*/
+void Q3Ftp::dataConnected()
+{
+}
+/*!  \internal
+*/
+void Q3Ftp::dataClosed()
+{
+}
+/*!  \internal
+*/
+void Q3Ftp::dataReadyRead()
+{
+}
+/*!  \internal
+*/
+void Q3Ftp::dataBytesWritten( int )
+{
+}
+/*!  \internal
+*/
+void Q3Ftp::error( int )
+{
+}
+
+QT_END_NAMESPACE
+
+#include "q3ftp.moc"
+
+#endif // QT_NO_NETWORKPROTOCOL_FTP