FwdState.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.
 */
 
#ifndef SQUID_SRC_FWDSTATE_H
#define SQUID_SRC_FWDSTATE_H
 
#include "base/forward.h"
#include "base/JobWait.h"
#include "base/RefCount.h"
#include "clients/forward.h"
#include "comm.h"
#include "comm/Connection.h"
#include "error/forward.h"
#include "fde.h"
#include "http/StatusCode.h"
#include "ip/Address.h"
#include "ip/forward.h"
#include "PeerSelectState.h"
#include "ResolvedPeers.h"
#include "security/forward.h"
#if USE_OPENSSL
#include "ssl/support.h"
#endif
 
/* forward decls */
 
class AccessLogEntry;
typedef RefCount<AccessLogEntry> AccessLogEntryPointer;
class HttpRequest;
class PconnPool;
class ResolvedPeers;
typedef RefCount<ResolvedPeers> ResolvedPeersPointer;
 
class HappyConnOpener;
class HappyConnOpenerAnswer;
 
void GetMarkingsToServer(HttpRequest * request, Comm::Connection &conn);
 
void ResetMarkingsToServer(HttpRequest *, Comm::Connection &);
 
class HelperReply;
 
class PeeringActivityTimer
{
public:
    PeeringActivityTimer(const HttpRequestPointer &); 
    ~PeeringActivityTimer(); 
 
    void stop()
    {
        if (!stopped) {
            timer().pause();
            stopped = true;
        }
    }
 
private:
    Stopwatch &timer();
 
    HttpRequestPointer request;
 
    // We cannot rely on timer().ran(): This class eliminates excessive calls
    // within a single task (e.g., an AsyncJob) while the timer (and its ran()
    // state) may be shared/affected by multiple concurrent tasks.
    bool stopped = false;
};
 
class FwdState: public RefCountable, public PeerSelectionInitiator
{
    CBDATA_CHILD(FwdState);
 
public:
    typedef RefCount<FwdState> Pointer;
    ~FwdState() override;
    static void initModule();
 
    static void Start(const Comm::ConnectionPointer &client, StoreEntry *, HttpRequest *, const AccessLogEntryPointer &alp);
    static void fwdStart(const Comm::ConnectionPointer &client, StoreEntry *, HttpRequest *);
    static time_t ForwardTimeout(const time_t fwdStart);
    static bool EnoughTimeToReForward(const time_t fwdStart);
 
    void useDestinations();
 
    void fail(ErrorState *err);
    void unregister(Comm::ConnectionPointer &conn);
    void unregister(int fd);
    void complete();
 
    void markStoredReplyAsWhole(const char *whyWeAreSure);
 
    void handleUnregisteredServerEnd();
    int reforward();
    void serverClosed();
    void connectStart();
    void connectDone(const Comm::ConnectionPointer & conn, Comm::Flag status, int xerrno);
    bool checkRetry();
    bool checkRetriable();
    void dispatch();
 
    void pconnPush(Comm::ConnectionPointer & conn, const char *domain);
 
    bool dontRetry() { return flags.dont_retry; }
 
    void dontRetry(bool val) { flags.dont_retry = val; }
 
    void closePendingConnection(const Comm::ConnectionPointer &conn, const char *reason);
 
    Comm::ConnectionPointer const & serverConnection() const { return serverConn; };
 
private:
    // hidden for safer management of self; use static fwdStart
    FwdState(const Comm::ConnectionPointer &client, StoreEntry *, HttpRequest *, const AccessLogEntryPointer &alp);
    void start(Pointer aSelf);
    void stopAndDestroy(const char *reason);
 
    /* PeerSelectionInitiator API */
    void noteDestination(Comm::ConnectionPointer conn) override;
    void noteDestinationsEnd(ErrorState *selectionError) override;
 
    bool transporting() const;
 
    void noteConnection(HappyConnOpenerAnswer &);
 
#if STRICT_ORIGINAL_DST
    void selectPeerForIntercepted();
#endif
    static void logReplyStatus(int tries, const Http::StatusCode status);
    void doneWithRetries();
    void completed();
    void retryOrBail();
 
    void usePinned();
 
    bool pinnedCanRetry() const;
 
    template <typename StepStart>
    void advanceDestination(const char *stepDescription, const Comm::ConnectionPointer &conn, const StepStart &startStep);
 
    ErrorState *makeConnectingError(const err_type type) const;
    void connectedToPeer(Security::EncryptorAnswer &answer);
    static void RegisterWithCacheManager(void);
 
    void establishTunnelThruProxy(const Comm::ConnectionPointer &);
    void tunnelEstablishmentDone(Http::TunnelerAnswer &answer);
    void secureConnectionToPeerIfNeeded(const Comm::ConnectionPointer &);
    void secureConnectionToPeer(const Comm::ConnectionPointer &);
    void successfullyConnectedToPeer(const Comm::ConnectionPointer &);
 
    void closeServerConnection(const char *reason);
 
    void syncWithServerConn(const Comm::ConnectionPointer &server, const char *host, const bool reused);
    void syncHierNote(const Comm::ConnectionPointer &server, const char *host);
 
    bool exhaustedTries() const;
    void updateAttempts(int);
 
    time_t connectingTimeout(const Comm::ConnectionPointer &conn) const;
 
    void cancelStep(const char *reason);
 
    void notifyConnOpener();
    void reactToZeroSizeObject();
 
    void updateAleWithFinalError();
 
public:
    StoreEntry *entry;
    HttpRequest *request;
    AccessLogEntryPointer al; 
 
    static void HandleStoreAbort(FwdState *);
 
private:
    Pointer self;
    ErrorState *err;
    Comm::ConnectionPointer clientConn;        
    time_t start_t;
    int n_tries; 
 
    struct {
        bool connected_okay; 
        bool dont_retry;
        bool forward_completed;
        bool destinationsFound; 
    } flags;
 
    JobWait<HappyConnOpener> transportWait;
 
    JobWait<Security::PeerConnector> encryptionWait;
 
    JobWait<Http::Tunneler> peerWait;
 
    bool waitingForDispatched;
 
    ResolvedPeersPointer destinations; 
    Comm::ConnectionPointer serverConn; 
    PeerConnectionPointer destinationReceipt; 
 
    AsyncCall::Pointer closeHandler; 
 
    typedef enum { raceImpossible, racePossible, raceHappened } PconnRace;
    PconnRace pconnRace; 
 
    const char *storedWholeReply_;
 
    PeeringActivityTimer peeringTimer;
};
 
class acl_tos;
tos_t aclMapTOS(acl_tos *, ACLChecklist *);
 
Ip::NfMarkConfig aclFindNfMarkConfig(acl_nfmark *, ACLChecklist *);
void getOutgoingAddress(HttpRequest *, const Comm::ConnectionPointer &);
 
extern PconnPool *fwdPconnPool;
 
#endif /* SQUID_SRC_FWDSTATE_H */