path: root/library/cpp/http/fetch/httpload.h

#pragma once

#include "httpagent.h" 
#include "httpparser.h" 
#include "http_digest.h" 
 
#include <util/system/compat.h>
#include <util/string/vector.h>
#include <util/network/ip.h>
#include <library/cpp/uri/http_url.h>
#include <library/cpp/http/misc/httpcodes.h>

/********************************************************/
// Section 1: socket handlers
/********************************************************/
// The following classes allows to adopt template scheme
// THttpAgent for work with socket by flexible
// object-style scheme.

/********************************************************/
// This class is used as a base one for flexible
// socket handling
class socketAbstractHandler { 
public:
    virtual bool Good() = 0;

    virtual int Connect(const TAddrList& addrs, TDuration Timeout) = 0;

    virtual void Disconnect() = 0;

    virtual void shutdown() = 0;

    virtual bool send(const char* message, ssize_t messlen) = 0;

    virtual bool peek() = 0;

    virtual ssize_t read(void* buffer, ssize_t buflen) = 0;

    virtual ~socketAbstractHandler() { 
    } 

protected:
    socketAbstractHandler() { 
    } 
};

/********************************************************/
// This class is used as a proxy between THttpAgent and
// socketAbstractHandler
// (it is used by template scheme,
//  so it does not have virtual methods)
class TSocketHandlerPtr { 
protected:
    socketAbstractHandler* Handler_; 

public:
    TSocketHandlerPtr() 
        : Handler_(nullptr) 
    { 
    } 

    virtual ~TSocketHandlerPtr() { 
        delete Handler_; 
    } 

    int Good() { 
        return (Handler_ && Handler_->Good()); 
    } 

    int Connect(const TAddrList& addrs, TDuration Timeout) { 
        return (Handler_) ? Handler_->Connect(addrs, Timeout) : 1; 
    }

    void Disconnect() { 
        if (Handler_) 
            Handler_->Disconnect(); 
    }

    void shutdown() { 
        if (Handler_) 
            Handler_->shutdown(); 
    }

    bool send(const char* message, ssize_t messlen) { 
        return (Handler_) ? Handler_->send(message, messlen) : false; 
    }

    virtual bool peek() { 
        return (Handler_) ? Handler_->peek() : false; 
    }

    virtual ssize_t read(void* buffer, ssize_t buflen) { 
        return (Handler_) ? Handler_->read(buffer, buflen) : 0; 
    }

    void setHandler(socketAbstractHandler* handler) { 
        if (Handler_) 
            delete Handler_; 
        Handler_ = handler; 
    }
};

/********************************************************/
// Here is httpAgent that uses socketAbstractHandler class
// ant its derivatives
using httpSpecialAgent = THttpAgent<TSocketHandlerPtr>;

/********************************************************/
// Regular handler is used as implementation of
// socketAbstractHandler for work through HTTP protocol
class socketRegularHandler: public socketAbstractHandler { 
protected: 
    TSimpleSocketHandler Socket_; 

public: 
    socketRegularHandler() 
        : Socket_() 
    { 
    } 

    bool Good() override { 
        return Socket_.Good(); 
    }

    int Connect(const TAddrList& addrs, TDuration Timeout) override { 
        return Socket_.Connect(addrs, Timeout);
    }

    void Disconnect() override { 
        Socket_.Disconnect(); 
    }

    void shutdown() override { 
        //Do not block writing to socket
        //There are servers that works in a bad way with this
        //mSocket.shutdown();
    }

    bool send(const char* message, ssize_t messlen) override { 
        return Socket_.send(message, messlen); 
    }

    bool peek() override { 
        return Socket_.peek(); 
    }

    ssize_t read(void* buffer, ssize_t buflen) override { 
        return Socket_.read(buffer, buflen); 
    }
};

/********************************************************/
// The base factory that allows to choose an appropriate
// socketAbstractHandler implementation by url schema
 
class socketHandlerFactory { 
public: 
    virtual ~socketHandlerFactory() { 
    } 

    //returns mHandler_HTTP for correct HTTP-based url
    virtual socketAbstractHandler* chooseHandler(const THttpURL& url); 

    static socketHandlerFactory sInstance;
};

/********************************************************/
// Section 2: the configurates tool to parse an HTTP-response
/********************************************************/

class httpAgentReader: public THttpParserGeneric<1> { 
protected: 
    THttpAuthHeader Header_; 
    httpSpecialAgent& Agent_; 

    char* Buffer_; 
    void* BufPtr_; 
    int BufSize_; 
    long BufRest_; 

    void readBuf();

    bool step() { 
        if (BufRest_ == 0) 
            readBuf();
        if (eof())
            return false;
        return true;
    }

public: 
    httpAgentReader(httpSpecialAgent& agent, 
                    const char* baseUrl, 
                    bool assumeConnectionClosed, 
                    bool use_auth = false, 
                    int bufSize = 0x1000); 

    ~httpAgentReader();

    bool eof() { 
        return BufRest_ < 0; 
    }

    int error() { 
        return Header_.error; 
    }

    void setError(int errCode) { 
        Header_.error = errCode; 
    }

    const THttpAuthHeader* getAuthHeader() { 
        return &Header_; 
    }

    const THttpHeader* readHeader(); 
    long readPortion(void*& buf); 
    bool skipTheRest(); 
};

/********************************************************/
// Section 3: the main class
/********************************************************/
class httpLoadAgent: public httpSpecialAgent { 
protected: 
    socketHandlerFactory& Factory_; 
    bool HandleAuthorization_; 
    THttpURL URL_; 
    bool PersistentConn_; 
    httpAgentReader* Reader_; 
    TVector<TString> Headers_; 
    int ErrCode_; 
    char* RealHost_; 
    httpDigestHandler Digest_; 

    void clearReader();
    bool doSetHost(const TAddrList& addrs);
    bool doStartRequest();

public: 
    httpLoadAgent(bool handleAuthorization = false, 
                  socketHandlerFactory& factory = socketHandlerFactory::sInstance); 
    ~httpLoadAgent();

    void setRealHost(const char* host);
    void setIMS(const char* ifModifiedSince); 
    void addHeaderInstruction(const char* instr);
    void dropHeaderInstructions();

    bool startRequest(const char* url,
                      const char* url_to_merge = nullptr,
                      bool persistent = false, 
                      const TAddrList& addrs = TAddrList());

    // deprecated v4-only
    bool startRequest(const char* url,
                      const char* url_to_merge,
                      bool persistent, 
                      ui32 ip); 

    bool startRequest(const THttpURL& url,
                      bool persistent = false, 
                      const TAddrList& addrs = TAddrList());

    bool setHost(const char* host_url, 
                 const TAddrList& addrs = TAddrList()); 

    bool startOneRequest(const char* local_url);

    const THttpAuthHeader* getAuthHeader() { 
        if (Reader_ && Reader_->getAuthHeader()->use_auth) 
            return Reader_->getAuthHeader(); 
        return nullptr;
    }

    const THttpHeader* getHeader() { 
        if (Reader_) 
            return Reader_->getAuthHeader(); 
        return nullptr;
    }

    const THttpURL& getURL() { 
        return URL_; 
    }

    bool eof() { 
        if (Reader_) 
            return Reader_->eof(); 
        return true;
    }

    int error() { 
        if (ErrCode_) 
            return ErrCode_; 
        if (Reader_) 
            return Reader_->error(); 
        return HTTP_BAD_URL;
    }

    long readPortion(void*& buf) { 
        if (Reader_) 
            return Reader_->readPortion(buf); 
        return -1;
    }
};

/********************************************************/