Client.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2025 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_CLIENT_H
#define SQUID_SRC_CLIENTS_CLIENT_H
 
#include "base/AsyncJob.h"
#include "BodyPipe.h"
#include "CommCalls.h"
#include "FwdState.h"
#include "http/forward.h"
#include "StoreIOBuffer.h"
#if USE_ADAPTATION
#include "adaptation/forward.h"
#include "adaptation/Initiator.h"
#endif
 
class Client:
#if USE_ADAPTATION
    public Adaptation::Initiator,
    public BodyProducer,
#endif
    public BodyConsumer
{
 
public:
    Client(FwdState *);
    ~Client() override;
 
    virtual const Comm::ConnectionPointer & dataConnection() const = 0;
 
    // BodyConsumer: consume request body or adapted response body.
    // The implementation just calls the corresponding HTTP or ICAP handle*()
    // method, depending on the pipe.
    void noteMoreBodyDataAvailable(BodyPipe::Pointer) override;
    void noteBodyProductionEnded(BodyPipe::Pointer) override;
    void noteBodyProducerAborted(BodyPipe::Pointer) override;
 
    virtual void maybeReadVirginBody() = 0;
 
    virtual void abortAll(const char *reason) = 0;
 
    virtual bool abortOnData(const char *reason);
 
    virtual HttpRequestPointer originalRequest();
 
#if USE_ADAPTATION
    // Adaptation::Initiator API: start an ICAP transaction and receive adapted headers.
    void noteAdaptationAnswer(const Adaptation::Answer &answer) override;
    void noteAdaptationAclCheckDone(Adaptation::ServiceGroupPointer group) override;
 
    // BodyProducer: provide virgin response body to ICAP.
    void noteMoreBodySpaceAvailable(BodyPipe::Pointer ) override;
    void noteBodyConsumerAborted(BodyPipe::Pointer ) override;
#endif
    virtual bool getMoreRequestBody(MemBuf &buf);
    virtual void processReplyBody() = 0;
 
//AsyncJob virtual methods
    void swanSong() override;
    bool doneAll() const override;
 
public: // should be protected
    void serverComplete();     
    void markParsedVirginReplyAsWhole(const char *reasonWeAreSure);
 
private:
    void serverComplete2();    
    bool completed = false;            
protected:
    // kids customize these
    virtual void haveParsedReplyHeaders(); 
    virtual void completeForwarding(); 
    // BodyConsumer for HTTP: consume request body.
    bool startRequestBodyFlow();
    void handleMoreRequestBodyAvailable();
    void handleRequestBodyProductionEnded();
    virtual void handleRequestBodyProducerAborted() = 0;
 
    // sending of the request body to the server
    void sendMoreRequestBody();
    // has body; kids overwrite to increment I/O stats counters
    virtual void sentRequestBody(const CommIoCbParams &io) = 0;
    virtual void doneSendingRequestBody() = 0;
 
    virtual void closeServer() = 0;
    virtual bool doneWithServer() const = 0;   
    virtual bool mayReadVirginReplyBody() const = 0;
 
    virtual void noteDelayAwareReadChance() = 0;
 
    bool abortOnBadEntry(const char *abortReason);
 
    bool blockCaching();
 
#if USE_ADAPTATION
    void startAdaptation(const Adaptation::ServiceGroupPointer &group, HttpRequest *cause);
    void adaptVirginReplyBody(const char *buf, ssize_t len);
    void cleanAdaptation();
    virtual bool doneWithAdaptation() const;   
    // BodyConsumer for ICAP: consume adapted response body.
    void handleMoreAdaptedBodyAvailable();
    void handleAdaptedBodyProductionEnded();
    void handleAdaptedBodyProducerAborted();
 
    void handleAdaptedHeader(Http::Message *msg);
    void handleAdaptationCompleted();
    void handleAdaptationBlocked(const Adaptation::Answer &answer);
    void handleAdaptationAborted(bool bypassable = false);
    bool handledEarlyAdaptationAbort();
 
    void resumeBodyStorage();
 
    void checkAdaptationWithBodyCompletion();
#endif
 
protected:
    const HttpReply *virginReply() const;
    HttpReply *virginReply();
    HttpReply *setVirginReply(HttpReply *r);
 
    HttpReply *finalReply();
    HttpReply *setFinalReply(HttpReply *r);
 
    // Kids use these to stuff data into the response instead of messing with the entry directly
    void adaptOrFinalizeReply();
    void addVirginReplyBody(const char *buf, ssize_t len);
    void storeReplyBody(const char *buf, ssize_t len);
    size_t replyBodySpace(const MemBuf &readBuf, const size_t minSpace) const;
    size_t calcBufferSpaceToReserve(const size_t space, const size_t wantSpace) const;
 
    void adjustBodyBytesRead(const int64_t delta);
 
    void delayRead();
 
    // These should be private
    int64_t currentOffset = 0;  
    MemBuf *responseBodyBuffer = nullptr; 
public: // should not be
    StoreEntry *entry = nullptr;
    FwdState::Pointer fwd;
    HttpRequestPointer request;
 
protected:
    BodyPipe::Pointer requestBodySource;  
    AsyncCall::Pointer requestSender;     
#if USE_ADAPTATION
    BodyPipe::Pointer virginBodyDestination;  
    CbcPointer<Adaptation::Initiate> adaptedHeadSource;  
    BodyPipe::Pointer adaptedBodySource;      
    bool adaptationAccessCheckPending = false;
    bool startedAdaptation = false;
 
    bool receivedWholeAdaptedReply = false;
 
    bool adaptedReplyAborted = false; 
#endif
    bool receivedWholeRequestBody = false; 
 
    bool waitingForDelayAwareReadChance = false;
 
    const char *markedParsedVirginReplyAsWhole = nullptr;
 
    const char *doneWithFwd = nullptr;
 
private:
    void sendBodyIsTooLargeError();
    void maybePurgeOthers();
 
    HttpReply *theVirginReply = nullptr;       
    HttpReply *theFinalReply = nullptr;        
};
 
#endif /* SQUID_SRC_CLIENTS_CLIENT_H */