#ifndef Net_FTPClientSession_INCLUDED

#define Net_FTPClientSession_INCLUDED

#include "Poco/Net/Net.h"

#include "Poco/Net/DialogSocket.h"

#include "Poco/Timespan.h"

#include <istream>

#include <ostream>

namespace Poco {

namespace Net {

class SocketStream;

class Net_API FTPClientSession

/// This class implements an File Transfer Protocol

/// (FTP, RFC 959) client.

///

/// Most of the features of the FTP protocol, as specified

/// in RFC 959, are supported. Not supported are EBCDIC and

/// LOCAL data types and format control and structured files.

///

/// Also supported are the EPRT and EPSV commands from

/// RFC 1738 (FTP Extensions for IPv6 and NAT).

/// The client will first attempt to use the EPRT and EPSV

/// commands. If the server does not supports these commands,

/// the client will fall back to PORT and PASV.

{

enum

{

FTP_PORT = 21

};

enum FileType

};

FTPClientSession();

/// Creates an FTPClientSession.

///

/// Passive mode will be used for data transfers.

FTPClientSession(const StreamSocket& socket, bool readWelcomeMessage = true);

/// Creates an FTPClientSession using the given

/// connected socket for the control connection.

///

/// Passive mode will be used for data transfers.

FTPClientSession(const std::string& host, Poco::UInt16 port = FTP_PORT, const std::string& username = "", const std::string& password = "");

/// Creates an FTPClientSession using a socket connected

/// to the given host and port. If username is supplied,

/// login is attempted.

///

/// Passive mode will be used for data transfers.

virtual ~FTPClientSession();

/// Destroys the FTPClientSession.

void setTimeout(const Poco::Timespan& timeout);

/// Sets the timeout for socket operations.

Poco::Timespan getTimeout() const;

/// Returns the timeout for socket operations.

void setPassive(bool flag, bool useRFC1738 = true);

/// Enables (default) or disables FTP passive mode for this session.

///

/// If useRFC1738 is true (the default), the RFC 1738

/// EPSV command is used (with a fallback to PASV if EPSV fails)

/// for switching to passive mode. The same applies to

/// EPRT and PORT for active connections.

bool getPassive() const;

/// Returns true iff passive mode is enabled for this connection.

virtual void open(const std::string& host, Poco::UInt16 port, const std::string& username = "", const std::string& password = "");

/// Opens the FTP connection to the given host and port.

/// If username is supplied, login is attempted.

virtual void login(const std::string& username, const std::string& password);

/// Authenticates the user against the FTP server. Must be

/// called before any other commands (except QUIT) can be sent.

///

/// Sends a USER command followed by a PASS command with the

/// respective arguments to the server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

void logout();

/// Logs out from the server by sending a QUIT command. Any transfer

/// that's in progress is ended. The control connection is kept

/// open.

void close();

/// Sends a QUIT command and closes the connection to the server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

std::string systemType();

/// Returns the system type of the FTP server.

///

/// Sends a SYST command to the server and returns the result.

void setFileType(FileType type);

/// Sets the file type for transferring files.

///

/// Sends a TYPE command with a corresponding argument to the

/// server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

FileType getFileType() const;

/// Returns the file type for transferring files.

void setWorkingDirectory(const std::string& path);

/// Changes the current working directory on the server.

///

/// Sends a CWD command with the given path as argument to the

/// server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

std::string getWorkingDirectory();

/// Returns the current working directory on the server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

void cdup();

/// Moves one directory up from the current working directory

/// on the server.

///

/// Sends a CDUP command to the server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

void rename(const std::string& oldName, const std::string& newName);

/// Renames the file on the server given by oldName to newName.

///

/// Sends a RNFR command, followed by a RNTO command to the server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

void remove(const std::string& path);

/// Deletes the file specified by path on the server.

///

/// Sends a DELE command with path as argument to the server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

void createDirectory(const std::string& path);

/// Creates a new directory with the given path on the server.

///

/// Sends a MKD command with path as argument to the server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

void removeDirectory(const std::string& path);

/// Removes the directory specified by path from the server.

///

/// Sends a RMD command with path as argument to the server.

///

/// Throws a FTPException in case of a FTP-specific error, or a

/// NetException in case of a general network communication failure.

std::istream& beginDownload(const std::string& path);

/// Starts downloading the file with the given name.

/// After all data has been read from the returned stream,

/// endDownload() must be called to finish the download.

///

/// A stream for reading the file's content is returned.

/// The stream is valid until endDownload() is called.

///

/// Creates a data connection between the client and the

/// server. If passive mode is on, then the server waits for

/// a connection request from the client. Otherwise, the

/// client waits for a connection request from the server.

/// After establishing the data connection, a SocketStream

/// for transferring the data is created.

///

/// If ASCII transfer mode is selected, the caller is

/// responsible for converting the received data to

/// the native text file format.

/// The InputLineEndingConverter class from the Foundation

/// library can be used for that purpose.

void endDownload();

/// Must be called to complete a download initiated with

/// beginDownload().

std::ostream& beginUpload(const std::string& path);

/// Starts uploading the file with the given name.

/// After all data has been written to the returned stream,

/// endUpload() must be called to finish the upload.

///

/// A stream for reading the file's content is returned.

/// The stream is valid until endUpload() is called.

///

/// Creates a data connection between the client and the

/// server. If passive mode is on, then the server waits for

/// a connection request from the client. Otherwise, the

/// client waits for a connection request from the server.

/// After establishing the data connection, a SocketStream

/// for transferring the data is created.

///

/// If ASCII transfer mode is selected, the caller is

/// responsible for converting the data to be sent

/// into network (CR-LF line endings) format.

/// The OutputLineEndingConverter class from the Foundation

/// library can be used for that purpose.

void endUpload();

/// Must be called to complete an upload initiated with

/// beginUpload().

std::istream& beginList(const std::string& path = "", bool extended = false);

/// Starts downloading a directory listing.

/// After all data has been read from the returned stream,

/// endList() must be called to finish the download.

///

/// A stream for reading the directory data is returned.

/// The stream is valid until endList() is called.

///

/// Optionally, a path to a directory or file can be specified.

/// According to the FTP protocol, if a path to a filename is

/// given, only information for the specific file is returned.

/// If a path to a directory is given, a listing of that directory

/// is returned. If no path is given, a listing of the current

/// working directory is returned.

///

/// If extended is false, only a filenames (one per line) are

/// returned. Otherwise, a full directory listing including

/// file attributes is returned. The format of this listing

/// depends on the FTP server. No attempt is made to interpret

/// this data.

///

/// Creates a data connection between the client and the

/// server. If passive mode is on, then the server waits for

/// a connection request from the client. Otherwise, the

/// client waits for a connection request from the server.

/// After establishing the data connection, a SocketStream

/// for transferring the data is created.

void endList();

/// Must be called to complete a directory listing download

/// initiated with beginList().

void abort();

/// Aborts the download or upload currently in progress.

///

/// Sends a TELNET IP/SYNCH sequence, followed by an ABOR

/// command to the server.

///

/// A separate call to endDownload() or endUpload() is

/// not necessary.

int sendCommand(const std::string& command, std::string& response);

/// Sends the given command verbatim to the server

/// and waits for a response.

int sendCommand(const std::string& command, const std::string& arg, std::string& response);

/// Sends the given command verbatim to the server

/// and waits for a response.

bool isOpen() const;

/// Returns true if the connection with FTP server is opened.

bool isLoggedIn() const;

/// Returns true if the session is logged in.

bool isSecure() const;

/// Returns true if the session is FTPS.

const std::string& welcomeMessage();

/// Returns the welcome message.

virtual void receiveServerReadyReply();

enum StatusClass

};

enum

{

DEFAULT_TIMEOUT = 30000000 // 30 seconds default timeout for socket operations

};

static bool isPositivePreliminary(int status);

static bool isPositiveCompletion(int status);

static bool isPositiveIntermediate(int status);

static bool isTransientNegative(int status);

static bool isPermanentNegative(int status);

std::string extractPath(const std::string& response);

virtual StreamSocket establishDataConnection(const std::string& command, const std::string& arg);

StreamSocket activeDataConnection(const std::string& command, const std::string& arg);

StreamSocket passiveDataConnection(const std::string& command, const std::string& arg);

void sendPortCommand(const SocketAddress& addr);

SocketAddress sendPassiveCommand();

bool sendEPRT(const SocketAddress& addr);

void sendPORT(const SocketAddress& addr);

bool sendEPSV(SocketAddress& addr);

void sendPASV(SocketAddress& addr);

void parseAddress(const std::string& str, SocketAddress& addr);

void parseExtAddress(const std::string& str, SocketAddress& addr);

void endTransfer();

DialogSocket* _pControlSocket = nullptr;

SocketStream* _pDataStream = nullptr;

FTPClientSession(const FTPClientSession&);

FTPClientSession& operator = (const FTPClientSession&);

std::string _host;

Poco::UInt16 _port = FTP_PORT;

bool _passiveMode = true;

FileType _fileType = TYPE_BINARY;

bool _supports1738 = true;

bool _serverReady = false;

bool _isLoggedIn = false;

Poco::Timespan _timeout = DEFAULT_TIMEOUT;

std::string _welcomeMessage;

Poco::FastMutex _wmMutex;

};

inline bool FTPClientSession::isPositivePreliminary(int status)

{

return status/100 == FTP_POSITIVE_PRELIMINARY;

}

inline bool FTPClientSession::isPositiveCompletion(int status)

{

return status/100 == FTP_POSITIVE_COMPLETION;

}

inline bool FTPClientSession::isPositiveIntermediate(int status)

{

return status/100 == FTP_POSITIVE_INTERMEDIATE;

}

inline bool FTPClientSession::isTransientNegative(int status)

{

return status/100 == FTP_TRANSIENT_NEGATIVE;

}

inline bool FTPClientSession::isPermanentNegative(int status)

{

return status/100 == FTP_PERMANENT_NEGATIVE;

}

inline bool FTPClientSession::isOpen() const

{

return _pControlSocket != 0;

}

inline bool FTPClientSession::isLoggedIn() const

{

return _isLoggedIn;

}

inline bool FTPClientSession::isSecure() const

{

return false;

}

inline const std::string& FTPClientSession::welcomeMessage()

{

Poco::FastMutex::ScopedLock lock(_wmMutex);

return _welcomeMessage;

}

} } // namespace Poco::Net

#endif // Net_FTPClientSession_INCLUDED