HttpTunneler.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2021 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.
 */
 
#ifndef SQUID_SRC_CLIENTS_HTTP_TUNNELER_H
#define SQUID_SRC_CLIENTS_HTTP_TUNNELER_H
 
#include "base/AsyncCbdataCalls.h"
#include "base/AsyncJob.h"
#include "clients/forward.h"
#include "clients/HttpTunnelerAnswer.h"
#include "CommCalls.h"
#if USE_DELAY_POOLS
#include "DelayId.h"
#endif
#include "http/forward.h"
 
class ErrorState;
class AccessLogEntry;
typedef RefCount<AccessLogEntry> AccessLogEntryPointer;
 
namespace Http
{
 
class Tunneler: virtual public AsyncJob
{
    CBDATA_CLASS(Tunneler);
 
public:
    template <class Initiator>
    class CbDialer: public CallDialer, public Http::TunnelerAnswer
    {
    public:
        // initiator method to receive our answer
        typedef void (Initiator::*Method)(Http::TunnelerAnswer &);
 
        CbDialer(Method method, Initiator *initiator): initiator_(initiator), method_(method) {}
        virtual ~CbDialer() = default;
 
        /* CallDialer API */
        bool canDial(AsyncCall &) { return initiator_.valid(); }
        void dial(AsyncCall &) {((*initiator_).*method_)(*this); }
        virtual void print(std::ostream &os) const override {
            os << '(' << static_cast<const Http::TunnelerAnswer&>(*this) << ')';
        }
    private:
        CbcPointer<Initiator> initiator_; 
        Method method_; 
    };
 
public:
    Tunneler(const Comm::ConnectionPointer &conn, const HttpRequestPointer &req, AsyncCall::Pointer &aCallback, time_t timeout, const AccessLogEntryPointer &alp);
    Tunneler(const Tunneler &) = delete;
    Tunneler &operator =(const Tunneler &) = delete;
 
#if USE_DELAY_POOLS
    void setDelayId(DelayId delay_id) {delayId = delay_id;}
#endif
 
    bool noteFwdPconnUse;
 
protected:
    /* AsyncJob API */
    virtual ~Tunneler();
    virtual void start();
    virtual bool doneAll() const;
    virtual void swanSong();
    virtual const char *status() const;
 
    void handleConnectionClosure(const CommCloseCbParams&);
    void watchForClosures();
    void handleTimeout(const CommTimeoutCbParams &);
    void startReadingResponse();
    void writeRequest();
    void handleWrittenRequest(const CommIoCbParams&);
    void handleReadyRead(const CommIoCbParams&);
    void readMore();
    void handleResponse(const bool eof);
    void bailOnResponseError(const char *error, HttpReply *);
 
private:
    void bailWith(ErrorState*);
 
    void sendSuccess();
 
    void callBack();
 
    void disconnect();
 
    void countFailingConnection();
 
    TunnelerAnswer &answer();
 
    AsyncCall::Pointer writer; 
    AsyncCall::Pointer reader; 
    AsyncCall::Pointer closer; 
 
    Comm::ConnectionPointer connection; 
    HttpRequestPointer request; 
    AsyncCall::Pointer callback; 
    SBuf url; 
    time_t lifetimeLimit; 
    AccessLogEntryPointer al; 
#if USE_DELAY_POOLS
    DelayId delayId;
#endif
 
    SBuf readBuf; 
    Http1::ResponseParserPointer hp;
 
    const time_t startTime; 
 
    bool requestWritten; 
    bool tunnelEstablished; 
};
 
} // namespace Http
 
#endif /* SQUID_SRC_CLIENTS_HTTP_TUNNELER_H */