src/format/Token.cc

   1 #include "squid.h"
   2 #include "format/Config.h"
   3 #include "format/Token.h"
   4 #include "format/TokenTableEntry.h"
   5 #include "globals.h"
   6 #include "SquidConfig.h"
   7 #include "Store.h"
   8
   9 // Due to token overlaps between 1 and 2 letter tokens (Bug 3310)
  10 // We split the token table into sets determined by the token length
  11 namespace Format
  12 {
  13
  14 /// 1-char tokens.
  15 static TokenTableEntry TokenTable1C[] = {
  16
  17     {">a", LFT_CLIENT_IP_ADDRESS},
  18     {">p", LFT_CLIENT_PORT},
  19     {">A", LFT_CLIENT_FQDN},
  20
  21     {"<a", LFT_SERVER_IP_ADDRESS},
  22     {"<p", LFT_SERVER_PORT},
  23     {"<A", LFT_SERVER_FQDN_OR_PEER_NAME},
  24
  25     {">h", LFT_REQUEST_HEADER},
  26     {">h", LFT_REQUEST_ALL_HEADERS},
  27     {"<h", LFT_REPLY_HEADER},
  28     {"<h", LFT_REPLY_ALL_HEADERS},
  29
  30     {">v", LFT_REQUEST_VERSION_OLD_2X},
  31
  32     {"%", LFT_PERCENT},
  33
  34     {NULL, LFT_NONE}            /* this must be last */
  35 };
  36
  37 /// 2-char tokens
  38 static TokenTableEntry TokenTable2C[] = {
  39
  40     {">la", LFT_CLIENT_LOCAL_IP},
  41     {"la", LFT_LOCAL_LISTENING_IP},
  42     {">lp", LFT_CLIENT_LOCAL_PORT},
  43     {"lp", LFT_LOCAL_LISTENING_PORT},
  44     /*{ "lA", LFT_LOCAL_NAME }, */
  45
  46     {"<la", LFT_SERVER_LOCAL_IP},
  47     {"oa", LFT_SERVER_LOCAL_IP_OLD_27},
  48     {"<lp", LFT_SERVER_LOCAL_PORT},
  49
  50     {"ts", LFT_TIME_SECONDS_SINCE_EPOCH},
  51     {"tu", LFT_TIME_SUBSECOND},
  52     {"tl", LFT_TIME_LOCALTIME},
  53     {"tg", LFT_TIME_GMT},
  54     {"tS", LFT_TIME_START},
  55     {"tr", LFT_TIME_TO_HANDLE_REQUEST},
  56
  57     {"<pt", LFT_PEER_RESPONSE_TIME},
  58     {"<tt", LFT_TOTAL_SERVER_SIDE_RESPONSE_TIME},
  59     {"dt", LFT_DNS_WAIT_TIME},
  60
  61     {">ha", LFT_ADAPTED_REQUEST_HEADER},
  62     {">ha", LFT_ADAPTED_REQUEST_ALL_HEADERS},
  63
  64     {"un", LFT_USER_NAME},
  65     {"ul", LFT_USER_LOGIN},
  66     /*{ "ur", LFT_USER_REALM }, */
  67     /*{ "us", LFT_USER_SCHEME }, */
  68     {"ui", LFT_USER_IDENT},
  69     {"ue", LFT_USER_EXTERNAL},
  70
  71     {"Hs", LFT_HTTP_SENT_STATUS_CODE_OLD_30},
  72     {">Hs", LFT_HTTP_SENT_STATUS_CODE},
  73     {"<Hs", LFT_HTTP_RECEIVED_STATUS_CODE},
  74     /*{ "Ht", LFT_HTTP_STATUS }, */
  75     {"<bs", LFT_HTTP_BODY_BYTES_READ},
  76
  77     {"Ss", LFT_SQUID_STATUS},
  78     {"Sh", LFT_SQUID_HIERARCHY},
  79
  80     {"mt", LFT_MIME_TYPE},
  81
  82     {">rm", LFT_CLIENT_REQ_METHOD},
  83     {">ru", LFT_CLIENT_REQ_URI},
  84     {">rs", LFT_CLIENT_REQ_URLSCHEME},
  85     {">rd", LFT_CLIENT_REQ_URLDOMAIN},
  86     {">rP", LFT_CLIENT_REQ_URLPORT},
  87     {">rp", LFT_CLIENT_REQ_URLPATH},
  88     /*{">rq", LFT_CLIENT_REQ_QUERY},*/
  89     {">rv", LFT_CLIENT_REQ_VERSION},
  90
  91     {"rm", LFT_REQUEST_METHOD},
  92     {"ru", LFT_REQUEST_URI},    /* doesn't include the query-string */
  93     {"rp", LFT_REQUEST_URLPATH_OLD_31},
  94     /* { "rq", LFT_REQUEST_QUERY }, * /     / * the query-string, INCLUDING the leading ? */
  95     {"rv", LFT_REQUEST_VERSION},
  96     {"rG", LFT_REQUEST_URLGROUP_OLD_2X},
  97
  98     {"<rm", LFT_SERVER_REQ_METHOD},
  99     {"<ru", LFT_SERVER_REQ_URI},
 100     {"<rs", LFT_SERVER_REQ_URLSCHEME},
 101     {"<rd", LFT_SERVER_REQ_URLDOMAIN},
 102     {"<rP", LFT_SERVER_REQ_URLPORT},
 103     {"<rp", LFT_SERVER_REQ_URLPATH},
 104     /*{"<rq", LFT_SERVER_REQ_QUERY},*/
 105     {"<rv", LFT_SERVER_REQ_VERSION},
 106
 107     {">st", LFT_CLIENT_REQUEST_SIZE_TOTAL },
 108     {">sh", LFT_CLIENT_REQUEST_SIZE_HEADERS },
 109     /*{ ">sb", LFT_REQUEST_SIZE_BODY }, */
 110     /*{ ">sB", LFT_REQUEST_SIZE_BODY_NO_TE }, */
 111
 112     {"<st", LFT_ADAPTED_REPLY_SIZE_TOTAL}, // XXX: adapted should be code: <sta
 113     {"<sH", LFT_REPLY_HIGHOFFSET},
 114     {"<sS", LFT_REPLY_OBJECTSIZE},
 115     {"<sh", LFT_ADAPTED_REPLY_SIZE_HEADERS }, // XXX: adapted should be code: <sha
 116     /*{ "<sb", LFT_REPLY_SIZE_BODY }, */
 117     /*{ "<sB", LFT_REPLY_SIZE_BODY_NO_TE }, */
 118
 119     {"st", LFT_CLIENT_IO_SIZE_TOTAL}, // XXX: total from client should be stC ??
 120     /*{"stP", LFT_SERVER_IO_SIZE_TOTAL},*/
 121
 122     {"et", LFT_TAG},
 123     {"ea", LFT_EXT_LOG},
 124     {"sn", LFT_SEQUENCE_NUMBER},
 125
 126     {NULL, LFT_NONE}            /* this must be last */
 127 };
 128
 129 /// Miscellaneous >2 byte tokens
 130 static TokenTableEntry TokenTableMisc[] = {
 131     {">eui", LFT_CLIENT_EUI},
 132     {">qos", LFT_CLIENT_LOCAL_TOS},
 133     {"<qos", LFT_SERVER_LOCAL_TOS},
 134     {">nfmark", LFT_CLIENT_LOCAL_NFMARK},
 135     {"<nfmark", LFT_SERVER_LOCAL_NFMARK},
 136     {"err_code", LFT_SQUID_ERROR },
 137     {"err_detail", LFT_SQUID_ERROR_DETAIL },
 138     {"note", LFT_NOTE },
 139     {"credentials", LFT_CREDENTIALS},
 140     {NULL, LFT_NONE}            /* this must be last */
 141 };
 142
 143 #if USE_ADAPTATION
 144 static TokenTableEntry TokenTableAdapt[] = {
 145     {"all_trs", LFT_ADAPTATION_ALL_XACT_TIMES},
 146     {"sum_trs", LFT_ADAPTATION_SUM_XACT_TIMES},
 147     {"<last_h", LFT_ADAPTATION_LAST_HEADER},
 148     {NULL, LFT_NONE}           /* this must be last */
 149 };
 150 #endif
 151
 152 #if ICAP_CLIENT
 153 /// ICAP (icap::) tokens
 154 static TokenTableEntry TokenTableIcap[] = {
 155     {"tt", LFT_ICAP_TOTAL_TIME},
 156     {"<last_h", LFT_ADAPTATION_LAST_HEADER}, // deprecated
 157
 158     {"<A",  LFT_ICAP_ADDR},
 159     {"<service_name",  LFT_ICAP_SERV_NAME},
 160     {"ru",  LFT_ICAP_REQUEST_URI},
 161     {"rm",  LFT_ICAP_REQUEST_METHOD},
 162     {">st", LFT_ICAP_BYTES_SENT},
 163     {"<st", LFT_ICAP_BYTES_READ},
 164     {"<bs", LFT_ICAP_BODY_BYTES_READ},
 165
 166     {">h",  LFT_ICAP_REQ_HEADER},
 167     {"<h",  LFT_ICAP_REP_HEADER},
 168
 169     {"tr",  LFT_ICAP_TR_RESPONSE_TIME},
 170     {"tio", LFT_ICAP_IO_TIME},
 171     {"to",  LFT_ICAP_OUTCOME},
 172     {"Hs",  LFT_ICAP_STATUS_CODE},
 173
 174     {NULL, LFT_NONE}           /* this must be last */
 175 };
 176 #endif
 177
 178 #if USE_OPENSSL
 179 // SSL (ssl::) tokens
 180 static TokenTableEntry TokenTableSsl[] = {
 181     {"bump_mode", LFT_SSL_BUMP_MODE},
 182     {">cert_subject", LFT_SSL_USER_CERT_SUBJECT},
 183     {">cert_issuer", LFT_SSL_USER_CERT_ISSUER},
 184     {NULL, LFT_NONE}
 185 };
 186 #endif
 187 } // namespace Format
 188
 189 /// Register all components custom format tokens
 190 void
 191 Format::Token::Init()
 192 {
 193     // TODO standard log tokens
 194     // TODO external ACL fmt tokens
 195
 196 #if USE_ADAPTATION
 197     TheConfig.registerTokens(String("adapt"),::Format::TokenTableAdapt);
 198 #endif
 199 #if ICAP_CLIENT
 200     TheConfig.registerTokens(String("icap"),::Format::TokenTableIcap);
 201 #endif
 202 #if USE_OPENSSL
 203     TheConfig.registerTokens(String("ssl"),::Format::TokenTableSsl);
 204 #endif
 205 }
 206
 207 /// Scans a token table to see if the next token exists there
 208 /// returns a pointer to next unparsed byte and updates type member if found
 209 const char *
 210 Format::Token::scanForToken(TokenTableEntry const table[], const char *cur)
 211 {
 212     for (TokenTableEntry const *lte = table; lte->configTag != NULL; ++lte) {
 213         debugs(46, 8, HERE << "compare tokens '" << lte->configTag << "' with '" << cur << "'");
 214         if (strncmp(lte->configTag, cur, strlen(lte->configTag)) == 0) {
 215             type = lte->tokenType;
 216             label = lte->configTag;
 217             debugs(46, 7, HERE << "Found token '" << label << "'");
 218             return cur + strlen(lte->configTag);
 219         }
 220     }
 221     return cur;
 222 }
 223
 224 /* parses a single token. Returns the token length in characters,
 225  * and fills in the lt item with the token information.
 226  * def is for sure null-terminated
 227  */
 228 int
 229 Format::Token::parse(const char *def, Quoting *quoting)
 230 {
 231     const char *cur = def;
 232
 233     int l;
 234
 235     l = strcspn(cur, "%");
 236
 237     if (l > 0) {
 238         char *cp;
 239         /* it's a string for sure, until \0 or the next % */
 240         cp = (char *)xmalloc(l + 1);
 241         xstrncpy(cp, cur, l + 1);
 242         type = LFT_STRING;
 243         data.string = cp;
 244
 245         while (l > 0) {
 246             switch (*cur) {
 247
 248             case '"':
 249
 250                 if (*quoting == LOG_QUOTE_NONE)
 251                     *quoting = LOG_QUOTE_QUOTES;
 252                 else if (*quoting == LOG_QUOTE_QUOTES)
 253                     *quoting = LOG_QUOTE_NONE;
 254
 255                 break;
 256
 257             case '[':
 258                 if (*quoting == LOG_QUOTE_NONE)
 259                     *quoting = LOG_QUOTE_MIMEBLOB;
 260
 261                 break;
 262
 263             case ']':
 264                 if (*quoting == LOG_QUOTE_MIMEBLOB)
 265                     *quoting = LOG_QUOTE_NONE;
 266
 267                 break;
 268             }
 269
 270             ++cur;
 271             --l;
 272         }
 273
 274         goto done;
 275     }
 276
 277     if (!*cur)
 278         goto done;
 279
 280     ++cur;
 281
 282     // select quoting style for his particular token
 283     switch (*cur) {
 284
 285     case '"':
 286         quote = LOG_QUOTE_QUOTES;
 287         ++cur;
 288         break;
 289
 290     case '\'':
 291         quote = LOG_QUOTE_RAW;
 292         ++cur;
 293         break;
 294
 295     case '[':
 296         quote = LOG_QUOTE_MIMEBLOB;
 297         ++cur;
 298         break;
 299
 300     case '#':
 301         quote = LOG_QUOTE_URL;
 302         ++cur;
 303         break;
 304
 305     default:
 306         quote = *quoting;
 307         break;
 308     }
 309
 310     if (*cur == '-') {
 311         left = true;
 312         ++cur;
 313     }
 314
 315     if (*cur == '0') {
 316         zero = true;
 317         ++cur;
 318     }
 319
 320     char *endp;
 321     if (xisdigit(*cur)) {
 322         widthMin = strtol(cur, &endp, 10);
 323         cur = endp;
 324     }
 325
 326     if (*cur == '.' && xisdigit(*(++cur))) {
 327         widthMax = strtol(cur, &endp, 10);
 328         cur = endp;
 329     }
 330
 331     if (*cur == '{') {
 332         char *cp;
 333         ++cur;
 334         l = strcspn(cur, "}");
 335         cp = (char *)xmalloc(l + 1);
 336         xstrncpy(cp, cur, l + 1);
 337         data.string = cp;
 338         cur += l;
 339
 340         if (*cur == '}')
 341             ++cur;
 342     }
 343
 344     type = LFT_NONE;
 345
 346     // Scan each registered token namespace
 347     debugs(46, 9, HERE << "check for token in " << TheConfig.tokens.size() << " namespaces.");
 348     for (std::list<TokenNamespace>::const_iterator itr = TheConfig.tokens.begin(); itr != TheConfig.tokens.end(); ++itr) {
 349         debugs(46, 7, HERE << "check for possible " << itr->prefix << ":: token");
 350         const size_t len = itr->prefix.size();
 351         if (itr->prefix.cmp(cur, len) == 0 && cur[len] == ':' && cur[len+1] == ':') {
 352             debugs(46, 5, HERE << "check for " << itr->prefix << ":: token in '" << cur << "'");
 353             const char *old = cur;
 354             cur = scanForToken(itr->tokenSet, cur+len+2);
 355             if (old != cur) // found
 356                 break;
 357             else // reset to start of namespace
 358                 cur = cur - len - 2;
 359         }
 360     }
 361
 362     if (type == LFT_NONE) {
 363         // For upward compatibility, assume "http::" prefix as default prefix
 364         // for all log access formatting codes, except those starting with a
 365         // "%" or a known namespace. (ie "icap::", "adapt::")
 366         if (strncmp(cur,"http::", 6) == 0 && *(cur+6) != '%' )
 367             cur += 6;
 368
 369         // NP: scan the sets of tokens in decreasing size to guarantee no
 370         //     mistakes made with overlapping names. (Bug 3310)
 371
 372         // Scan for various long tokens
 373         debugs(46, 5, HERE << "scan for possible Misc token");
 374         cur = scanForToken(TokenTableMisc, cur);
 375         // scan for 2-char tokens
 376         if (type == LFT_NONE) {
 377             debugs(46, 5, HERE << "scan for possible 2C token");
 378             cur = scanForToken(TokenTable2C, cur);
 379         }
 380         // finally scan for 1-char tokens.
 381         if (type == LFT_NONE) {
 382             debugs(46, 5, HERE << "scan for possible 1C token");
 383             cur = scanForToken(TokenTable1C, cur);
 384         }
 385     }
 386
 387     if (type == LFT_NONE) {
 388         fatalf("Can't parse configuration token: '%s'\n", def);
 389     }
 390
 391     if (*cur == ' ') {
 392         space = true;
 393         ++cur;
 394     }
 395
 396 done:
 397
 398     switch (type) {
 399
 400 #if USE_ADAPTATION
 401     case LFT_ADAPTATION_LAST_HEADER:
 402 #endif
 403
 404 #if ICAP_CLIENT
 405     case LFT_ICAP_REQ_HEADER:
 406
 407     case LFT_ICAP_REP_HEADER:
 408 #endif
 409
 410     case LFT_ADAPTED_REQUEST_HEADER:
 411
 412     case LFT_REQUEST_HEADER:
 413
 414     case LFT_REPLY_HEADER:
 415
 416     case LFT_NOTE:
 417
 418         if (data.string) {
 419             char *header = data.string;
 420             char *cp = strchr(header, ':');
 421
 422             if (cp) {
 423                 *cp = '\0';
 424                 ++cp;
 425
 426                 if (*cp == ',' || *cp == ';' || *cp == ':') {
 427                     data.header.separator = *cp;
 428                     ++cp;
 429                 } else {
 430                     data.header.separator = ',';
 431                 }
 432
 433                 data.header.element = cp;
 434
 435                 switch (type) {
 436                 case LFT_REQUEST_HEADER:
 437                     type = LFT_REQUEST_HEADER_ELEM;
 438                     break;
 439
 440                 case LFT_ADAPTED_REQUEST_HEADER:
 441                     type = LFT_ADAPTED_REQUEST_HEADER_ELEM;
 442                     break;
 443
 444                 case LFT_REPLY_HEADER:
 445                     type = LFT_REPLY_HEADER_ELEM;
 446                     break;
 447 #if USE_ADAPTATION
 448                 case LFT_ADAPTATION_LAST_HEADER:
 449                     type = LFT_ADAPTATION_LAST_HEADER_ELEM;
 450                     break;
 451 #endif
 452 #if ICAP_CLIENT
 453                 case LFT_ICAP_REQ_HEADER:
 454                     type = LFT_ICAP_REQ_HEADER_ELEM;
 455                     break;
 456                 case LFT_ICAP_REP_HEADER:
 457                     type = LFT_ICAP_REP_HEADER_ELEM;
 458                     break;
 459 #endif
 460                 default:
 461                     break;
 462                 }
 463             }
 464
 465             data.header.header = header;
 466         } else {
 467             switch (type) {
 468             case LFT_REQUEST_HEADER:
 469                 type = LFT_REQUEST_ALL_HEADERS;
 470                 break;
 471
 472             case LFT_ADAPTED_REQUEST_HEADER:
 473                 type = LFT_ADAPTED_REQUEST_ALL_HEADERS;
 474                 break;
 475
 476             case LFT_REPLY_HEADER:
 477                 type = LFT_REPLY_ALL_HEADERS;
 478                 break;
 479 #if USE_ADAPTATION
 480             case LFT_ADAPTATION_LAST_HEADER:
 481                 type = LFT_ADAPTATION_LAST_ALL_HEADERS;
 482                 break;
 483 #endif
 484 #if ICAP_CLIENT
 485             case LFT_ICAP_REQ_HEADER:
 486                 type = LFT_ICAP_REQ_ALL_HEADERS;
 487                 break;
 488             case LFT_ICAP_REP_HEADER:
 489                 type = LFT_ICAP_REP_ALL_HEADERS;
 490                 break;
 491 #endif
 492             default:
 493                 break;
 494             }
 495             Config.onoff.log_mime_hdrs = 1;
 496         }
 497
 498         break;
 499
 500     case LFT_CLIENT_FQDN:
 501         Config.onoff.log_fqdn = 1;
 502         break;
 503
 504     case LFT_TIME_START:
 505     case LFT_TIME_SUBSECOND:
 506         divisor = 1000;
 507
 508         if (widthMax > 0) {
 509             divisor = 1000000;
 510
 511             for (int i = widthMax; i > 0; --i)
 512                 divisor /= 10;
 513
 514             if (!divisor)
 515                 divisor = 1;
 516         }
 517         break;
 518
 519     case LFT_HTTP_SENT_STATUS_CODE_OLD_30:
 520         debugs(46, DBG_PARSE_NOTE(DBG_IMPORTANT), "WARNING: The \"Hs\" formatting code is deprecated. Use the \">Hs\" instead.");
 521         type = LFT_HTTP_SENT_STATUS_CODE;
 522         break;
 523
 524     case LFT_SERVER_LOCAL_IP_OLD_27:
 525         debugs(46, DBG_PARSE_NOTE(DBG_IMPORTANT), "WARNING: The \"oa\" formatting code is deprecated. Use the \"<la\" instead.");
 526         type = LFT_SERVER_LOCAL_IP;
 527         break;
 528
 529     case LFT_REQUEST_URLPATH_OLD_31:
 530         debugs(46, DBG_PARSE_NOTE(DBG_IMPORTANT), "WARNING: The \"rp\" formatting code is deprecated. Use the \">rp\" instead.");
 531         type = LFT_CLIENT_REQ_URLPATH;
 532         break;
 533
 534     case LFT_REQUEST_VERSION_OLD_2X:
 535         debugs(46, DBG_PARSE_NOTE(DBG_IMPORTANT), "WARNING: The \">v\" formatting code is deprecated. Use the \">rv\" instead.");
 536         type = LFT_REQUEST_VERSION;
 537         break;
 538
 539 #if !USE_SQUID_EUI
 540     case LFT_CLIENT_EUI:
 541         debugs(46, DBG_CRITICAL, "WARNING: The \">eui\" formatting code requires EUI features which are disabled in this Squid.");
 542         break;
 543 #endif
 544
 545     case LFT_REQUEST_URLGROUP_OLD_2X:
 546         debugs(46, DBG_PARSE_NOTE(DBG_IMPORTANT), "WARNING: The \"rG\" formatting code is deprecated. Use \"note{urlgroup}\" instead.");
 547         type = LFT_NOTE;
 548         data.header.header = xstrdup("urlgroup");
 549         break;
 550
 551     default:
 552         break;
 553     }
 554
 555     return (cur - def);
 556 }
 557
 558 Format::Token::Token() : type(LFT_NONE),
 559         label(NULL),
 560         widthMin(-1),
 561         widthMax(-1),
 562         quote(LOG_QUOTE_NONE),
 563         left(false),
 564         space(false),
 565         zero(false),
 566         divisor(1),
 567         next(NULL)
 568 {
 569     data.string = NULL;
 570     data.header.header = NULL;
 571     data.header.element = NULL;
 572     data.header.separator = ',';
 573 }
 574
 575 Format::Token::~Token()
 576 {
 577     label = NULL; // drop reference to global static.
 578     safe_free(data.string);
 579     while (next) {
 580         Token *tokens = next;
 581         next = next->next;
 582         tokens->next = NULL;
 583         delete tokens;
 584     }
 585 }
 586