FtpClient.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
/* DEBUG: section 09    File Transfer Protocol (FTP) */
 
#ifndef SQUID_FTP_CLIENT_H
#define SQUID_FTP_CLIENT_H
 
#include "clients/Client.h"
#include "error/Detail.h"
 
class String;
namespace Ftp
{
 
extern const char *const crlf;
 
class ErrorDetail: public ::ErrorDetail {
    MEMPROXY_CLASS(Ftp::ErrorDetail);
 
public:
    explicit ErrorDetail(const int code): completionCode(code) {}
 
    /* ErrorDetail API */
    SBuf brief() const override;
    SBuf verbose(const HttpRequestPointer &) const override;
 
private:
    int completionCode; 
};
 
class Channel
{
public:
    void opened(const Comm::ConnectionPointer &conn, const AsyncCall::Pointer &aCloser);
 
    void close();
 
    void forget(); 
 
    void clear(); 
 
    Comm::ConnectionPointer conn; 
 
    Comm::ConnectionPointer listenConn;
 
private:
    AsyncCall::Pointer closer; 
};
 
class CtrlChannel: public Ftp::Channel
{
public:
    CtrlChannel();
    ~CtrlChannel();
 
    char *buf;
    size_t size;
    size_t offset;
    wordlist *message;
    char *last_command;
    char *last_reply;
    int replycode;
 
private:
    CtrlChannel(const CtrlChannel &); // not implemented
    CtrlChannel &operator =(const CtrlChannel &); // not implemented
};
 
class DataChannel: public Ftp::Channel
{
public:
    DataChannel();
    ~DataChannel();
 
    void addr(const Ip::Address &addr); 
 
public:
    MemBuf *readBuf;
    char *host;
    unsigned short port;
    bool read_pending;
};
 
class Client: public ::Client
{
public:
    explicit Client(FwdState *fwdState);
    ~Client() override;
 
    virtual void failed(err_type error = ERR_NONE, int xerrno = 0,
                        ErrorState *ftperr = nullptr);
 
    virtual void timeout(const CommTimeoutCbParams &io);
 
    /* Client API */
    void maybeReadVirginBody() override;
 
    void writeCommand(const char *buf);
 
    bool handlePasvReply(Ip::Address &remoteAddr);
    bool handleEpsvReply(Ip::Address &remoteAddr);
 
    bool sendEprt();
    bool sendPort();
    bool sendPassive();
    void connectDataChannel();
    bool openListenSocket();
    void switchTimeoutToDataChannel();
 
    CtrlChannel ctrl; 
    DataChannel data; 
 
    enum {
        BEGIN,
        SENT_USER,
        SENT_PASS,
        SENT_TYPE,
        SENT_MDTM,
        SENT_SIZE,
        SENT_EPRT,
        SENT_PORT,
        SENT_EPSV_ALL,
        SENT_EPSV_1,
        SENT_EPSV_2,
        SENT_PASV,
        SENT_CWD,
        SENT_LIST,
        SENT_NLST,
        SENT_REST,
        SENT_RETR,
        SENT_STOR,
        SENT_QUIT,
        READING_DATA,
        WRITING_DATA,
        SENT_MKDIR,
        SENT_FEAT,
        SENT_PWD,
        SENT_CDUP,
        SENT_DATA_REQUEST, // LIST, NLST or RETR requests..
        SENT_COMMAND, // General command
        END
    } ftp_state_t;
 
    int state;
    char *old_request;
    char *old_reply;
 
protected:
    /* AsyncJob API */
    void start() override;
 
    /* Client API */
    void closeServer() override;
    bool doneWithServer() const override;
    const Comm::ConnectionPointer & dataConnection() const override;
    void abortAll(const char *reason) override;
    void noteDelayAwareReadChance() override;
 
    virtual Http::StatusCode failedHttpStatus(err_type &error);
    void ctrlClosed(const CommCloseCbParams &io);
    void scheduleReadControlReply(int buffered_ok);
    void readControlReply(const CommIoCbParams &io);
    virtual void handleControlReply();
    void writeCommandCallback(const CommIoCbParams &io);
    virtual void dataChannelConnected(const CommConnectCbParams &io) = 0;
    void dataRead(const CommIoCbParams &io);
    void dataComplete();
    AsyncCall::Pointer dataCloser();
    virtual void dataClosed(const CommCloseCbParams &io);
    void initReadBuf();
 
    // sending of the request body to the server
    void sentRequestBody(const CommIoCbParams &io) override;
    void doneSendingRequestBody() override;
 
    JobWait<Comm::ConnOpener> dataConnWait;
 
private:
    bool parseControlReply(size_t &bytesUsed);
 
    bool shortenReadTimeout;
};
 
} // namespace Ftp
 
#endif /* SQUID_FTP_CLIENT_H */