HttpRequest.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_HTTPREQUEST_H
#define SQUID_HTTPREQUEST_H
 
#include "anyp/Uri.h"
#include "base/CbcPointer.h"
#include "dns/forward.h"
#include "error/Error.h"
#include "HierarchyLogEntry.h"
#include "http/Message.h"
#include "http/RequestMethod.h"
#include "MasterXaction.h"
#include "Notes.h"
#include "RequestFlags.h"
 
#if USE_AUTH
#include "auth/UserRequest.h"
#endif
#if USE_ADAPTATION
#include "adaptation/History.h"
#endif
#if ICAP_CLIENT
#include "adaptation/icap/History.h"
#endif
#if USE_SQUID_EUI
#include "eui/Eui48.h"
#include "eui/Eui64.h"
#endif
 
class AccessLogEntry;
typedef RefCount<AccessLogEntry> AccessLogEntryPointer;
class CachePeer;
class ConnStateData;
class Downloader;
 
/*  Http Request */
void httpRequestPack(void *obj, Packable *p);
 
class HttpHdrRange;
 
class HttpRequest: public Http::Message
{
    MEMPROXY_CLASS(HttpRequest);
 
public:
    typedef RefCount<HttpRequest> Pointer;
 
    HttpRequest(const MasterXaction::Pointer &);
    HttpRequest(const HttpRequestMethod& aMethod, AnyP::ProtocolType aProtocol, const char *schemeImage, const char *aUrlpath, const MasterXaction::Pointer &);
    ~HttpRequest() override;
    void reset() override;
 
    void initHTTP(const HttpRequestMethod& aMethod, AnyP::ProtocolType aProtocol, const char *schemeImage, const char *aUrlpath);
 
    HttpRequest *clone() const override;
 
    bool maybeCacheable();
 
    bool conditional() const; 
 
    bool canHandle1xx() const;
 
    char *canonicalCleanUrl() const;
 
#if USE_ADAPTATION
    Adaptation::History::Pointer adaptLogHistory() const;
    Adaptation::History::Pointer adaptHistory(bool createIfNone = false) const;
    void adaptHistoryImport(const HttpRequest &them);
#endif
#if ICAP_CLIENT
    Adaptation::Icap::History::Pointer icapHistory() const;
#endif
 
    /* If a request goes through several destinations, then the following two
     * methods will be called several times, in destinations-dependent order. */
    void prepForPeering(const CachePeer &peer);
    void prepForDirect();
 
    void recordLookup(const Dns::LookupDetails &detail);
 
    void detailError(const err_type c, const ErrorDetail::Pointer &d) { error.update(c, d); }
    void clearError();
 
    void manager(const CbcPointer<ConnStateData> &aMgr, const AccessLogEntryPointer &al);
 
protected:
    void clean();
 
    void init();
 
public:
    HttpRequestMethod method;
    AnyP::Uri url; 
 
private:
#if USE_ADAPTATION
    mutable Adaptation::History::Pointer adaptHistory_; 
#endif
#if ICAP_CLIENT
    mutable Adaptation::Icap::History::Pointer icapHistory_; 
#endif
 
public:
#if USE_AUTH
    Auth::UserRequest::Pointer auth_user_request;
#endif
 
    const SBuf &effectiveRequestUri() const;
 
    String store_id;
 
    RequestFlags flags;
 
    HttpHdrRange *range;
 
    time_t ims;
 
    int imslen;
 
    Ip::Address client_addr;
 
#if FOLLOW_X_FORWARDED_FOR
    Ip::Address indirect_client_addr;
#endif /* FOLLOW_X_FORWARDED_FOR */
 
    Ip::Address my_addr;
 
    HierarchyLogEntry hier;
 
    int dnsWait; 
 
    Error error; 
 
    char *peer_login;       /* Configured peer login:password */
 
    char *peer_host;           /* Selected peer host*/
 
    time_t lastmod;     /* Used on refreshes */
 
    SBuf vary_headers;
 
    char *peer_domain;      /* Configured peer forceddomain */
 
    String myportname; // Internal tag name= value from port this requests arrived in.
 
    String tag;         /* Internal tag for this request */
 
    String extacl_user;     /* User name returned by extacl lookup */
 
    String extacl_passwd;   /* Password returned by extacl lookup */
 
    String extacl_log;      /* String to be used for access.log purposes */
 
    String extacl_message;  /* String to be used for error page purposes */
 
#if FOLLOW_X_FORWARDED_FOR
    String x_forwarded_for_iterator; /* XXX a list of IP addresses */
#endif /* FOLLOW_X_FORWARDED_FOR */
 
    String etag;
 
    bool forcedBodyContinuation;
 
public:
    bool multipartRangeRequest() const;
 
    bool parseFirstLine(const char *start, const char *end) override;
 
    bool expectingBody(const HttpRequestMethod& unused, int64_t&) const override;
 
    bool bodyNibbled() const; // the request has a [partially] consumed body
 
    int prefixLen() const;
 
    void swapOut(StoreEntry * e);
 
    void pack(Packable * p) const;
 
    static void httpRequestPack(void *obj, Packable *p);
 
    static HttpRequest * FromUrl(const SBuf &url, const MasterXaction::Pointer &, const HttpRequestMethod &method = Http::METHOD_GET);
 
    static HttpRequest * FromUrlXXX(const char * url, const MasterXaction::Pointer &, const HttpRequestMethod &method = Http::METHOD_GET);
 
    ConnStateData *pinnedConnection();
 
    const SBuf storeId();
 
    CbcPointer<ConnStateData> clientConnectionManager;
 
    CbcPointer<Downloader> downloader;
 
    MasterXaction::Pointer masterXaction;
 
    void ignoreRange(const char *reason);
    int64_t getRangeOffsetLimit(); /* the result of this function gets cached in rangeOffsetLimit */
 
    NotePairs::Pointer notes();
    bool hasNotes() const { return bool(theNotes) && !theNotes->empty(); }
 
    void configureContentLengthInterpreter(Http::ContentLengthInterpreter &) override {}
 
    Http::StatusCode checkEntityFraming() const;
 
    bool parseHeader(Http1::Parser &hp);
    bool parseHeader(const char *buffer, const size_t size);
 
private:
    mutable int64_t rangeOffsetLimit;  /* caches the result of getRangeOffsetLimit */
 
    NotePairs::Pointer theNotes;
protected:
    void packFirstLineInto(Packable * p, bool full_uri) const override;
 
    bool sanityCheckStartLine(const char *buf, const size_t hdr_len, Http::StatusCode *error) override;
 
    void hdrCacheInit() override;
 
    bool inheritProperties(const Http::Message *) override;
};
 
class ConnStateData;
void UpdateRequestNotes(ConnStateData *csd, HttpRequest &request, NotePairs const &notes);
 
const Ip::Address *FindListeningPortAddress(const HttpRequest *, const AccessLogEntry *);
 
AnyP::Port FindListeningPortNumber(const HttpRequest *, const AccessLogEntry *);
 
#endif /* SQUID_HTTPREQUEST_H */