src/AccessLogEntry.h

   1 /*
   2  * Copyright (C) 1996-2014 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 #ifndef SQUID_HTTPACCESSLOGENTRY_H
  10 #define SQUID_HTTPACCESSLOGENTRY_H
  11
  12 #include "anyp/PortCfg.h"
  13 #include "base/RefCount.h"
  14 #include "comm/Connection.h"
  15 #include "HierarchyLogEntry.h"
  16 #include "http/ProtocolVersion.h"
  17 #include "HttpHeader.h"
  18 #include "HttpRequestMethod.h"
  19 #include "icp_opcode.h"
  20 #include "ip/Address.h"
  21 #include "LogTags.h"
  22 #include "MessageSizes.h"
  23 #include "Notes.h"
  24 #if ICAP_CLIENT
  25 #include "adaptation/icap/Elements.h"
  26 #endif
  27 #if USE_OPENSSL
  28 #include "ssl/gadgets.h"
  29 #endif
  30
  31 /* forward decls */
  32 class HttpReply;
  33 class HttpRequest;
  34 class CustomLog;
  35
  36 class AccessLogEntry: public RefCountable
  37 {
  38
  39 public:
  40     typedef RefCount<AccessLogEntry> Pointer;
  41
  42     AccessLogEntry() : url(NULL), tcpClient(), reply(NULL), request(NULL),
  43             adapted_request(NULL) {}
  44     ~AccessLogEntry();
  45
  46     /// Fetch the client IP log string into the given buffer.
  47     /// Knows about several alternate locations of the IP
  48     /// including indirect forwarded-for IP if configured to log that
  49     void getLogClientIp(char *buf, size_t bufsz) const;
  50
  51     const char *url;
  52
  53     /// TCP/IP level details about the client connection
  54     Comm::ConnectionPointer tcpClient;
  55     // TCP/IP level details about the server or peer connection
  56     // are stored in hier.tcpServer
  57
  58     /** \brief This subclass holds log info for HTTP protocol
  59      * \todo Inner class declarations should be moved outside
  60      * \todo details of HTTP held in the parent class need moving into here.
  61      */
  62     class HttpDetails
  63     {
  64
  65     public:
  66         HttpDetails() : method(Http::METHOD_NONE), code(0), content_type(NULL),
  67                 timedout(false),
  68                 aborted(false),
  69                 clientRequestSz(),
  70                 clientReplySz() {}
  71
  72         HttpRequestMethod method;
  73         int code;
  74         const char *content_type;
  75         Http::ProtocolVersion version;
  76         bool timedout; ///< terminated due to a lifetime or I/O timeout
  77         bool aborted; ///< other abnormal termination (e.g., I/O error)
  78
  79         /// compute suffix for the status access.log field
  80         const char *statusSfx() const {
  81             return timedout ? "_TIMEDOUT" : (aborted ? "_ABORTED" : "");
  82         }
  83
  84         /// counters for the original request received from client
  85         // TODO calculate header and payload better (by parser)
  86         // XXX payload encoding overheads not calculated at all yet.
  87         MessageSizes clientRequestSz;
  88
  89         /// counters for the response sent to client
  90         // TODO calculate header and payload better (by parser)
  91         // XXX payload encoding overheads not calculated at all yet.
  92         MessageSizes clientReplySz;
  93
  94     } http;
  95
  96     /** \brief This subclass holds log info for ICP protocol
  97      * \todo Inner class declarations should be moved outside
  98      */
  99     class IcpDetails
 100     {
 101
 102     public:
 103         IcpDetails() : opcode(ICP_INVALID) {}
 104
 105         icp_opcode opcode;
 106     } icp;
 107
 108     /** \brief This subclass holds log info for HTCP protocol
 109      * \todo Inner class declarations should be moved outside
 110      */
 111     class HtcpDetails
 112     {
 113     public:
 114         HtcpDetails() : opcode(NULL) {};
 115
 116         const char *opcode;
 117     } htcp;
 118
 119 #if USE_OPENSSL
 120     /// logging information specific to the SSL protocol
 121     class SslDetails
 122     {
 123     public:
 124         SslDetails();
 125
 126         const char *user; ///< emailAddress from the SSL client certificate
 127         int bumpMode; ///< whether and how the request was SslBumped
 128     } ssl;
 129 #endif
 130
 131     /** \brief This subclass holds log info for Squid internal stats
 132      * \todo Inner class declarations should be moved outside
 133      * \todo some details relevant to particular protocols need shuffling to other sub-classes
 134      * \todo this object field need renaming to 'squid' or something.
 135      */
 136     class CacheDetails
 137     {
 138
 139     public:
 140         CacheDetails() : caddr(),
 141                 highOffset(0),
 142                 objectSize(0),
 143                 code (LOG_TAG_NONE),
 144                 msec(0),
 145                 rfc931 (NULL),
 146                 extuser(NULL),
 147 #if USE_OPENSSL
 148                 ssluser(NULL),
 149 #endif
 150                 port(NULL) {
 151             caddr.setNoAddr();
 152         }
 153
 154         Ip::Address caddr;
 155         int64_t highOffset;
 156         int64_t objectSize;
 157         LogTags code;
 158         struct timeval start_time; ///< The time the master transaction started
 159         int msec;
 160         const char *rfc931;
 161         const char *extuser;
 162 #if USE_OPENSSL
 163
 164         const char *ssluser;
 165         Ssl::X509_Pointer sslClientCert; ///< cert received from the client
 166 #endif
 167         AnyP::PortCfgPointer port;
 168
 169     } cache;
 170
 171     /** \brief This subclass holds log info for various headers in raw format
 172      * \todo shuffle this to the relevant protocol section.
 173      */
 174     class Headers
 175     {
 176
 177     public:
 178         Headers() : request(NULL),
 179                 adapted_request(NULL),
 180                 reply(NULL) {}
 181
 182         char *request; //< virgin HTTP request headers
 183
 184         char *adapted_request; //< HTTP request headers after adaptation and redirection
 185
 186         char *reply;
 187     } headers;
 188
 189 #if USE_ADAPTATION
 190     /** \brief This subclass holds general adaptation log info.
 191      * \todo Inner class declarations should be moved outside.
 192      */
 193     class AdaptationDetails
 194     {
 195
 196     public:
 197         AdaptationDetails(): last_meta(NULL) {}
 198
 199         /// image of the last ICAP response header or eCAP meta received
 200         char *last_meta;
 201     } adapt;
 202 #endif
 203
 204     // Why is this a sub-class and not a set of real "private:" fields?
 205     // TODO: shuffle this to the relevant ICP/HTCP protocol section
 206     class Private
 207     {
 208
 209     public:
 210         Private() : method_str(NULL) {}
 211
 212         const char *method_str;
 213     } _private;
 214     HierarchyLogEntry hier;
 215     HttpReply *reply;
 216     HttpRequest *request; //< virgin HTTP request
 217     HttpRequest *adapted_request; //< HTTP request after adaptation and redirection
 218
 219     /// key:value pairs set by squid.conf note directive and
 220     /// key=value pairs returned from URL rewrite/redirect helper
 221     NotePairs::Pointer notes;
 222
 223 #if ICAP_CLIENT
 224     /** \brief This subclass holds log info for ICAP part of request
 225      *  \todo Inner class declarations should be moved outside
 226      */
 227     class IcapLogEntry
 228     {
 229     public:
 230         IcapLogEntry() : reqMethod(Adaptation::methodNone), bytesSent(0), bytesRead(0),
 231                 bodyBytesRead(-1), request(NULL), reply(NULL),
 232                 outcome(Adaptation::Icap::xoUnknown), trTime(0),
 233                 ioTime(0), resStatus(Http::scNone), processingTime(0) {}
 234
 235         Ip::Address hostAddr; ///< ICAP server IP address
 236         String serviceName;        ///< ICAP service name
 237         String reqUri;             ///< ICAP Request-URI
 238         Adaptation::Icap::ICAP::Method reqMethod; ///< ICAP request method
 239         int64_t bytesSent;       ///< number of bytes sent to ICAP server so far
 240         int64_t bytesRead;       ///< number of bytes read from ICAP server so far
 241         /**
 242          * number of ICAP body bytes read from ICAP server or -1 for no encapsulated
 243          * message data in ICAP reply (eg 204 responses)
 244          */
 245         int64_t bodyBytesRead;
 246         HttpRequest* request;    ///< ICAP request
 247         HttpReply* reply;        ///< ICAP reply
 248
 249         Adaptation::Icap::XactOutcome outcome; ///< final transaction status
 250         /** \brief Transaction response time.
 251          * The timer starts when the ICAP transaction
 252          *  is created and stops when the result of the transaction is logged
 253          */
 254         int trTime;
 255         /** \brief Transaction I/O time.
 256          * The timer starts when the first ICAP request
 257          * byte is scheduled for sending and stops when the lastbyte of the
 258          * ICAP response is received.
 259          */
 260         int ioTime;
 261         Http::StatusCode resStatus;   ///< ICAP response status code
 262         int processingTime;      ///< total ICAP processing time in milliseconds
 263     }
 264     icap;
 265 #endif
 266 };
 267
 268 class ACLChecklist;
 269 class StoreEntry;
 270
 271 /* Should be in 'AccessLog.h' as the driver */
 272 void accessLogLogTo(CustomLog* log, AccessLogEntry::Pointer &al, ACLChecklist* checklist = NULL);
 273 void accessLogLog(AccessLogEntry::Pointer &, ACLChecklist * checklist);
 274 void accessLogRotate(void);
 275 void accessLogClose(void);
 276 void accessLogInit(void);
 277 const char *accessLogTime(time_t);
 278
 279 #endif /* SQUID_HTTPACCESSLOGENTRY_H */