FtpServer.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 33    Client-side Routines */
 
#ifndef SQUID_SRC_SERVERS_FTPSERVER_H
#define SQUID_SRC_SERVERS_FTPSERVER_H
 
#include "base/JobWait.h"
#include "base/Lock.h"
#include "client_side.h"
#include "comm/forward.h"
#include "http/forward.h"
 
namespace Ftp
{
 
typedef enum {
    fssBegin,
    fssConnected,
    fssHandleFeat,
    fssHandlePasv,
    fssHandlePort,
    fssHandleDataRequest,
    fssHandleUploadRequest,
    fssHandleEprt,
    fssHandleEpsv,
    fssHandleCwd,
    fssHandlePass,
    fssHandleCdup,
    fssError
} ServerState;
 
// TODO: This should become a part of MasterXaction when we start sending
// master transactions to the clients/ code.
class MasterState: public RefCountable
{
public:
    typedef RefCount<MasterState> Pointer;
 
    MasterState(): serverState(fssBegin), clientReadGreeting(false), userDataDone(0) {}
 
    Ip::Address clientDataAddr; 
    SBuf workingDir; 
    ServerState serverState; 
    bool clientReadGreeting; 
    int userDataDone;
};
 
class Server: public ConnStateData
{
    CBDATA_CHILD(Server);
 
public:
    explicit Server(const MasterXaction::Pointer &xact);
    ~Server() override;
 
    /* AsyncJob API */
    void callException(const std::exception &e) override;
 
    void startWaitingForOrigin();
 
    void stopWaitingForOrigin(int status);
 
    // This is a pointer in hope to minimize future changes when MasterState
    // becomes a part of MasterXaction. Guaranteed not to be nil.
    MasterState::Pointer master; 
 
protected:
    friend void StartListening();
 
    // errors detected before it is possible to create an HTTP request wrapper
    enum class EarlyErrorKind {
        HugeRequest,
        MissingLogin,
        MissingUsername,
        MissingHost,
        UnsupportedCommand,
        InvalidUri,
        MalformedCommand
    };
 
    /* ConnStateData API */
    Http::Stream *parseOneRequest() override;
    void processParsedRequest(Http::StreamPointer &context) override;
    void notePeerConnection(Comm::ConnectionPointer conn) override;
    void clientPinnedConnectionClosed(const CommCloseCbParams &io) override;
    void handleReply(HttpReply *header, StoreIOBuffer receivedData) override;
    int pipelinePrefetchMax() const override;
    bool writeControlMsgAndCall(HttpReply *rep, AsyncCall::Pointer &call) override;
    time_t idleTimeout() const override;
 
    /* BodyPipe API */
    void noteMoreBodySpaceAvailable(BodyPipe::Pointer) override;
    void noteBodyConsumerAborted(BodyPipe::Pointer ptr) override;
 
    /* AsyncJob API */
    void start() override;
 
    /* Comm callbacks */
    static void AcceptCtrlConnection(const CommAcceptCbParams &params);
    void acceptDataConnection(const CommAcceptCbParams &params);
    void readUploadData(const CommIoCbParams &io);
    void wroteEarlyReply(const CommIoCbParams &io);
    void wroteReply(const CommIoCbParams &io);
    void wroteReplyData(const CommIoCbParams &io);
    void connectedForData(const CommConnectCbParams &params);
 
    unsigned int listenForDataConnection();
    bool createDataConnection(Ip::Address cltAddr);
    void closeDataConnection();
 
    void userDataCompletionCheckpoint(int finalStatusCode);
 
    void completeDataDownload();
 
    void calcUri(const SBuf *file);
    void changeState(const Ftp::ServerState newState, const char *reason);
    Http::Stream *handleUserRequest(const SBuf &cmd, SBuf &params);
    bool checkDataConnPost() const;
    void replyDataWritingCheckpoint();
    void maybeReadUploadData();
 
    void setReply(const int code, const char *msg);
    void writeCustomReply(const int code, const char *msg, const HttpReply *reply = nullptr);
    void writeEarlyReply(const int code, const char *msg);
    void writeErrorReply(const HttpReply *reply, const int status);
    void writeForwardedForeign(const HttpReply *reply);
    void writeForwardedReply(const HttpReply *reply);
    void writeForwardedReplyAndCall(const HttpReply *reply, AsyncCall::Pointer &call);
    void writeReply(MemBuf &mb);
 
    Http::Stream *earlyError(const EarlyErrorKind eek);
    bool handleRequest(HttpRequest *);
    void setDataCommand();
    bool checkDataConnPre();
 
    typedef bool (Ftp::Server::*RequestHandler)(String &cmd, String &params);
    bool handleFeatRequest(String &cmd, String &params);
    bool handlePasvRequest(String &cmd, String &params);
    bool handlePortRequest(String &cmd, String &params);
    bool handleDataRequest(String &cmd, String &params);
    bool handleUploadRequest(String &cmd, String &params);
    bool handleEprtRequest(String &cmd, String &params);
    bool handleEpsvRequest(String &cmd, String &params);
    bool handleCwdRequest(String &cmd, String &params);
    bool handlePassRequest(String &cmd, String &params);
    bool handleCdupRequest(String &cmd, String &params);
 
    typedef void (Ftp::Server::*ReplyHandler)(const HttpReply *reply, StoreIOBuffer data);
    void handleFeatReply(const HttpReply *header, StoreIOBuffer receivedData);
    void handlePasvReply(const HttpReply *header, StoreIOBuffer receivedData);
    void handlePortReply(const HttpReply *header, StoreIOBuffer receivedData);
    void handleErrorReply(const HttpReply *header, StoreIOBuffer receivedData);
    void handleDataReply(const HttpReply *header, StoreIOBuffer receivedData);
    void handleUploadReply(const HttpReply *header, StoreIOBuffer receivedData);
    void handleEprtReply(const HttpReply *header, StoreIOBuffer receivedData);
    void handleEpsvReply(const HttpReply *header, StoreIOBuffer receivedData);
 
private:
    void doProcessRequest();
    void shovelUploadData();
    void resetLogin(const char *reason);
 
    SBuf uri; 
    SBuf host; 
    bool gotEpsvAll; 
    AsyncCall::Pointer onDataAcceptCall; 
    Comm::ConnectionPointer dataListenConn; 
    Comm::ConnectionPointer dataConn; 
    char uploadBuf[CLIENT_REQ_BUF_SZ]; 
    size_t uploadAvailSize; 
 
    AsyncCall::Pointer listener; 
 
    JobWait<Comm::ConnOpener> dataConnWait;
 
    AsyncCall::Pointer reader; 
 
    bool waitingForOrigin;
    bool originDataDownloadAbortedOnError;
 
    HttpReply::Pointer delayedReply;
};
 
} // namespace Ftp
 
#endif /* SQUID_SRC_SERVERS_FTPSERVER_H */