You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdeio-ftps/kio_ftps/ftp.h

627 lines
18 KiB

// -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 2; -*-
/* This file is part of the KDE libraries
Copyright (C) 2000 David Faure <faure@kde.org>
ftps-support has been added by Magnus Kulke <magnus.kulke@radicalapproach.de>,
based upon rfc4217 (http://www.ietf.org/rfc/rfc4217.txt). it should work
yet with most server implementations. it issues an "AUTH TLS" command after
connecting and refuses to continue, when it's not supported. in prior to
every data channel io command ("STOR", "RETR", etc) it tries to secure the
data channel via "PBSZ" and "PROT" commands. if that fails it will transfer
data unencrypted. there is currently no support for ssl-certificates. this
might be added on demand.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
// $Id$
#ifndef __ftp_h__
#define __ftp_h__
#include <config.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <qcstring.h>
#include <qstring.h>
#include <kurl.h>
#include <kio/slavebase.h>
#include <kextsock.h>
#include <ksocks.h>
#include <kssl.h>
struct FtpEntry
{
QString name;
QString owner;
QString group;
QString link;
KIO::filesize_t size;
mode_t type;
mode_t access;
time_t date;
};
//===============================================================================
// FtpTextReader A helper class to read text lines from a socket
//===============================================================================
#ifdef KIO_FTP_PRIVATE_INCLUDE
class FtpSocket;
class FtpTextReader
{
public:
FtpTextReader() { textClear(); }
/**
* Resets the status of the object, also called from xtor
*/
void textClear();
/**
* Read a line from the socket into m_szText. Only the first RESP_READ_LIMIT
* characters are copied. If the server response is longer all extra data up to
* the new-line gets discarded. An ending CR gets stripped. The number of chars
* in the buffer is returned. Use textToLong() to check for truncation!
*/
int textRead(FtpSocket *pSock);
/**
* An accessor to the data read by textRead()
*/
const char* textLine() const { return m_szText; }
/**
* Returns true if the last textRead() resulted in a truncated line
*/
bool textTooLong() const { return m_bTextTruncated; }
/**
* Returns true if the last textRead() got an EOF or an error
*/
bool textEOF() const { return m_bTextEOF; }
enum {
/**
* This is the physical size of m_szText. Only up to textReadLimit
* characters are used to store a server reply. If the server reply
* is longer, the stored line gets truncated - see textTooLong()!
*/
textReadBuffer = 2048,
/**
* Max number of chars returned from textLine(). If the server
* sends more all chars until the next new-line are discarded.
*/
textReadLimit = 1024
};
private:
/**
* textRead() sets this true on trucation (e.g. line too long)
*/
bool m_bTextTruncated;
/**
* textRead() sets this true if the read returns 0 bytes or error
*/
bool m_bTextEOF;
/**
* textRead() fills this buffer with data
*/
char m_szText[textReadBuffer];
/**
* the number of bytes in the current response line
*/
int m_iTextLine;
/**
* the number of bytes in the response buffer (includes m_iRespLine)
*/
int m_iTextBuff;
};
#endif // KIO_FTP_PRIVATE_INCLUDE
//===============================================================================
// FtpSocket Helper Class for Data or Control Connections
//===============================================================================
#ifdef KIO_FTP_PRIVATE_INCLUDE
class FtpSocket : public FtpTextReader, public KExtendedSocket
{
private:
// hide the default xtor
FtpSocket() {}
public:
/**
* The one and only public xtor. The string data passed to the
* xtor must remain valid during the object's lifetime - it is
* used in debug messages to identify the socket instance.
*/
FtpSocket(const char* pszName)
{
m_pszName = pszName;
m_server = -1;
m_sslUsed = false;
}
~FtpSocket() { closeSocket(); }
/**
* Resets the status of the object, also called from xtor
*/
void closeSocket();
/**
* We may have a server connection socket if not in passive mode. This
* routine returns the server socket set by setServer. The sock()
* function will return the server socket - if it is set.
*/
int server() const { return m_server; }
/**
* Set the server socket if arg >= 0, otherwise clear it.
*/
void setServer(int i) { m_server = (i >= 0) ? i : -1; }
/**
* returns the effective socket that user used for read/write. See server()
*/
int sock() const { return (m_server != -1) ? m_server : fd(); }
/**
* output an debug message via kdDebug
*/
void debugMessage(const char* pszMsg) const;
/**
* output an error message via kdError, returns iErrorCode
*/
int errorMessage(int iErrorCode, const char* pszMsg) const;
/**
* connect socket and set some options (reuse, keepalive, linger)
*/
int connectSocket(int iTimeOutSec, bool bControl);
/**
* utility to simplify calls to ::setsockopt(). Uses sock().
*/
bool setSocketOption(int opt, char*arg, socklen_t len) const;
/**
* utility to read data from the effective socket, see sock()
*/
long read(void* pData, long iMaxlen)
{
return (m_sslUsed) ? m_ssl.read(pData, iMaxlen) : KSocks::self()->read(sock(), pData, iMaxlen);
}
/**
* utility to write data to the effective socket, see sock()
*/
long write(void* pData, long iMaxlen)
{
return (m_sslUsed) ? m_ssl.write(pData, iMaxlen) : KSocks::self()->write(sock(), pData, iMaxlen);
}
/**
* Use the inherited FtpTextReader to read a line from the socket
*/
int textRead()
{
return FtpTextReader::textRead(this);
}
/**
* negotiates TLS encryption
*/
bool sslConnect();
private:
const char* m_pszName; // set by the xtor, used for debug output
int m_server; // socket override, see setSock()
KSSL m_ssl; // ssl context
bool m_sslUsed;
};
#else
class FtpSocket;
#endif // KIO_FTP_PRIVATE_INCLUDE
//===============================================================================
// Ftp
//===============================================================================
class Ftp : public KIO::SlaveBase
{
// Ftp() {}
public:
Ftp( const QCString &prot, const QCString &pool, const QCString &app );
virtual ~Ftp();
virtual void setHost( const QString& host, int port, const QString& user, const QString& pass );
/**
* Connects to a ftp server and logs us in
* m_bLoggedOn is set to true if logging on was successful.
* It is set to false if the connection becomes closed.
*
*/
virtual void openConnection();
/**
* Closes the connection
*/
virtual void closeConnection();
virtual void stat( const KURL &url );
virtual void listDir( const KURL & url );
virtual void mkdir( const KURL & url, int permissions );
virtual void rename( const KURL & src, const KURL & dst, bool overwrite );
virtual void del( const KURL & url, bool isfile );
virtual void chmod( const KURL & url, int permissions );
virtual void get( const KURL& url );
virtual void put( const KURL& url, int permissions, bool overwrite, bool resume);
//virtual void mimetype( const KURL& url );
virtual void slave_status();
/**
* Handles the case that one side of the job is a local file
*/
virtual void copy( const KURL &src, const KURL &dest, int permissions, bool overwrite );
private:
// ------------------------------------------------------------------------
// All the methods named ftpXyz are lowlevel methods that are not exported.
// The implement functionality used by the public high-level methods. Some
// low-level methods still use error() to emit errors. This behaviour is not
// recommended - please return a boolean status or an error code instead!
// ------------------------------------------------------------------------
/**
* Status Code returned from ftpPut() and ftpGet(), used to select
* source or destination url for error messages
*/
typedef enum {
statusSuccess,
statusClientError,
statusServerError
} StatusCode;
/**
* Login Mode for ftpOpenConnection
*/
typedef enum {
loginDefered,
loginExplicit,
loginImplicit
} LoginMode;
/**
* Connect and login to the FTP server.
*
* @param loginMode controls if login info should be sent<br>
* loginDefered - must not be logged on, no login info is sent<br>
* loginExplicit - must not be logged on, login info is sent<br>
* loginImplicit - login info is sent if not logged on
*
* @return true on success (a login failure would return false).
*/
bool ftpOpenConnection (LoginMode loginMode);
/**
* Executes any auto login macro's as specified in a .netrc file.
*/
void ftpAutoLoginMacro ();
/**
* Called by openConnection. It logs us in.
* m_initialPath is set to the current working directory
* if logging on was successful.
*
* @return true on success.
*/
bool ftpLogin();
/**
* ftpSendCmd - send a command (@p cmd) and read response
*
* @param maxretries number of time it should retry. Since it recursively
* calls itself if it can't read the answer (this happens especially after
* timeouts), we need to limit the recursiveness ;-)
*
* return true if any response received, false on error
*/
bool ftpSendCmd( const QCString& cmd, int maxretries = 1 );
/**
* Use the SIZE command to get the file size.
* @param mode the size depends on the transfer mode, hence this arg.
* @return true on success
* Gets the size into m_size.
*/
bool ftpSize( const QString & path, char mode );
/**
* Set the current working directory, but only if not yet current
*/
bool ftpFolder(const QString& path, bool bReportError);
/**
* Runs a command on the ftp server like "list" or "retr". In contrast to
* ftpSendCmd a data connection is opened. The corresponding socket
* sData is available for reading/writing on success.
* The connection must be closed afterwards with ftpCloseCommand.
*
* @param mode is 'A' or 'I'. 'A' means ASCII transfer, 'I' means binary transfer.
* @param errorcode the command-dependent error code to emit on error
*
* @return true if the command was accepted by the server.
*/
bool ftpOpenCommand( const char *command, const QString & path, char mode,
int errorcode, KIO::fileoffset_t offset = 0 );
/**
* The counterpart to openCommand.
* Closes data sockets and then reads line sent by server at
* end of command.
* @return false on error (line doesn't start with '2')
*/
bool ftpCloseCommand();
/**
* Send "TYPE I" or "TYPE A" only if required, see m_cDataMode.
*
* Use 'A' to select ASCII and 'I' to select BINARY mode. If
* cMode is '?' the m_bTextMode flag is used to choose a mode.
*/
bool ftpDataMode(char cMode);
//void ftpAbortTransfer();
/**
* Used by ftpOpenCommand, return 0 on success or an error code
*/
int ftpOpenDataConnection();
/**
* closes a data connection, see ftpOpenDataConnection()
*/
void ftpCloseDataConnection();
/**
* Helper for ftpOpenDataConnection
*/
int ftpOpenPASVDataConnection();
/**
* Helper for ftpOpenDataConnection
*/
int ftpOpenEPSVDataConnection();
/**
* Helper for ftpOpenDataConnection
*/
int ftpOpenEPRTDataConnection();
/**
* Helper for ftpOpenDataConnection
*/
int ftpOpenPortDataConnection();
/**
* ftpAcceptConnect - wait for incoming connection
*
* return -2 on error or timeout
* otherwise returns socket descriptor
*/
int ftpAcceptConnect();
bool ftpChmod( const QString & path, int permissions );
// used by listDir
bool ftpOpenDir( const QString & path );
/**
* Called to parse directory listings, call this until it returns false
*/
bool ftpReadDir(FtpEntry& ftpEnt);
/**
* Helper to fill an UDSEntry
*/
void ftpCreateUDSEntry( const QString & filename, FtpEntry& ftpEnt, KIO::UDSEntry& entry, bool isDir );
void ftpShortStatAnswer( const QString& filename, bool isDir );
void ftpStatAnswerNotFound( const QString & path, const QString & filename );
/**
* This is the internal implementation of rename() - set put().
*
* @return true on success.
*/
bool ftpRename( const QString & src, const QString & dst, bool overwrite );
/**
* Called by openConnection. It opens the control connection to the ftp server.
*
* @return true on success.
*/
bool ftpOpenControlConnection( const QString & host, unsigned short int port );
/**
* closes the socket holding the control connection (see ftpOpenControlConnection)
*/
void ftpCloseControlConnection();
/**
* read a response from the server (a trailing CR gets stripped)
* @param iOffset -1 to read a new line from the server<br>
* 0 to return the whole response string
* >0 to return the response with iOffset chars skipped
* @return the reponse message with iOffset chars skipped (or "" if iOffset points
* behind the available data)
*/
const char* ftpResponse(int iOffset);
/**
* This is the internal implementation of get() - see copy().
*
* IMPORTANT: the caller should call ftpCloseCommand() on return.
* The function does not call error(), the caller should do this.
*
* @param iError set to an ERR_xxxx code on error
* @param iCopyFile -1 -or- handle of a local destination file
* @param hCopyOffset local file only: non-zero for resume
* @return 0 for success, -1 for server error, -2 for client error
*/
StatusCode ftpGet(int& iError, int iCopyFile, const KURL& url, KIO::fileoffset_t hCopyOffset);
/**
* This is the internal implementation of put() - see copy().
*
* IMPORTANT: the caller should call ftpCloseCommand() on return.
* The function does not call error(), the caller should do this.
*
* @param iError set to an ERR_xxxx code on error
* @param iCopyFile -1 -or- handle of a local source file
* @return 0 for success, -1 for server error, -2 for client error
*/
StatusCode ftpPut(int& iError, int iCopyFile, const KURL& url, int permissions, bool overwrite, bool resume);
/**
* helper called from copy() to implement FILE -> FTP transfers
*
* @param iError set to an ERR_xxxx code on error
* @param iCopyFile [out] handle of a local source file
* @param sCopyFile path of the local source file
* @return 0 for success, -1 for server error, -2 for client error
*/
StatusCode ftpCopyPut(int& iError, int& iCopyFile, QString sCopyFile, const KURL& url, int permissions, bool overwrite);
/**
* helper called from copy() to implement FTP -> FILE transfers
*
* @param iError set to an ERR_xxxx code on error
* @param iCopyFile [out] handle of a local source file
* @param sCopyFile path of the local destination file
* @return 0 for success, -1 for server error, -2 for client error
*/
StatusCode ftpCopyGet(int& iError, int& iCopyFile, QString sCopyFile, const KURL& url, int permissions, bool overwrite);
/**
* ssl connect method
*/
int sslConnect(FtpSocket* socket);
private: // data members
QString m_host;
unsigned short int m_port;
QString m_user;
QString m_pass;
/**
* Where we end up after connecting
*/
QString m_initialPath;
KURL m_proxyURL;
/**
* the current working directory - see ftpFolder
*/
QString m_currentPath;
/**
* the status returned by the FTP protocol, set in ftpResponse()
*/
int m_iRespCode;
/**
* the status/100 returned by the FTP protocol, set in ftpResponse()
*/
int m_iRespType;
/**
* This flag is maintained by ftpDataMode() and contains I or A after
* ftpDataMode() has successfully set the mode.
*/
char m_cDataMode;
/**
* true if logged on (m_control should also be non-NULL)
*/
bool m_bLoggedOn;
/**
* true if a "textmode" metadata key was found by ftpLogin(). This
* switches the ftp data transfer mode from binary to ASCII.
*/
bool m_bTextMode;
/**
* true if a data stream is open, used in closeConnection().
*
* When the user cancels a get or put command the Ftp dtor will be called,
* which in turn calls closeConnection(). The later would try to send QUIT
* which won't work until timeout. ftpOpenCommand sets the m_bBusy flag so
* that the sockets will be closed immedeately - the server should be
* capable of handling this and return an error code on thru the control
* connection. The m_bBusy gets cleared by the ftpCloseCommand() routine.
*/
bool m_bBusy;
bool m_bPasv;
bool m_bUseProxy;
KIO::filesize_t m_size;
static KIO::filesize_t UnknownSize;
enum
{
epsvUnknown = 0x01,
epsvAllUnknown = 0x02,
eprtUnknown = 0x04,
epsvAllSent = 0x10,
pasvUnknown = 0x20,
chmodUnknown = 0x100
};
int m_extControl;
/**
* control connection socket, only set if openControl() succeeded
*/
FtpSocket *m_control;
/**
* data connection socket
*/
FtpSocket *m_data;
/**
* protocol used currently (ftp or ftps)
*/
QString m_prot;
};
#endif