diff options
Diffstat (limited to 'experimental/tqtinterface/qt4/src/network/tqftp.cpp')
-rw-r--r-- | experimental/tqtinterface/qt4/src/network/tqftp.cpp | 2421 |
1 files changed, 2421 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/network/tqftp.cpp b/experimental/tqtinterface/qt4/src/network/tqftp.cpp new file mode 100644 index 000000000..7fb239eaf --- /dev/null +++ b/experimental/tqtinterface/qt4/src/network/tqftp.cpp @@ -0,0 +1,2421 @@ +/**************************************************************************** +** +** Implementation of TQFtp class. +** +** Created : 970521 +** +** Copyright (C) 1997-2008 Trolltech ASA. All rights reserved. +** +** This file is part of the network module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include "tqftp.h" + +#ifndef TQT_NO_NETWORKPROTOCOL_FTP + +#include "tqsocket.h" +#include "tqsocketdevice.h" +#include "tqurlinfo.h" +#include "tqurloperator.h" +#include "tqstringlist.h" +#include "tqregexp.h" +#include "tqtimer.h" +#include "tqfileinfo.h" +#include "tqptrdict.h" // binary compatibility + +#ifndef TQT_NO_TEXTCODEC +#include "tqtextcodec.h" +#endif + +//#define TQFTPPI_DEBUG +//#define TQFTPDTP_DEBUG + + +class TQFtpPI; + +class TQFtpDTP : public TQObject +{ + Q_OBJECT + TQ_OBJECT + +public: + enum ConnectState { + CsHostFound, + CsConnected, + CsClosed, + CsHostNotFound, + CsConnectionRefused + }; + + TQFtpDTP( TQFtpPI *p, TQObject *tqparent=0, const char *name=0 ); + + void setData( TQByteArray * ); + void setDevice( TQIODevice * ); + void writeData(); + + void setBytesTotal( int bytes ) + { + bytesTotal = bytes; + bytesDone = 0; + emit dataTransferProgress( bytesDone, bytesTotal ); + } + + bool hasError() const; + TQString errorMessage() const; + void clearError(); + + void connectToHost( const TQString & host, TQ_UINT16 port ) + { socket.connectToHost( host, port ); } + + TQSocket::State socketState() const + { return socket.state(); } + + TQ_ULONG bytesAvailable() const + { return socket.bytesAvailable(); } + + TQ_LONG readBlock( char *data, TQ_ULONG maxlen ) + { + TQ_LONG read = socket.readBlock( data, maxlen ); + bytesDone += read; + return read; + } + + TQByteArray readAll() + { + TQByteArray tmp = TQT_TQBYTEARRAY_OBJECT(socket.readAll()); + bytesDone += tmp.size(); + return tmp; + } + + void abortConnection(); + + static bool parseDir( const TQString &buffer, const TQString &userName, TQUrlInfo *info ); + +Q_SIGNALS: + void listInfo( const TQUrlInfo& ); + void readyRead(); + void dataTransferProgress( int, int ); + + void connectState( int ); + +private Q_SLOTS: + void socketConnected(); + void socketReadyRead(); + void socketError( int ); + void socketConnectionClosed(); + void socketBytesWritten( int ); + +private: + void clearData() + { + is_ba = FALSE; + data.dev = 0; + } + + TQSocket socket; + TQFtpPI *pi; + TQString 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 { + TQByteArray *ba; + TQIODevice *dev; + } data; + bool is_ba; +}; + +class TQFtpPI : public TQObject +{ + Q_OBJECT + TQ_OBJECT + +public: + TQFtpPI( TQObject *tqparent = 0 ); + + void connectToHost( const TQString &host, TQ_UINT16 port ); + + bool sendCommands( const TQStringList &cmds ); + bool sendCommand( const TQString &cmd ) + { return sendCommands( TQStringList( cmd ) ); } + + void clearPendingCommands(); + void abort(); + + TQString currentCommand() const + { return currentCmd; } + + bool rawCommand; + + TQFtpDTP dtp; // the PI has a DTP which is not the design of RFC 959, but it + // makes the design simpler this way +Q_SIGNALS: + void connectState( int ); + void finished( const TQString& ); + void error( int, const TQString& ); + void rawFtpReply( int, const TQString& ); + +private Q_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(); + + TQSocket commandSocket; + TQString replyText; + char replyCode[3]; + State state; + AbortState abortState; + TQStringList pendingCommands; + TQString currentCmd; + + bool waitForDtpToConnect; + bool waitForDtpToClose; +}; + +/********************************************************************** + * + * TQFtpCommand implemenatation + * + *********************************************************************/ +class TQFtpCommand +{ +public: + TQFtpCommand( TQFtp::Command cmd, TQStringList raw ); + TQFtpCommand( TQFtp::Command cmd, TQStringList raw, const TQByteArray &ba ); + TQFtpCommand( TQFtp::Command cmd, TQStringList raw, TQIODevice *dev ); + ~TQFtpCommand(); + + int id; + TQFtp::Command command; + TQStringList rawCmds; + + // If is_ba is TRUE, ba is used; ba is never 0. + // Otherwise dev is used; dev can be 0 or not. + union { + TQByteArray *ba; + TQIODevice *dev; + } data; + bool is_ba; + + static int idCounter; +}; + +int TQFtpCommand::idCounter = 0; + +TQFtpCommand::TQFtpCommand( TQFtp::Command cmd, TQStringList raw ) + : command(cmd), rawCmds(raw), is_ba(FALSE) +{ + id = ++idCounter; + data.dev = 0; +} + +TQFtpCommand::TQFtpCommand( TQFtp::Command cmd, TQStringList raw, const TQByteArray &ba ) + : command(cmd), rawCmds(raw), is_ba(TRUE) +{ + id = ++idCounter; + data.ba = new TQByteArray( ba ); +} + +TQFtpCommand::TQFtpCommand( TQFtp::Command cmd, TQStringList raw, TQIODevice *dev ) + : command(cmd), rawCmds(raw), is_ba(FALSE) +{ + id = ++idCounter; + data.dev = dev; +} + +TQFtpCommand::~TQFtpCommand() +{ + if ( is_ba ) + delete data.ba; +} + +/********************************************************************** + * + * TQFtpDTP implemenatation + * + *********************************************************************/ +TQFtpDTP::TQFtpDTP( TQFtpPI *p, TQObject *tqparent, const char *name ) : + TQObject( tqparent, name ), + socket( 0, "TQFtpDTP_socket" ), + pi( p ), + callWriteData( FALSE ) +{ + clearData(); + + connect( &socket, TQT_SIGNAL( connected() ), + TQT_SLOT( socketConnected() ) ); + connect( &socket, TQT_SIGNAL( readyRead() ), + TQT_SLOT( socketReadyRead() ) ); + connect( &socket, TQT_SIGNAL( error(int) ), + TQT_SLOT( socketError(int) ) ); + connect( &socket, TQT_SIGNAL( connectionClosed() ), + TQT_SLOT( socketConnectionClosed() ) ); + connect( &socket, TQT_SIGNAL( bytesWritten(int) ), + TQT_SLOT( socketBytesWritten(int) ) ); +} + +void TQFtpDTP::setData( TQByteArray *ba ) +{ + is_ba = TRUE; + data.ba = ba; +} + +void TQFtpDTP::setDevice( TQIODevice *dev ) +{ + is_ba = FALSE; + data.dev = dev; +} + +void TQFtpDTP::writeData() +{ + if ( is_ba ) { +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::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 ) { + TQ_LONG read = data.dev->readBlock( buf, blockSize ); +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::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 TQFtpDTP::hasError() const +{ + return !err.isNull(); +} + +inline TQString TQFtpDTP::errorMessage() const +{ + return err; +} + +inline void TQFtpDTP::clearError() +{ + err = TQString::null; +} + +void TQFtpDTP::abortConnection() +{ +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::abortConnection" ); +#endif + callWriteData = FALSE; + clearData(); + + socket.clearPendingData(); + socket.close(); +} + +bool TQFtpDTP::parseDir( const TQString &buffer, const TQString &userName, TQUrlInfo *info ) +{ + TQStringList lst = TQStringList::split( " ", buffer ); + + if ( lst.count() < 9 ) + return FALSE; + + TQString tmp; + + // permissions + tmp = lst[ 0 ]; + + if ( tmp[ 0 ] == TQChar( 'd' ) ) { + info->setDir( TRUE ); + info->setFile( FALSE ); + info->setSymLink( FALSE ); + } else if ( tmp[ 0 ] == TQChar( '-' ) ) { + info->setDir( FALSE ); + info->setFile( TRUE ); + info->setSymLink( FALSE ); + } else if ( tmp[ 0 ] == TQChar( '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 ] == 'r'); + perms[0][1] = (tmp[ 2 ] == 'w'); + perms[0][2] = (tmp[ 3 ] == 'x'); + perms[1][0] = (tmp[ 4 ] == 'r'); + perms[1][1] = (tmp[ 5 ] == 'w'); + perms[1][2] = (tmp[ 6 ] == 'x'); + perms[2][0] = (tmp[ 7 ] == 'r'); + perms[2][1] = (tmp[ 8 ] == 'w'); + perms[2][2] = (tmp[ 9 ] == '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 |= TQUrlInfo::ReadOwner; + if ( perms[ user ][ writable ] ) + p |= TQUrlInfo::WriteOwner; + if ( perms[ user ][ executable ] ) + p |= TQUrlInfo::ExeOwner; + if ( perms[ group ][ readable ] ) + p |= TQUrlInfo::ReadGroup; + if ( perms[ group ][ writable ] ) + p |= TQUrlInfo::WriteGroup; + if ( perms[ group ][ executable ] ) + p |= TQUrlInfo::ExeGroup; + if ( perms[ other ][ readable ] ) + p |= TQUrlInfo::ReadOther; + if ( perms[ other ][ writable ] ) + p |= TQUrlInfo::WriteOther; + if ( perms[ other ][ executable ] ) + p |= TQUrlInfo::ExeOther; + info->setPermissions( p ); + + // size + tmp = lst[ 4 ]; + info->setSize( tmp.toInt() ); + + // date and time + TQTime time; + TQString dateStr; + dateStr += "Sun "; + lst[ 5 ][ 0 ] = lst[ 5 ][ 0 ].upper(); + dateStr += lst[ 5 ]; + dateStr += ' '; + dateStr += lst[ 6 ]; + dateStr += ' '; + + if ( lst[ 7 ].tqcontains( ":" ) ) { + time = TQTime( lst[ 7 ].left( 2 ).toInt(), lst[ 7 ].right( 2 ).toInt() ); + dateStr += TQString::number( TQDate::currentDate().year() ); + } else { + dateStr += lst[ 7 ]; + } + + TQDate date = TQT_TQDATE_OBJECT(TQDate::fromString( dateStr )); + info->setLastModified( TQDateTime( date, time ) ); + + if ( lst[ 7 ].tqcontains( ":" ) ) { + const int futureTolerance = 600; + if( info->lastModified().secsTo( TQDateTime::tqcurrentDateTime() ) < -futureTolerance ) { + TQDateTime dt = info->lastModified(); + TQDate d = TQT_TQDATE_OBJECT(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 { + TQString n; + for ( uint i = 8; i < lst.count(); ++i ) + n += lst[ i ] + " "; + n = n.stripWhiteSpace(); + info->setName( n ); + } + return TRUE; +} + +void TQFtpDTP::socketConnected() +{ +#if !defined (TQ_WS_TQWS) + // 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(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::connectState( CsConnected )" ); +#endif + emit connectState( TQFtpDTP::CsConnected ); +} + +void TQFtpDTP::socketReadyRead() +{ + if ( pi->currentCommand().isEmpty() ) { + socket.close(); +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::connectState( CsClosed )" ); +#endif + emit connectState( TQFtpDTP::CsClosed ); + return; + } + + if ( pi->currentCommand().startsWith("LIST") ) { + while ( socket.canReadLine() ) { + TQUrlInfo i; + TQString line = socket.readLine(); +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP read (list): '%s'", line.latin1() ); +#endif + if ( parseDir( line, "", &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( "No such file or directory\r\n" ) ) + err = line; + } + } + } else { + if ( !is_ba && data.dev ) { + TQByteArray ba( socket.bytesAvailable() ); + TQ_LONG bytesRead = socket.readBlock( ba.data(), ba.size() ); + if ( bytesRead < 0 ) { + // ### error handling + return; + } + ba.resize( bytesRead ); + bytesDone += bytesRead; +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP 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(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP readyRead: %d bytes available (total %d bytes read)", (int)bytesAvailable(), bytesDone ); +#endif + emit dataTransferProgress( bytesDone+socket.bytesAvailable(), bytesTotal ); + emit readyRead(); + } + } +} + +void TQFtpDTP::socketError( int e ) +{ + if ( e == TQSocket::ErrHostNotFound ) { +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::connectState( CsHostNotFound )" ); +#endif + emit connectState( TQFtpDTP::CsHostNotFound ); + } else if ( e == TQSocket::ErrConnectionRefused ) { +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::connectState( CsConnectionRefused )" ); +#endif + emit connectState( TQFtpDTP::CsConnectionRefused ); + } +} + +void TQFtpDTP::socketConnectionClosed() +{ + if ( !is_ba && data.dev ) { + clearData(); + } +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::connectState( CsClosed )" ); +#endif + emit connectState( TQFtpDTP::CsClosed ); +} + +void TQFtpDTP::socketBytesWritten( int bytes ) +{ + bytesDone += bytes; +#if defined(TQFTPDTP_DEBUG) + qDebug( "TQFtpDTP::bytesWritten( %d )", bytesDone ); +#endif + emit dataTransferProgress( bytesDone, bytesTotal ); + if ( callWriteData ) + writeData(); +} + +/********************************************************************** + * + * TQFtpPI implemenatation + * + *********************************************************************/ +TQFtpPI::TQFtpPI( TQObject *tqparent ) : + TQObject( tqparent ), + rawCommand(FALSE), + dtp( this ), + commandSocket( 0, "TQFtpPI_socket" ), + state( Begin ), abortState( None ), + currentCmd( TQString::null ), + waitForDtpToConnect( FALSE ), + waitForDtpToClose( FALSE ) +{ + connect( &commandSocket, TQT_SIGNAL(hostFound()), + TQT_SLOT(hostFound()) ); + connect( &commandSocket, TQT_SIGNAL(connected()), + TQT_SLOT(connected()) ); + connect( &commandSocket, TQT_SIGNAL(connectionClosed()), + TQT_SLOT(connectionClosed()) ); + connect( &commandSocket, TQT_SIGNAL(delayedCloseFinished()), + TQT_SLOT(delayedCloseFinished()) ); + connect( &commandSocket, TQT_SIGNAL(readyRead()), + TQT_SLOT(readyRead()) ); + connect( &commandSocket, TQT_SIGNAL(error(int)), + TQT_SLOT(error(int)) ); + + connect( &dtp, TQT_SIGNAL(connectState(int)), + TQT_SLOT(dtpConnectState(int)) ); +} + +void TQFtpPI::connectToHost( const TQString &host, TQ_UINT16 port ) +{ + emit connectState( TQFtp::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 TQFtpPI::sendCommands( const TQStringList &cmds ) +{ + if ( !pendingCommands.isEmpty() ) + return FALSE; + + if ( commandSocket.state()!=TQSocket::Connected || state!=Idle ) { + emit error( TQFtp::NotConnected, TQFtp::tr( "Not connected" ) ); + return TRUE; // there are no pending commands + } + + pendingCommands = cmds; + startNextCmd(); + return TRUE; +} + +void TQFtpPI::clearPendingCommands() +{ + pendingCommands.clear(); + dtp.abortConnection(); + currentCmd = TQString::null; + state = Idle; +} + +void TQFtpPI::abort() +{ + pendingCommands.clear(); + + if ( abortState != None ) + // ABOR already sent + return; + + abortState = AbortStarted; +#if defined(TQFTPPI_DEBUG) + qDebug( "TQFtpPI send: ABOR" ); +#endif + commandSocket.writeBlock( "ABOR\r\n", 6 ); + + if ( currentCmd.startsWith("STOR ") ) + dtp.abortConnection(); +} + +void TQFtpPI::hostFound() +{ + emit connectState( TQFtp::Connecting ); +} + +void TQFtpPI::connected() +{ + state = Begin; +#if defined(TQFTPPI_DEBUG) +// qDebug( "TQFtpPI state: %d [connected()]", state ); +#endif + emit connectState( TQFtp::Connected ); +} + +void TQFtpPI::connectionClosed() +{ + commandSocket.close(); + emit connectState( TQFtp::Unconnected ); +} + +void TQFtpPI::delayedCloseFinished() +{ + emit connectState( TQFtp::Unconnected ); +} + +void TQFtpPI::error( int e ) +{ + if ( e == TQSocket::ErrHostNotFound ) { + emit connectState( TQFtp::Unconnected ); + emit error( TQFtp::HostNotFound, + TQFtp::tr( "Host %1 not found" ).arg( commandSocket.peerName() ) ); + } else if ( e == TQSocket::ErrConnectionRefused ) { + emit connectState( TQFtp::Unconnected ); + emit error( TQFtp::ConnectionRefused, + TQFtp::tr( "Connection refused to host %1" ).arg( commandSocket.peerName() ) ); + } +} + +void TQFtpPI::readyRead() +{ + if ( waitForDtpToClose ) + return; + + while ( commandSocket.canReadLine() ) { + // read line with respect to line continuation + TQString line = 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; + } + } + } + TQString endOfMultiLine; + endOfMultiLine[0] = '0' + replyCode[0]; + endOfMultiLine[1] = '0' + replyCode[1]; + endOfMultiLine[2] = '0' + replyCode[2]; + endOfMultiLine[3] = ' '; + TQString lineCont( endOfMultiLine ); + lineCont[3] = '-'; + TQString lineLeft4 = line.left(4); + + while ( lineLeft4 != endOfMultiLine ) { + if ( lineLeft4 == lineCont ) + replyText += line.mid( 4 ); // strip 'xyz-' + else + replyText += line; + if ( !commandSocket.canReadLine() ) + return; + line = commandSocket.readLine(); + lineLeft4 = line.left(4); + } + replyText += line.mid( 4 ); // strip reply code 'xyz ' + if ( replyText.endsWith("\r\n") ) + replyText.truncate( replyText.length()-2 ); + + if ( processReply() ) + replyText = ""; + } +} + +/* + 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 TQFtpPI::processReply() +{ +#if defined(TQFTPPI_DEBUG) +// qDebug( "TQFtpPI state: %d [processReply() begin]", state ); + if ( replyText.length() < 400 ) + qDebug( "TQFtpPI recv: %d %s", 100*replyCode[0]+10*replyCode[1]+replyCode[2], replyText.latin1() ); + else + qDebug( "TQFtpPI 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() != TQSocket::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( TQFtp::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 + state = table[ replyCode[0] - 1 ]; + break; + default: + // ### spontaneous message + return TRUE; + } +#if defined(TQFTPPI_DEBUG) +// qDebug( "TQFtpPI 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. + TQRegExp addrPortPattern("(\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)"); + if (addrPortPattern.search(replyText) == -1) { +#if defined(TQFTPPI_DEBUG) + qDebug( "TQFtp: bad 227 response -- address and port information missing" ); +#endif + // ### error handling + } else { + QStringList lst = addrPortPattern.capturedTexts(); + TQString host = lst[1] + "." + lst[2] + "." + lst[3] + "." + lst[4]; + TQ_UINT16 port = ( lst[5].toUInt() << 8 ) + lst[6].toUInt(); + waitForDtpToConnect = TRUE; + dtp.connectToHost( host, port ); + } + } else if ( replyCodeInt == 230 ) { + if ( currentCmd.startsWith("USER ") && pendingCommands.count()>0 && + pendingCommands.first().startsWith("PASS ") ) { + // no need to send the PASS -- we are already logged in + pendingCommands.pop_front(); + } + // 230 User logged in, proceed. + emit connectState( TQFtp::LoggedIn ); + } else if ( replyCodeInt == 213 ) { + // 213 File status. + if ( currentCmd.startsWith("SIZE ") ) + dtp.setBytesTotal( replyText.simplifyWhiteSpace().toInt() ); + } else if ( replyCode[0]==1 && currentCmd.startsWith("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( TQFtp::UnknownError, dtp.errorMessage() ); + dtp.clearError(); + } + startNextCmd(); + break; + case Waiting: + // ### do nothing + break; + case Failure: + emit error( TQFtp::UnknownError, replyText ); + state = Idle; + startNextCmd(); + break; + } +#if defined(TQFTPPI_DEBUG) +// qDebug( "TQFtpPI state: %d [processReply() end]", state ); +#endif + return TRUE; +} + +#ifndef TQT_NO_TEXTCODEC +TQM_EXPORT_FTP TQTextCodec *qt_ftp_filename_codec = 0; +#endif + +/* + Starts next pending command. Returns FALSE if there are no pending commands, + otherwise it returns TRUE. +*/ +bool TQFtpPI::startNextCmd() +{ + if ( waitForDtpToConnect ) + // don't process any new commands until we are connected + return TRUE; + +#if defined(TQFTPPI_DEBUG) + if ( state != Idle ) + qDebug( "TQFtpPI startNextCmd: Internal error! TQFtpPI called in non-Idle state %d", state ); +#endif + if ( pendingCommands.isEmpty() ) { + currentCmd = TQString::null; + emit finished( replyText ); + return FALSE; + } + currentCmd = pendingCommands.first(); + pendingCommands.pop_front(); +#if defined(TQFTPPI_DEBUG) + qDebug( "TQFtpPI send: %s", currentCmd.left( currentCmd.length()-2 ).latin1() ); +#endif + state = Waiting; +#ifndef TQT_NO_TEXTCODEC + if ( qt_ftp_filename_codec ) { + int len = 0; + TQCString enc = qt_ftp_filename_codec->fromUnicode(currentCmd,len); + commandSocket.writeBlock( enc.data(), len ); + } else +#endif + { + commandSocket.writeBlock( currentCmd.latin1(), currentCmd.length() ); + } + return TRUE; +} + +void TQFtpPI::dtpConnectState( int s ) +{ + switch ( s ) { + case TQFtpDTP::CsClosed: + if ( waitForDtpToClose ) { + // there is an unprocessed reply + if ( processReply() ) + replyText = ""; + else + return; + } + waitForDtpToClose = FALSE; + readyRead(); + return; + case TQFtpDTP::CsConnected: + waitForDtpToConnect = FALSE; + startNextCmd(); + return; + case TQFtpDTP::CsHostNotFound: + case TQFtpDTP::CsConnectionRefused: + emit error( TQFtp::ConnectionRefused, + TQFtp::tr( "Connection refused for data connection" ) ); + startNextCmd(); + return; + default: + return; + } +} + +/********************************************************************** + * + * TQFtpPrivate + * + *********************************************************************/ +class TQFtpPrivate +{ +public: + TQFtpPrivate() : + close_waitForStateChange(FALSE), + state( TQFtp::Unconnected ), + error( TQFtp::NoError ), + npWaitForLoginDone( FALSE ) + { pending.setAutoDelete( TRUE ); } + + TQFtpPI pi; + TQPtrList<TQFtpCommand> pending; + bool close_waitForStateChange; + TQFtp::State state; + TQFtp::Error error; + TQString errorString; + + bool npWaitForLoginDone; +}; + +static TQPtrDict<TQFtpPrivate> *d_ptr = 0; +static void cleanup_d_ptr() +{ + delete d_ptr; + d_ptr = 0; +} +static TQFtpPrivate* d( const TQFtp* foo ) +{ + if ( !d_ptr ) { + d_ptr = new TQPtrDict<TQFtpPrivate>; + d_ptr->setAutoDelete( TRUE ); + qAddPostRoutine( cleanup_d_ptr ); + } + TQFtpPrivate* ret = d_ptr->tqfind( (void*)foo ); + if ( ! ret ) { + ret = new TQFtpPrivate; + d_ptr->tqreplace( (void*) foo, ret ); + } + return ret; +} + +static void delete_d( const TQFtp* foo ) +{ + if ( d_ptr ) + d_ptr->remove( (void*) foo ); +} + +/********************************************************************** + * + * TQFtp implementation + * + *********************************************************************/ +/*! + \class TQFtp tqftp.h + \brief The TQFtp class provides an implementation of the FTP protocol. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup io + \module network + + This class provides two different interfaces: one is the + TQNetworkProtocol interface that allows you to use FTP through the + TQUrlOperator 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 TQFtp with the TQNetworkProtocol interface, you + do not use it directly, but rather through a TQUrlOperator, for + example: + + \code + TQUrlOperator op( "ftp://ftp.trolltech.com" ); + op.listChildren(); // Asks the server to provide a directory listing + \endcode + + This code will only work if the TQFtp class is registered; to + register the class, you must call qInitNetworkProtocols() before + using a TQUrlOperator with TQFtp. + + 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 Q_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: + + \code + TQFtp *ftp = new TQFtp( this ); // this is an optional TQObject tqparent + ftp->connectToHost( "ftp.trolltech.com" ); + ftp->login(); + \endcode + + 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 Q_SIGNALS are + emitted for them. + + Some commands, e.g. list(), emit additional Q_SIGNALS to report + their results. + + Example: If you want to download the INSTALL file from Trolltech's + FTP server, you would write this: + + \code + ftp->connectToHost( "ftp.trolltech.com" ); // id == 1 + ftp->login(); // id == 2 + ftp->cd( "qt" ); // id == 3 + ftp->get( "INSTALL" ); // id == 4 + ftp->close(); // id == 5 + \endcode + + For this example the following sequence of Q_SIGNALS is emitted + (with small variations, depending on network traffic, etc.): + + \code + start( 1 ) + stateChanged( HostLookup ) + stateChanged( Connecting ) + stateChanged( Connected ) + finished( 1, FALSE ) + + start( 2 ) + stateChanged( LoggedIn ) + finished( 2, FALSE ) + + start( 3 ) + finished( 3, FALSE ) + + start( 4 ) + dataTransferProgress( 0, 3798 ) + dataTransferProgress( 2896, 3798 ) + readyRead() + dataTransferProgress( 3798, 3798 ) + readyRead() + finished( 4, FALSE ) + + start( 5 ) + stateChanged( Closing ) + stateChanged( Unconnected ) + finished( 5, FALSE ) + + done( FALSE ) + \endcode + + The dataTransferProgress() signal in the above example is useful + if you want to show a \link TQProgressBar progressbar \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 Q_SIGNALS would look + like this: + + \code + start( 1 ) + stateChanged( HostLookup ) + stateChanged( Connecting ) + stateChanged( Connected ) + finished( 1, FALSE ) + + start( 2 ) + finished( 2, TRUE ) + + done( TRUE ) + \endcode + + 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 + TQUrlOperator() 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 \link network.html TQt Network Documentation \endlink TQNetworkProtocol, TQUrlOperator TQHttp +*/ + +/*! + Constructs a TQFtp object. +*/ +TQFtp::TQFtp() : TQNetworkProtocol() +{ + init(); +} + +/*! + Constructs a TQFtp object. The \a tqparent and \a name parameters + are passed to the TQObject constructor. +*/ +TQFtp::TQFtp( TQObject *tqparent, const char *name ) : TQNetworkProtocol() +{ + if ( tqparent ) + tqparent->insertChild( this ); + TQT_TQOBJECT(this)->setName( name ); + init(); +} + +void TQFtp::init() +{ + TQFtpPrivate *d = ::d( this ); + d->errorString = tr( "Unknown error" ); + + connect( &d->pi, TQT_SIGNAL(connectState(int)), + TQT_SLOT(piConnectState(int)) ); + connect( &d->pi, TQT_SIGNAL(finished(const TQString&)), + TQT_SLOT(piFinished(const TQString&)) ); + connect( &d->pi, TQT_SIGNAL(error(int,const TQString&)), + TQT_SLOT(piError(int,const TQString&)) ); + connect( &d->pi, TQT_SIGNAL(rawFtpReply(int,const TQString&)), + TQT_SLOT(piFtpReply(int,const TQString&)) ); + + connect( &d->pi.dtp, TQT_SIGNAL(readyRead()), + TQT_SIGNAL(readyRead()) ); + connect( &d->pi.dtp, TQT_SIGNAL(dataTransferProgress(int,int)), + TQT_SIGNAL(dataTransferProgress(int,int)) ); + connect( &d->pi.dtp, TQT_SIGNAL(listInfo(const TQUrlInfo&)), + TQT_SIGNAL(listInfo(const TQUrlInfo&)) ); +} + +/*! + \enum TQFtp::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 TQFtp::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 TQFtp::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 TQFtp::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 TQFtp::listInfo( const TQUrlInfo &i ); + + This signal is emitted for each directory entry the list() command + tqfinds. The details of the entry are stored in \a i. + + \sa list() +*/ + +/*! + \fn void TQFtp::commandStarted( int id ) + + This signal is emitted when processing the command identified by + \a id starts. + + \sa commandFinished() done() +*/ + +/*! + \fn void TQFtp::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 TQFtp::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 TQFtp::readyRead() + + This signal is emitted in response to a get() command when there + is new data to read. + + If you specify a tqdevice as the second argument in the get() + command, this signal is \e not emitted; instead the data is + written directly to the tqdevice. + + 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 TQFtp::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 TQFtp 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 TQProgressBar, 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() TQProgressBar::setProgress() +*/ + +/*! + \fn void TQFtp::rawCommandReply( int replyCode, const TQString &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 TQFtp::connectToHost( const TQString &host, TQ_UINT16 port ) +{ + TQStringList cmds; + cmds << host; + cmds << TQString::number( (uint)port ); + return addCommand( new TQFtpCommand( 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 TQFtp::login( const TQString &user, const TQString &password ) +{ + TQStringList cmds; + cmds << ( TQString("USER ") + ( user.isNull() ? TQString("anonymous") : user ) + "\r\n" ); + cmds << ( TQString("PASS ") + ( password.isNull() ? TQString("anonymous@") : password ) + "\r\n" ); + return addCommand( new TQFtpCommand( 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 TQFtp::close() +{ + return addCommand( new TQFtpCommand( Close, TQStringList("TQUIT\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 TQFtp::list( const TQString &dir ) +{ + TQStringList cmds; + cmds << "TYPE A\r\n"; + cmds << "PASV\r\n"; + if ( dir.isEmpty() ) + cmds << "LIST\r\n"; + else + cmds << ( "LIST " + dir + "\r\n" ); + return addCommand( new TQFtpCommand( 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 TQFtp::cd( const TQString &dir ) +{ + return addCommand( new TQFtpCommand( Cd, TQStringList("CWD "+dir+"\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 tqdevice \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 TQFtp::get( const TQString &file, TQIODevice *dev ) +{ + TQStringList cmds; + cmds << ( "SIZE " + file + "\r\n" ); + cmds << "TYPE I\r\n"; + cmds << "PASV\r\n"; + cmds << ( "RETR " + file + "\r\n" ); + if ( dev ) + return addCommand( new TQFtpCommand( Get, cmds, dev ) ); + return addCommand( new TQFtpCommand( 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 TQFtp::put( const TQByteArray &data, const TQString &file ) +{ + TQStringList cmds; + cmds << "TYPE I\r\n"; + cmds << "PASV\r\n"; + cmds << ( "ALLO " + TQString::number(data.size()) + "\r\n" ); + cmds << ( "STOR " + file + "\r\n" ); + return addCommand( new TQFtpCommand( Put, cmds, data ) ); +} + +/*! + Reads the data from the IO tqdevice \a dev, and writes it to the + file called \a file on the server. The data is read in chunks from + the IO tqdevice, 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 TQFtp::put( TQIODevice *dev, const TQString &file ) +{ + TQStringList cmds; + cmds << "TYPE I\r\n"; + cmds << "PASV\r\n"; + if ( !dev->isSequentialAccess() ) + cmds << ( "ALLO " + TQString::number(dev->size()) + "\r\n" ); + cmds << ( "STOR " + file + "\r\n" ); + return addCommand( new TQFtpCommand( 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 TQFtp::remove( const TQString &file ) +{ + return addCommand( new TQFtpCommand( Remove, TQStringList("DELE "+file+"\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 TQFtp::mkdir( const TQString &dir ) +{ + return addCommand( new TQFtpCommand( Mkdir, TQStringList("MKD "+dir+"\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 TQFtp::rmdir( const TQString &dir ) +{ + return addCommand( new TQFtpCommand( Rmdir, TQStringList("RMD "+dir+"\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 TQFtp::rename( const TQString &oldname, const TQString &newname ) +{ + TQStringList cmds; + cmds << ( "RNFR " + oldname + "\r\n" ); + cmds << ( "RNTO " + newname + "\r\n" ); + return addCommand( new TQFtpCommand( 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 TQFtp 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 TQFtp::rawCommand( const TQString &command ) +{ + TQString cmd = command.stripWhiteSpace() + "\r\n"; + return addCommand( new TQFtpCommand( RawCommand, TQStringList(cmd) ) ); +} + +/*! + Returns the number of bytes that can be read from the data socket + at the moment. + + \sa get() readyRead() readBlock() readAll() +*/ +TQ_ULONG TQFtp::bytesAvailable() const +{ + TQFtpPrivate *d = ::d( 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() +*/ +TQ_LONG TQFtp::readBlock( char *data, TQ_ULONG maxlen ) +{ + TQFtpPrivate *d = ::d( 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() +*/ +TQByteArray TQFtp::readAll() +{ + TQFtpPrivate *d = ::d( 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 + Q_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 TQFtp::abort() +{ + TQFtpPrivate *d = ::d( 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 TQFtp::currentId() const +{ + TQFtpPrivate *d = ::d( this ); + TQFtpCommand *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() +*/ +TQFtp::Command TQFtp::currentCommand() const +{ + TQFtpPrivate *d = ::d( this ); + TQFtpCommand *c = d->pending.getFirst(); + if ( c == 0 ) + return None; + return c->command; +} + +/*! + Returns the TQIODevice 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 tqdevice, this function returns 0. + + This function can be used to delete the TQIODevice in the slot connected to + the commandFinished() signal. + + \sa get() put() +*/ +TQIODevice* TQFtp::currentDevice() const +{ + TQFtpPrivate *d = ::d( this ); + TQFtpCommand *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 TQFtp::hasPendingCommands() const +{ + TQFtpPrivate *d = ::d( 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 this as well, use abort(). + + \sa hasPendingCommands() abort() +*/ +void TQFtp::clearPendingCommands() +{ + TQFtpPrivate *d = ::d( this ); + TQFtpCommand *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() +*/ +TQFtp::State TQFtp::state() const +{ + TQFtpPrivate *d = ::d( this ); + return d->state; +} + +/*! + Returns the last error that occurred. This is useful to tqfind 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. +*/ +TQFtp::Error TQFtp::error() const +{ + TQFtpPrivate *d = ::d( 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 TQt, the string has already passed through + tr(). +*/ +TQString TQFtp::errorString() const +{ + TQFtpPrivate *d = ::d( this ); + return d->errorString; +} + +int TQFtp::addCommand( TQFtpCommand *cmd ) +{ + TQFtpPrivate *d = ::d( this ); + d->pending.append( cmd ); + + if ( d->pending.count() == 1 ) + // don't emit the commandStarted() signal before the id is returned + TQTimer::singleShot( 0, this, TQT_SLOT(startNextCommand()) ); + + return cmd->id; +} + +void TQFtp::startNextCommand() +{ + TQFtpPrivate *d = ::d( this ); + + TQFtpCommand *c = d->pending.getFirst(); + if ( c == 0 ) + return; + + d->error = NoError; + d->errorString = 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(IO_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 = TQFtp::Closing; + emit stateChanged( d->state ); + } + if ( !d->pi.sendCommands( c->rawCmds ) ) { + // ### error handling (this case should not happen) + } + } +} + +void TQFtp::piFinished( const TQString& ) +{ + TQFtpPrivate *d = ::d( this ); + TQFtpCommand *c = d->pending.getFirst(); + if ( c == 0 ) + return; + + if ( c->command == Close ) { + // The order of in which the Q_SLOTS are called is arbitrary, so + // disconnect the SIGNAL-TQT_SIGNAL temporary to make sure that we + // don't get the commandFinished() signal before the stateChanged() + // signal. + if ( d->state != TQFtp::Unconnected ) { + d->close_waitForStateChange = TRUE; + return; + } + } + emit commandFinished( c->id, FALSE ); + + d->pending.removeFirst(); + if ( d->pending.isEmpty() ) { + emit done( FALSE ); + } else { + startNextCommand(); + } +} + +void TQFtp::piError( int errorCode, const TQString &text ) +{ + TQFtpPrivate *d = ::d( this ); + TQFtpCommand *c = d->pending.getFirst(); + + // non-fatal errors + if ( c->command==Get && d->pi.currentCommand().startsWith("SIZE ") ) { + d->pi.dtp.setBytesTotal( -1 ); + return; + } else if ( c->command==Put && d->pi.currentCommand().startsWith("ALLO ") ) { + return; + } + + d->error = (Error)errorCode; + switch ( currentCommand() ) { + case ConnectToHost: + d->errorString = tr( "Connecting to host failed:\n%1" ).arg( text ); + break; + case Login: + d->errorString = tr( "Login failed:\n%1" ).arg( text ); + break; + case List: + d->errorString = tr( "Listing directory failed:\n%1" ).arg( text ); + break; + case Cd: + d->errorString = tr( "Changing directory failed:\n%1" ).arg( text ); + break; + case Get: + d->errorString = tr( "Downloading file failed:\n%1" ).arg( text ); + break; + case Put: + d->errorString = tr( "Uploading file failed:\n%1" ).arg( text ); + break; + case Remove: + d->errorString = tr( "Removing file failed:\n%1" ).arg( text ); + break; + case Mkdir: + d->errorString = tr( "Creating directory failed:\n%1" ).arg( text ); + break; + case Rmdir: + d->errorString = 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 TQFtp::piConnectState( int state ) +{ + TQFtpPrivate *d = ::d( this ); + d->state = (State)state; + emit stateChanged( d->state ); + if ( d->close_waitForStateChange ) { + d->close_waitForStateChange = FALSE; + piFinished( tr( "Connection closed" ) ); + } +} + +void TQFtp::piFtpReply( int code, const TQString &text ) +{ + if ( currentCommand() == RawCommand ) { + TQFtpPrivate *d = ::d( this ); + d->pi.rawCommand = TRUE; + emit rawCommandReply( code, text ); + } +} + +/*! + Destructor. +*/ +TQFtp::~TQFtp() +{ + abort(); + close(); + delete_d( this ); +} + +/********************************************************************** + * + * TQFtp implementation of the TQNetworkProtocol interface + * + *********************************************************************/ +/*! \reimp +*/ +void TQFtp::operationListChildren( TQNetworkOperation *op ) +{ + op->setState( StInProgress ); + + cd( ( url()->path().isEmpty() ? TQString( "/" ) : url()->path() ) ); + list(); + emit start( op ); +} + +/*! \reimp +*/ +void TQFtp::operationMkDir( TQNetworkOperation *op ) +{ + op->setState( StInProgress ); + + mkdir( op->arg( 0 ) ); +} + +/*! \reimp +*/ +void TQFtp::operationRemove( TQNetworkOperation *op ) +{ + op->setState( StInProgress ); + + cd( ( url()->path().isEmpty() ? TQString( "/" ) : url()->path() ) ); + remove( TQUrl( op->arg( 0 ) ).path() ); +} + +/*! \reimp +*/ +void TQFtp::operationRename( TQNetworkOperation *op ) +{ + op->setState( StInProgress ); + + cd( ( url()->path().isEmpty() ? TQString( "/" ) : url()->path() ) ); + rename( op->arg( 0 ), op->arg( 1 )); +} + +/*! \reimp +*/ +void TQFtp::operationGet( TQNetworkOperation *op ) +{ + op->setState( StInProgress ); + + TQUrl u( op->arg( 0 ) ); + get( u.path() ); +} + +/*! \reimp +*/ +void TQFtp::operationPut( TQNetworkOperation *op ) +{ + op->setState( StInProgress ); + + TQUrl u( op->arg( 0 ) ); + put( op->rawArg(1), u.path() ); +} + +/*! \reimp +*/ +bool TQFtp::checkConnection( TQNetworkOperation *op ) +{ + TQFtpPrivate *d = ::d( this ); + if ( state() == Unconnected && !d->npWaitForLoginDone ) { + connect( this, TQT_SIGNAL(listInfo(const TQUrlInfo&)), + this, TQT_SLOT(npListInfo(const TQUrlInfo&)) ); + connect( this, TQT_SIGNAL(done(bool)), + this, TQT_SLOT(npDone(bool)) ); + connect( this, TQT_SIGNAL(stateChanged(int)), + this, TQT_SLOT(npStateChanged(int)) ); + connect( this, TQT_SIGNAL(dataTransferProgress(int,int)), + this, TQT_SLOT(npDataTransferProgress(int,int)) ); + connect( this, TQT_SIGNAL(readyRead()), + this, TQT_SLOT(npReadyRead()) ); + + d->npWaitForLoginDone = TRUE; + switch ( op->operation() ) { + case OpGet: + case OpPut: + { + TQUrl 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; + } + TQString user = url()->user().isEmpty() ? TQString( "anonymous" ) : url()->user(); + TQString pass = url()->password().isEmpty() ? TQString( "anonymous@" ) : url()->password(); + login( user, pass ); + } + + if ( state() == LoggedIn ) + return TRUE; + return FALSE; +} + +/*! \reimp +*/ +int TQFtp::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 TQFtp::parseDir( const TQString &buffer, TQUrlInfo &info ) +{ + TQFtpDTP::parseDir( buffer, url()->user(), &info ); +} + +void TQFtp::npListInfo( const TQUrlInfo & i ) +{ + if ( url() ) { + TQRegExp filt( url()->nameFilter(), FALSE, TRUE ); + if ( i.isDir() || filt.search( i.name() ) != -1 ) { + emit newChild( i, operationInProgress() ); + } + } else { + emit newChild( i, operationInProgress() ); + } +} + +void TQFtp::npDone( bool err ) +{ + TQFtpPrivate *d = ::d( this ); + + bool emitFinishedSignal = FALSE; + TQNetworkOperation *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: + { + TQUrlInfo inf( op->arg( 0 ), 0, "", "", 0, TQDateTime(), + TQDateTime(), 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, TQT_SIGNAL(listInfo(const TQUrlInfo&)), + this, TQT_SLOT(npListInfo(const TQUrlInfo&)) ); + disconnect( this, TQT_SIGNAL(done(bool)), + this, TQT_SLOT(npDone(bool)) ); + disconnect( this, TQT_SIGNAL(stateChanged(int)), + this, TQT_SLOT(npStateChanged(int)) ); + disconnect( this, TQT_SIGNAL(dataTransferProgress(int,int)), + this, TQT_SLOT(npDataTransferProgress(int,int)) ); + disconnect( this, TQT_SIGNAL(readyRead()), + this, TQT_SLOT(npReadyRead()) ); + } + + // emit the finished() signal at the very end to avoid reentrance problems + if ( emitFinishedSignal ) + emit finished( op ); +} + +void TQFtp::npStateChanged( int state ) +{ + if ( url() ) { + if ( state == Connecting ) + emit connectionStateChanged( ConHostFound, tr( "Host %1 found" ).arg( url()->host() ) ); + else if ( state == Connected ) + emit connectionStateChanged( ConConnected, tr( "Connected to host %1" ).arg( url()->host() ) ); + else if ( state == Unconnected ) + emit connectionStateChanged( ConClosed, tr( "Connection to %1 closed" ).arg( url()->host() ) ); + } else { + if ( state == Connecting ) + emit connectionStateChanged( ConHostFound, tr( "Host found" ) ); + else if ( state == Connected ) + emit connectionStateChanged( ConConnected, tr( "Connected to host" ) ); + else if ( state == Unconnected ) + emit connectionStateChanged( ConClosed, tr( "Connection closed" ) ); + } +} + +void TQFtp::npDataTransferProgress( int bDone, int bTotal ) +{ + emit TQNetworkProtocol::dataTransferProgress( bDone, bTotal, operationInProgress() ); +} + +void TQFtp::npReadyRead() +{ + emit data( readAll(), operationInProgress() ); +} + +// ### unused -- delete in TQt 4.0 +/*! \internal +*/ +void TQFtp::hostFound() +{ +} +/*! \internal +*/ +void TQFtp::connected() +{ +} +/*! \internal +*/ +void TQFtp::closed() +{ +} +/*! \internal +*/ +void TQFtp::dataHostFound() +{ +} +/*! \internal +*/ +void TQFtp::dataConnected() +{ +} +/*! \internal +*/ +void TQFtp::dataClosed() +{ +} +/*! \internal +*/ +void TQFtp::dataReadyRead() +{ +} +/*! \internal +*/ +void TQFtp::dataBytesWritten( int ) +{ +} +/*! \internal +*/ +void TQFtp::error( int ) +{ +} + +#include "tqftp.tqmoc" + +#endif // TQT_NO_NETWORKPROTOCOL_FTP |