AccessLogEntry.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_HTTPACCESSLOGENTRY_H
#define SQUID_HTTPACCESSLOGENTRY_H
 
#include "anyp/PortCfg.h"
#include "base/CodeContext.h"
#include "comm/Connection.h"
#include "error/Error.h"
#include "HierarchyLogEntry.h"
#include "http/ProtocolVersion.h"
#include "http/RequestMethod.h"
#include "HttpHeader.h"
#include "icp_opcode.h"
#include "ip/Address.h"
#include "LogTags.h"
#include "MessageSizes.h"
#include "Notes.h"
#include "proxyp/forward.h"
#include "sbuf/SBuf.h"
#if ICAP_CLIENT
#include "adaptation/icap/Elements.h"
#endif
#if USE_OPENSSL
#include "ssl/gadgets.h"
#include "ssl/support.h"
#endif
 
/* forward decls */
class HttpReply;
class HttpRequest;
class CustomLog;
 
class AccessLogEntry: public CodeContext
{
 
public:
    typedef RefCount<AccessLogEntry> Pointer;
 
    AccessLogEntry();
    ~AccessLogEntry() override;
 
    /* CodeContext API */
    std::ostream &detailCodeContext(std::ostream &os) const override;
    ScopedId codeContextGist() const override;
 
    void getLogClientIp(char *buf, size_t bufsz) const;
 
    const char *getLogClientFqdn(char *buf, size_t bufSize) const;
 
    const char *getClientIdent() const;
 
    const char *getExtUser() const;
 
    bool hasLogMethod() const { return icp.opcode || htcp.opcode || http.method; }
 
    SBuf getLogMethod() const;
 
    void syncNotes(HttpRequest *request);
 
    void packReplyHeaders(MemBuf &mb) const;
 
    SBuf url;
 
    Comm::ConnectionPointer tcpClient;
    // TCP/IP level details about the server or peer connection
    // are stored in hier.tcpServer
 
    class HttpDetails
    {
 
    public:
        HttpRequestMethod method;
        int code = 0;
        const char *content_type = nullptr;
        AnyP::ProtocolVersion version;
 
        // TODO calculate header and payload better (by parser)
        // XXX payload encoding overheads not calculated at all yet.
        MessageSizes clientRequestSz;
 
        // TODO calculate header and payload better (by parser)
        // XXX payload encoding overheads not calculated at all yet.
        MessageSizes clientReplySz;
 
    } http;
 
    class IcpDetails
    {
    public:
        icp_opcode opcode = ICP_INVALID;
    } icp;
 
    class HtcpDetails
    {
    public:
        const char *opcode = nullptr;
    } htcp;
 
#if USE_OPENSSL
    class SslDetails
    {
    public:
        const char *user = nullptr; 
        int bumpMode = ::Ssl::bumpEnd; 
    } ssl;
#endif
 
    class CacheDetails
    {
    public:
        CacheDetails() {
            caddr.setNoAddr();
            memset(&start_time, 0, sizeof(start_time));
            memset(&trTime, 0, sizeof(start_time));
        }
 
        Ip::Address caddr;
        int64_t highOffset = 0;
        int64_t objectSize = 0;
        LogTags code;
        struct timeval start_time; 
        struct timeval trTime; 
        const char *rfc931 = nullptr;
        const char *extuser = nullptr;
#if USE_OPENSSL
        const char *ssluser = nullptr;
        Security::CertPointer sslClientCert; 
#endif
        AnyP::PortCfgPointer port;
    } cache;
 
    class Headers
    {
    public:
        char *request = nullptr; //< virgin HTTP request headers
        char *adapted_request = nullptr; //< HTTP request headers after adaptation and redirection
    } headers;
 
#if USE_ADAPTATION
    class AdaptationDetails
    {
    public:
        char *last_meta = nullptr;
    } adapt;
#endif
 
    const char *lastAclName = nullptr; 
    SBuf lastAclData; 
 
    HierarchyLogEntry hier;
    HttpReplyPointer reply;
    HttpRequest *request = nullptr; //< virgin HTTP request
    HttpRequest *adapted_request = nullptr; //< HTTP request after adaptation and redirection
 
    NotePairs::Pointer notes;
 
    int requestAttempts = 0;
 
    ProxyProtocol::HeaderPointer proxyProtocolHeader;
 
#if ICAP_CLIENT
    class IcapLogEntry
    {
    public:
        IcapLogEntry() {
            memset(&trTime, 0, sizeof(trTime));
            memset(&ioTime, 0, sizeof(ioTime));
            memset(&processingTime, 0, sizeof(processingTime));
        }
 
        Ip::Address hostAddr; 
        String serviceName;        
        String reqUri;             
        Adaptation::Icap::ICAP::Method reqMethod = Adaptation::methodNone; 
        int64_t bytesSent = 0;       
        int64_t bytesRead = 0;       
        int64_t bodyBytesRead = -1;
        HttpRequest* request = nullptr;    
        HttpReply* reply = nullptr;        
 
        Adaptation::Icap::XactOutcome outcome = Adaptation::Icap::xoUnknown; 
        struct timeval trTime;
        struct timeval ioTime;
        Http::StatusCode resStatus = Http::scNone;   
        struct timeval processingTime;      
    }
    icap;
#endif
 
    const SBuf *effectiveVirginUrl() const;
 
    void setVirginUrlForMissingRequest(const SBuf &vu)
    {
        if (!request)
            virginUrlForMissingRequest_ = vu;
    }
 
    const Error *error() const;
 
    void updateError(const Error &);
 
private:
    Error error_;
 
    SBuf virginUrlForMissingRequest_;
};
 
class ACLChecklist;
class StoreEntry;
 
/* Should be in 'AccessLog.h' as the driver */
void accessLogLogTo(CustomLog *, const AccessLogEntryPointer &, ACLChecklist *checklist = nullptr);
void accessLogLog(const AccessLogEntryPointer &, ACLChecklist *);
void accessLogRotate(void);
void accessLogClose(void);
void accessLogInit(void);
const char *accessLogTime(time_t);
 
#endif /* SQUID_HTTPACCESSLOGENTRY_H */