1 #include "first.h" 2 3 #include "base.h" 4 #include "fdevent.h" 5 #include "log.h" 6 #include "buffer.h" 7 #include "http_header.h" 8 #include "sock_addr.h" 9 10 #include "plugin.h" 11 12 #include <sys/types.h> 13 #include <sys/stat.h> 14 15 #include <stdlib.h> 16 #include <string.h> 17 #include <fcntl.h> 18 #include <unistd.h> 19 #include <time.h> 20 21 #ifdef HAVE_SYSLOG_H 22 # include <syslog.h> 23 #endif 24 25 typedef struct { 26 char key; 27 enum { 28 FORMAT_UNSET, 29 FORMAT_UNSUPPORTED, 30 FORMAT_PERCENT, 31 FORMAT_REMOTE_HOST, 32 FORMAT_REMOTE_IDENT, 33 FORMAT_REMOTE_USER, 34 FORMAT_TIMESTAMP, 35 FORMAT_REQUEST_LINE, 36 FORMAT_STATUS, 37 FORMAT_BYTES_OUT_NO_HEADER, 38 FORMAT_HEADER, 39 40 FORMAT_REMOTE_ADDR, 41 FORMAT_LOCAL_ADDR, 42 FORMAT_COOKIE, 43 FORMAT_TIME_USED_US, 44 FORMAT_ENV, 45 FORMAT_FILENAME, 46 FORMAT_REQUEST_PROTOCOL, 47 FORMAT_REQUEST_METHOD, 48 FORMAT_SERVER_PORT, 49 FORMAT_QUERY_STRING, 50 FORMAT_TIME_USED, 51 FORMAT_URL, 52 FORMAT_SERVER_NAME, 53 FORMAT_HTTP_HOST, 54 FORMAT_CONNECTION_STATUS, 55 FORMAT_BYTES_IN, 56 FORMAT_BYTES_OUT, 57 58 FORMAT_KEEPALIVE_COUNT, 59 FORMAT_RESPONSE_HEADER, 60 FORMAT_NOTE 61 } type; 62 } format_mapping; 63 64 /** 65 * 66 * 67 * "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" 68 * 69 */ 70 71 static const format_mapping fmap[] = 72 { 73 { '%', FORMAT_PERCENT }, 74 { 'h', FORMAT_REMOTE_HOST }, 75 { 'l', FORMAT_REMOTE_IDENT }, 76 { 'u', FORMAT_REMOTE_USER }, 77 { 't', FORMAT_TIMESTAMP }, 78 { 'r', FORMAT_REQUEST_LINE }, 79 { 's', FORMAT_STATUS }, 80 { 'b', FORMAT_BYTES_OUT_NO_HEADER }, 81 { 'i', FORMAT_HEADER }, 82 83 { 'a', FORMAT_REMOTE_ADDR }, 84 { 'A', FORMAT_LOCAL_ADDR }, 85 { 'B', FORMAT_BYTES_OUT_NO_HEADER }, 86 { 'C', FORMAT_COOKIE }, 87 { 'D', FORMAT_TIME_USED_US }, 88 { 'e', FORMAT_ENV }, 89 { 'f', FORMAT_FILENAME }, 90 { 'H', FORMAT_REQUEST_PROTOCOL }, 91 { 'k', FORMAT_KEEPALIVE_COUNT }, 92 { 'm', FORMAT_REQUEST_METHOD }, 93 { 'n', FORMAT_NOTE }, 94 { 'p', FORMAT_SERVER_PORT }, 95 { 'P', FORMAT_UNSUPPORTED }, /* we are only one process */ 96 { 'q', FORMAT_QUERY_STRING }, 97 { 'T', FORMAT_TIME_USED }, 98 { 'U', FORMAT_URL }, /* w/o querystring */ 99 { 'v', FORMAT_SERVER_NAME }, 100 { 'V', FORMAT_HTTP_HOST }, 101 { 'X', FORMAT_CONNECTION_STATUS }, 102 { 'I', FORMAT_BYTES_IN }, 103 { 'O', FORMAT_BYTES_OUT }, 104 105 { 'o', FORMAT_RESPONSE_HEADER }, 106 107 { '\0', FORMAT_UNSET } 108 }; 109 110 111 enum e_optflags_time { 112 /* format string is passed to strftime unless other format optflags set 113 * (besides FORMAT_FLAG_TIME_BEGIN or FORMAT_FLAG_TIME_END) */ 114 FORMAT_FLAG_TIME_END = 0x00,/* use request end time (default) */ 115 FORMAT_FLAG_TIME_BEGIN = 0x01,/* use request start time */ 116 FORMAT_FLAG_TIME_SEC = 0x02,/* request time as num sec since epoch */ 117 FORMAT_FLAG_TIME_MSEC = 0x04,/* request time as num msec since epoch */ 118 FORMAT_FLAG_TIME_USEC = 0x08,/* request time as num usec since epoch */ 119 FORMAT_FLAG_TIME_NSEC = 0x10,/* request time as num nsec since epoch */ 120 FORMAT_FLAG_TIME_MSEC_FRAC = 0x20,/* request time msec fraction */ 121 FORMAT_FLAG_TIME_USEC_FRAC = 0x40,/* request time usec fraction */ 122 FORMAT_FLAG_TIME_NSEC_FRAC = 0x80 /* request time nsec fraction */ 123 }; 124 125 enum e_optflags_port { 126 FORMAT_FLAG_PORT_LOCAL = 0x01,/* (default) */ 127 FORMAT_FLAG_PORT_REMOTE = 0x02 128 }; 129 130 131 typedef struct { 132 enum { FIELD_UNSET, FIELD_STRING, FIELD_FORMAT } type; 133 int field; 134 int opt; 135 buffer string; 136 } format_field; 137 138 typedef struct { 139 time_t last_generated_accesslog_ts; 140 buffer ts_accesslog_str; 141 #if defined(__STDC_VERSION__) && __STDC_VERSION__-0 >= 199901L /* C99 */ 142 format_field ptr[]; /* C99 VLA */ 143 #else 144 format_field ptr[1]; 145 #endif 146 } format_fields; 147 148 typedef struct { 149 int log_access_fd; 150 char use_syslog; /* syslog has global buffer */ 151 char piped_logger; 152 unsigned short syslog_level; 153 buffer *access_logbuffer; /* each logfile has a separate buffer */ 154 const buffer *access_logfile; 155 156 format_fields *parsed_format; 157 } plugin_config; 158 159 typedef struct { 160 int log_access_fd; 161 char piped_logger; 162 const buffer *access_logfile; 163 buffer access_logbuffer; /* each logfile has a separate buffer */ 164 } accesslog_st; 165 166 typedef struct { 167 PLUGIN_DATA; 168 plugin_config defaults; 169 plugin_config conf; 170 171 buffer syslog_logbuffer; /* syslog has global buffer. no caching, always written directly */ 172 log_error_st *errh; /* copy of srv->errh */ 173 format_fields *default_format;/* allocated if default format */ 174 } plugin_data; 175 176 INIT_FUNC(mod_accesslog_init) { 177 return calloc(1, sizeof(plugin_data)); 178 } 179 180 static int accesslog_write_all(const int fd, buffer * const b) { 181 const ssize_t wr = (fd >= 0) ? write_all(fd, CONST_BUF_LEN(b)) : 0; 182 buffer_clear(b); /*(clear buffer, even if fd < 0)*/ 183 return (-1 != wr); 184 } 185 186 static void accesslog_append_escaped_str(buffer * const dest, const char * const str, const size_t len) { 187 const char *ptr, *start, *end; 188 189 /* replaces non-printable chars with \xHH where HH is the hex representation of the byte */ 190 /* exceptions: " => \", \ => \\, whitespace chars => \n \t etc. */ 191 if (0 == len) return; 192 buffer_string_prepare_append(dest, len); 193 194 for (ptr = start = str, end = str+len; ptr < end; ++ptr) { 195 unsigned char const c = *(const unsigned char *)ptr; 196 if (c >= ' ' && c <= '~' && c != '"' && c != '\\') { 197 /* nothing to change, add later as one block */ 198 } else { 199 /* copy previous part */ 200 if (start < ptr) { 201 buffer_append_string_len(dest, start, ptr - start); 202 } 203 start = ptr + 1; 204 205 switch (c) { 206 case '"': 207 BUFFER_APPEND_STRING_CONST(dest, "\\\""); 208 break; 209 case '\\': 210 BUFFER_APPEND_STRING_CONST(dest, "\\\\"); 211 break; 212 case '\b': 213 BUFFER_APPEND_STRING_CONST(dest, "\\b"); 214 break; 215 case '\n': 216 BUFFER_APPEND_STRING_CONST(dest, "\\n"); 217 break; 218 case '\r': 219 BUFFER_APPEND_STRING_CONST(dest, "\\r"); 220 break; 221 case '\t': 222 BUFFER_APPEND_STRING_CONST(dest, "\\t"); 223 break; 224 case '\v': 225 BUFFER_APPEND_STRING_CONST(dest, "\\v"); 226 break; 227 default: { 228 /* non printable char => \xHH */ 229 char hh[5] = {'\\','x',0,0,0}; 230 char h = c / 16; 231 hh[2] = (h > 9) ? (h - 10 + 'A') : (h + '0'); 232 h = c % 16; 233 hh[3] = (h > 9) ? (h - 10 + 'A') : (h + '0'); 234 buffer_append_string_len(dest, &hh[0], 4); 235 } 236 break; 237 } 238 } 239 } 240 241 if (start < end) { 242 buffer_append_string_len(dest, start, end - start); 243 } 244 } 245 246 static void accesslog_append_escaped(buffer *dest, const buffer *str) { 247 accesslog_append_escaped_str(dest, CONST_BUF_LEN(str)); 248 } 249 250 __attribute_cold__ 251 static format_fields * accesslog_parse_format_err(log_error_st *errh, const char *file, unsigned int line, format_field *f, const char *msg) { 252 log_error(errh, file, line, "%s", msg); 253 for (; f->type != FIELD_UNSET; ++f) free(f->string.ptr); 254 return NULL; 255 } 256 257 static format_fields * accesslog_parse_format(const char * const format, const size_t flen, log_error_st * const errh) { 258 /* common log format (the default) results in 18 elements, 259 * so 127 should be enough except for obscene custom usage */ 260 size_t i, j, k = 0, start = 0; 261 uint32_t used = 0; 262 const uint32_t sz = 127;/* (sz+1 must match fptr[] num elts below) */ 263 format_field *f; 264 format_field fptr[128]; /* (128 elements takes 4k on stack in 64-bit) */ 265 memset(fptr, 0, sizeof(fptr)); 266 if (0 != FIELD_UNSET) return NULL; 267 268 if (0 == flen) return NULL; 269 270 for (i = 0; i < flen; ++i) { 271 if (format[i] != '%') continue; 272 273 if (i > 0 && start != i) { 274 /* copy the string before this % */ 275 if (used == sz) 276 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 277 "too many fields (>= 127) in accesslog.format"); 278 279 f = fptr+used; 280 f->type = FIELD_STRING; 281 memset(&f->string, 0, sizeof(buffer)); 282 buffer_copy_string_len(&f->string, format + start, i - start); 283 284 ++used; 285 } 286 287 /* we need a new field */ 288 if (used == sz) 289 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 290 "too many fields (>= 127) in accesslog.format"); 291 292 /* search for the terminating command */ 293 switch (format[i+1]) { 294 case '>': 295 case '<': 296 /* after the } has to be a character */ 297 if (format[i+2] == '\0') { 298 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 299 "%< and %> have to be followed by a format-specifier"); 300 } 301 302 303 for (j = 0; fmap[j].key != '\0'; j++) { 304 if (fmap[j].key != format[i+2]) continue; 305 306 /* found key */ 307 308 f = fptr+used; 309 f->type = FIELD_FORMAT; 310 f->field = fmap[j].type; 311 f->opt = 0; 312 f->string.ptr = NULL; 313 314 ++used; 315 316 break; 317 } 318 319 if (fmap[j].key == '\0') { 320 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 321 "%< and %> have to be followed by a valid format-specifier"); 322 } 323 324 start = i + 3; 325 i = start - 1; /* skip the string */ 326 327 break; 328 case '{': 329 /* go forward to } */ 330 331 for (k = i+2; k < flen; ++k) { 332 if (format[k] == '}') break; 333 } 334 335 if (k == flen) { 336 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 337 "%{ has to be terminated by a }"); 338 } 339 340 /* after the } has to be a character */ 341 if (format[k+1] == '\0') { 342 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 343 "%{...} has to be followed by a format-specifier"); 344 } 345 346 if (k == i + 2) { 347 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 348 "%{...} has to contain a string"); 349 } 350 351 for (j = 0; fmap[j].key != '\0'; j++) { 352 if (fmap[j].key != format[k+1]) continue; 353 354 /* found key */ 355 356 f = fptr+used; 357 f->type = FIELD_FORMAT; 358 f->field = fmap[j].type; 359 f->opt = 0; 360 memset(&f->string, 0, sizeof(buffer)); 361 buffer_copy_string_len(&f->string, format + i + 2, k - (i + 2)); 362 363 ++used; 364 365 break; 366 } 367 368 if (fmap[j].key == '\0') { 369 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 370 "%{...} has to be followed by a valid format-specifier"); 371 } 372 373 start = k + 2; 374 i = start - 1; /* skip the string */ 375 376 break; 377 default: 378 /* after the % has to be a character */ 379 if (format[i+1] == '\0') { 380 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 381 "% has to be followed by a format-specifier"); 382 } 383 384 for (j = 0; fmap[j].key != '\0'; j++) { 385 if (fmap[j].key != format[i+1]) continue; 386 387 /* found key */ 388 389 f = fptr+used; 390 f->type = FIELD_FORMAT; 391 f->field = fmap[j].type; 392 f->string.ptr = NULL; 393 f->opt = 0; 394 395 ++used; 396 397 break; 398 } 399 400 if (fmap[j].key == '\0') { 401 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 402 "% has to be followed by a valid format-specifier"); 403 } 404 405 start = i + 2; 406 i = start - 1; /* skip the string */ 407 408 break; 409 } 410 } 411 412 if (start < i) { 413 /* copy the string */ 414 if (used == sz) 415 return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr, 416 "too many fields (>= 127) in accesslog.format"); 417 418 f = fptr+used; 419 f->type = FIELD_STRING; 420 memset(&f->string, 0, sizeof(buffer)); 421 buffer_copy_string_len(&f->string, format + start, i - start); 422 423 ++used; 424 } 425 426 format_fields * const fields = 427 malloc(sizeof(format_fields) + ((used+1) * sizeof(format_field))); 428 force_assert(fields); 429 memset(fields, 0, sizeof(format_fields)); 430 memcpy(fields->ptr, fptr, (used+1) * sizeof(format_field)); 431 return fields; 432 } 433 434 static void mod_accesslog_free_accesslog(accesslog_st * const x, plugin_data *p) { 435 /*(piped loggers are closed in fdevent_close_logger_pipes())*/ 436 if (!x->piped_logger && -1 != x->log_access_fd) { 437 if (!accesslog_write_all(x->log_access_fd, &x->access_logbuffer)) { 438 log_perror(p->errh, __FILE__, __LINE__, 439 "writing access log entry failed: %s", x->access_logfile->ptr); 440 } 441 close(x->log_access_fd); 442 } 443 free(x->access_logbuffer.ptr); 444 } 445 446 static void mod_accesslog_free_format_fields(format_fields * const ff) { 447 for (format_field *f = ff->ptr; f->type != FIELD_UNSET; ++f) 448 free(f->string.ptr); 449 free(ff->ts_accesslog_str.ptr); 450 free(ff); 451 } 452 453 FREE_FUNC(mod_accesslog_free) { 454 plugin_data * const p = p_d; 455 free(p->syslog_logbuffer.ptr); 456 if (NULL == p->cvlist) return; 457 /* (init i to 0 if global context; to 1 to skip empty global context) */ 458 for (int i = !p->cvlist[0].v.u2[1], used = p->nconfig; i < used; ++i) { 459 config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0]; 460 for (; -1 != cpv->k_id; ++cpv) { 461 if (cpv->vtype != T_CONFIG_LOCAL || NULL == cpv->v.v) continue; 462 switch (cpv->k_id) { 463 case 0: /* accesslog.filename */ 464 mod_accesslog_free_accesslog(cpv->v.v, p); 465 break; 466 case 1: /* accesslog.format */ 467 mod_accesslog_free_format_fields(cpv->v.v); 468 break; 469 default: 470 break; 471 } 472 } 473 } 474 475 if (NULL != p->default_format) { 476 mod_accesslog_free_format_fields(p->default_format); 477 } 478 } 479 480 static void mod_accesslog_merge_config_cpv(plugin_config * const pconf, const config_plugin_value_t * const cpv) { 481 switch (cpv->k_id) { /* index into static config_plugin_keys_t cpk[] */ 482 case 0:{/* accesslog.filename */ 483 if (cpv->vtype != T_CONFIG_LOCAL) break; 484 accesslog_st * const x = cpv->v.v; 485 pconf->log_access_fd = x->log_access_fd; 486 pconf->piped_logger = x->piped_logger; 487 pconf->access_logfile = x->access_logfile; 488 pconf->access_logbuffer = &x->access_logbuffer; 489 break; 490 } 491 case 1:{/* accesslog.format */ 492 if (cpv->vtype != T_CONFIG_LOCAL) break; 493 pconf->parsed_format = cpv->v.v; 494 break; 495 } 496 case 2: /* accesslog.use-syslog */ 497 pconf->use_syslog = (int)cpv->v.u; 498 break; 499 case 3: /* accesslog.syslog-level */ 500 pconf->syslog_level = cpv->v.shrt; 501 break; 502 default:/* should not happen */ 503 return; 504 } 505 } 506 507 static void mod_accesslog_merge_config(plugin_config * const pconf, const config_plugin_value_t *cpv) { 508 do { 509 mod_accesslog_merge_config_cpv(pconf, cpv); 510 } while ((++cpv)->k_id != -1); 511 } 512 513 static void mod_accesslog_patch_config(request_st * const r, plugin_data * const p) { 514 memcpy(&p->conf, &p->defaults, sizeof(plugin_config)); 515 for (int i = 1, used = p->nconfig; i < used; ++i) { 516 if (config_check_cond(r, (uint32_t)p->cvlist[i].k_id)) 517 mod_accesslog_merge_config(&p->conf, p->cvlist + p->cvlist[i].v.u2[0]); 518 } 519 } 520 521 static format_fields * mod_accesslog_process_format(const char * const format, const size_t flen, server * const srv); 522 523 SETDEFAULTS_FUNC(mod_accesslog_set_defaults) { 524 static const config_plugin_keys_t cpk[] = { 525 { CONST_STR_LEN("accesslog.filename"), 526 T_CONFIG_STRING, 527 T_CONFIG_SCOPE_CONNECTION } 528 ,{ CONST_STR_LEN("accesslog.format"), 529 T_CONFIG_STRING, 530 T_CONFIG_SCOPE_CONNECTION } 531 ,{ CONST_STR_LEN("accesslog.use-syslog"), 532 T_CONFIG_BOOL, 533 T_CONFIG_SCOPE_CONNECTION } 534 ,{ CONST_STR_LEN("accesslog.syslog-level"), 535 T_CONFIG_SHORT, 536 T_CONFIG_SCOPE_CONNECTION } 537 ,{ NULL, 0, 538 T_CONFIG_UNSET, 539 T_CONFIG_SCOPE_UNSET } 540 }; 541 542 plugin_data * const p = p_d; 543 p->errh = srv->errh; 544 if (!config_plugin_values_init(srv, p, cpk, "mod_accesslog")) 545 return HANDLER_ERROR; 546 547 /* process and validate config directives 548 * (init i to 0 if global context; to 1 to skip empty global context) */ 549 for (int i = !p->cvlist[0].v.u2[1]; i < p->nconfig; ++i) { 550 config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0]; 551 int use_syslog = 0; 552 accesslog_st *x = NULL; 553 for (; -1 != cpv->k_id; ++cpv) { 554 switch (cpv->k_id) { 555 case 0: /* accesslog.filename */ 556 x = calloc(1, sizeof(accesslog_st)); 557 force_assert(x); 558 x->log_access_fd = -1; 559 x->piped_logger = (cpv->v.b->ptr[0] == '|'); 560 x->access_logfile = cpv->v.b; 561 cpv->vtype = T_CONFIG_LOCAL; 562 cpv->v.v = x; 563 break; 564 case 1: /* accesslog.format */ 565 if (NULL != strchr(cpv->v.b->ptr, '\\')) { 566 /* process basic backslash-escapes in format string */ 567 buffer *b; 568 *(const buffer **)&b = cpv->v.b; 569 char *t = b->ptr; 570 for (char *s = t; *s; ++s) { 571 if (s[0] != '\\') { *t++ = *s; continue; } 572 if (s[1] == '\0') continue; /*(ignore dangling '\\')*/ 573 switch (*++s) { 574 case 'a': *t++ = '\a'; break; /* bell */ 575 case 'b': *t++ = '\b'; break; /* backspace */ 576 case 'f': *t++ = '\f'; break; /* form feed */ 577 case 'n': *t++ = '\n'; break; /* newline */ 578 case 'r': *t++ = '\r'; break; /* carriage return */ 579 case 't': *t++ = '\t'; break; /* horizontal tab */ 580 case 'v': *t++ = '\v'; break; /* vertical tab */ 581 /*case '"':*/ 582 /*case '\\':*/ 583 default: *t++ = *s; break; /*(use literal char)*/ 584 } 585 } 586 buffer_string_set_length(b, (size_t)(t - b->ptr)); 587 } 588 cpv->v.v = 589 mod_accesslog_process_format(CONST_BUF_LEN(cpv->v.b), srv); 590 if (NULL == cpv->v.v) return HANDLER_ERROR; 591 cpv->vtype = T_CONFIG_LOCAL; 592 break; 593 case 2: /* accesslog.use-syslog */ 594 use_syslog = (int)cpv->v.u; 595 break; 596 case 3: /* accesslog.syslog-level */ 597 break; 598 default:/* should not happen */ 599 break; 600 } 601 } 602 603 if (srv->srvconf.preflight_check) continue; 604 605 if (use_syslog) continue; /* ignore the next checks */ 606 if (NULL == x || buffer_string_is_empty(x->access_logfile)) continue; 607 608 x->log_access_fd = fdevent_open_logger(x->access_logfile->ptr); 609 if (-1 == x->log_access_fd) { 610 log_perror(srv->errh, __FILE__, __LINE__, 611 "opening log '%s' failed", x->access_logfile->ptr); 612 return HANDLER_ERROR; 613 } 614 } 615 616 p->defaults.log_access_fd = -1; 617 p->defaults.syslog_level = LOG_INFO; 618 619 /* initialize p->defaults from global config context */ 620 if (p->nconfig > 0 && p->cvlist->v.u2[1]) { 621 const config_plugin_value_t *cpv = p->cvlist + p->cvlist->v.u2[0]; 622 if (-1 != cpv->k_id) 623 mod_accesslog_merge_config(&p->defaults, cpv); 624 } 625 626 if (NULL == p->defaults.parsed_format) { 627 /* (set default format even if p->use_syslog since 628 * some other condition might enable logfile) */ 629 static const char fmt[] = 630 "%h %V %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\""; 631 p->defaults.parsed_format = p->default_format = 632 mod_accesslog_process_format(CONST_STR_LEN(fmt), srv); 633 if (NULL == p->default_format) return HANDLER_ERROR; 634 } 635 636 return HANDLER_GO_ON; 637 } 638 639 static format_fields * mod_accesslog_process_format(const char * const format, const size_t flen, server * const srv) { 640 format_fields * const parsed_format = 641 accesslog_parse_format(format, flen, srv->errh); 642 if (NULL == parsed_format) { 643 log_error(srv->errh, __FILE__, __LINE__, 644 "parsing accesslog-definition failed: %s", format); 645 return NULL; 646 } 647 648 uint32_t tcount = 0; 649 for (format_field *f = parsed_format->ptr; f->type != FIELD_UNSET; ++f) { 650 const buffer * const fstr = &f->string; 651 if (FIELD_FORMAT != f->type) continue; 652 if (FORMAT_TIMESTAMP == f->field) { 653 if (!buffer_string_is_empty(fstr)) { 654 const char *ptr = fstr->ptr; 655 if (0 == strncmp(ptr, "begin:", sizeof("begin:")-1)) { 656 f->opt |= FORMAT_FLAG_TIME_BEGIN; 657 ptr += sizeof("begin:")-1; 658 } else if (0 == strncmp(ptr, "end:", sizeof("end:")-1)) { 659 f->opt |= FORMAT_FLAG_TIME_END; 660 ptr += sizeof("end:")-1; 661 } 662 if (0 == strcmp(ptr, "sec")) f->opt |= FORMAT_FLAG_TIME_SEC; 663 else if (0 == strcmp(ptr, "msec")) f->opt |= FORMAT_FLAG_TIME_MSEC; 664 else if (0 == strcmp(ptr, "usec")) f->opt |= FORMAT_FLAG_TIME_USEC; 665 else if (0 == strcmp(ptr, "nsec")) f->opt |= FORMAT_FLAG_TIME_NSEC; 666 else if (0 == strcmp(ptr, "msec_frac")) f->opt |= FORMAT_FLAG_TIME_MSEC_FRAC; 667 else if (0 == strcmp(ptr, "usec_frac")) f->opt |= FORMAT_FLAG_TIME_USEC_FRAC; 668 else if (0 == strcmp(ptr, "nsec_frac")) f->opt |= FORMAT_FLAG_TIME_NSEC_FRAC; 669 else if (NULL == strchr(ptr, '%')) { 670 log_error(srv->errh, __FILE__, __LINE__, 671 "constant string for time format (misspelled token? or missing '%%'): %s", format); 672 mod_accesslog_free_format_fields(parsed_format); 673 return NULL; 674 } 675 } 676 677 /* make sure they didn't try to send the timestamp in twice 678 * (would invalidate pconf->parsed_format.ts_accesslog_str cache of timestamp str) */ 679 if (!(f->opt & ~(FORMAT_FLAG_TIME_BEGIN|FORMAT_FLAG_TIME_END|FORMAT_FLAG_TIME_SEC)) && ++tcount > 1) { 680 log_error(srv->errh, __FILE__, __LINE__, 681 "you may not use strftime timestamp format %%{}t twice in the same access log: %s", format); 682 mod_accesslog_free_format_fields(parsed_format); 683 return NULL; 684 } 685 686 if (f->opt & FORMAT_FLAG_TIME_BEGIN) srv->srvconf.high_precision_timestamps = 1; 687 } else if (FORMAT_TIME_USED_US == f->field) { 688 f->opt |= FORMAT_FLAG_TIME_USEC; 689 srv->srvconf.high_precision_timestamps = 1; 690 } else if (FORMAT_TIME_USED == f->field) { 691 if (buffer_string_is_empty(fstr) 692 || buffer_is_equal_string(fstr, CONST_STR_LEN("s")) 693 || buffer_is_equal_string(fstr, CONST_STR_LEN("sec"))) f->opt |= FORMAT_FLAG_TIME_SEC; 694 else if (buffer_is_equal_string(fstr, CONST_STR_LEN("ms")) 695 || buffer_is_equal_string(fstr, CONST_STR_LEN("msec"))) f->opt |= FORMAT_FLAG_TIME_MSEC; 696 else if (buffer_is_equal_string(fstr, CONST_STR_LEN("us")) 697 || buffer_is_equal_string(fstr, CONST_STR_LEN("usec"))) f->opt |= FORMAT_FLAG_TIME_USEC; 698 else if (buffer_is_equal_string(fstr, CONST_STR_LEN("ns")) 699 || buffer_is_equal_string(fstr, CONST_STR_LEN("nsec"))) f->opt |= FORMAT_FLAG_TIME_NSEC; 700 else { 701 log_error(srv->errh, __FILE__, __LINE__, 702 "invalid time unit in %%{UNIT}T: %s", format); 703 mod_accesslog_free_format_fields(parsed_format); 704 return NULL; 705 } 706 707 if (f->opt & ~(FORMAT_FLAG_TIME_SEC)) srv->srvconf.high_precision_timestamps = 1; 708 } else if (FORMAT_COOKIE == f->field) { 709 if (buffer_string_is_empty(fstr)) f->type = FIELD_STRING; /*(blank)*/ 710 } else if (FORMAT_SERVER_PORT == f->field) { 711 if (buffer_string_is_empty(fstr)) 712 f->opt |= FORMAT_FLAG_PORT_LOCAL; 713 else if (buffer_is_equal_string(fstr, CONST_STR_LEN("canonical"))) 714 f->opt |= FORMAT_FLAG_PORT_LOCAL; 715 else if (buffer_is_equal_string(fstr, CONST_STR_LEN("local"))) 716 f->opt |= FORMAT_FLAG_PORT_LOCAL; 717 else if (buffer_is_equal_string(fstr, CONST_STR_LEN("remote"))) 718 f->opt |= FORMAT_FLAG_PORT_REMOTE; 719 else { 720 log_error(srv->errh, __FILE__, __LINE__, 721 "invalid format %%{canonical,local,remote}p: %s", format); 722 mod_accesslog_free_format_fields(parsed_format); 723 return NULL; 724 } 725 } else if (FORMAT_HEADER == f->field 726 || FORMAT_RESPONSE_HEADER == f->field) { 727 f->opt = http_header_hkey_get(CONST_BUF_LEN(fstr)); 728 } 729 } 730 731 return parsed_format; 732 } 733 734 static void log_access_flush(plugin_data * const p) { 735 /* future: might be slightly faster to have allocated array of open files 736 * rather than walking config, but only might matter with many directives */ 737 /* (init i to 0 if global context; to 1 to skip empty global context) */ 738 for (int i = !p->cvlist[0].v.u2[1]; i < p->nconfig; ++i) { 739 config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0]; 740 for (; -1 != cpv->k_id; ++cpv) { 741 switch (cpv->k_id) { 742 case 0: /* accesslog.filename */ 743 if (cpv->vtype == T_CONFIG_LOCAL && NULL != cpv->v.v) { 744 accesslog_st * const x = cpv->v.v; 745 if (buffer_string_is_empty(&x->access_logbuffer)) continue; 746 if (!accesslog_write_all(x->log_access_fd, 747 &x->access_logbuffer)) { 748 log_perror(p->errh, __FILE__, __LINE__, 749 "writing access log entry failed: %s", 750 x->access_logfile->ptr); 751 } 752 } 753 break; 754 default: 755 break; 756 } 757 } 758 } 759 } 760 761 TRIGGER_FUNC(log_access_periodic_flush) { 762 /* flush buffered access logs every 4 seconds */ 763 if (0 == (log_epoch_secs & 3)) log_access_flush((plugin_data *)p_d); 764 UNUSED(srv); 765 return HANDLER_GO_ON; 766 } 767 768 SIGHUP_FUNC(log_access_cycle) { 769 plugin_data * const p = p_d; 770 771 log_access_flush(p); 772 773 /* future: might be slightly faster to have allocated array of open files 774 * rather than walking config, but only might matter with many directives */ 775 /* (init i to 0 if global context; to 1 to skip empty global context) */ 776 for (int i = !p->cvlist[0].v.u2[1]; i < p->nconfig; ++i) { 777 config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0]; 778 for (; -1 != cpv->k_id; ++cpv) { 779 if (cpv->vtype != T_CONFIG_LOCAL || NULL == cpv->v.v) continue; 780 switch (cpv->k_id) { 781 case 0:{/* accesslog.filename */ 782 accesslog_st * const x = cpv->v.v; 783 if (x->piped_logger) continue; 784 if (buffer_string_is_empty(x->access_logfile)) continue; 785 if (-1 == fdevent_cycle_logger(x->access_logfile->ptr, 786 &x->log_access_fd)) { 787 log_perror(srv->errh, __FILE__, __LINE__, 788 "cycling access log failed: %s", x->access_logfile->ptr); 789 } 790 break; 791 } 792 default: 793 break; 794 } 795 } 796 } 797 798 return HANDLER_GO_ON; 799 } 800 801 static int log_access_record (const request_st * const r, buffer * const b, format_fields * const parsed_format) { 802 const connection * const con = r->con; 803 const buffer *vb; 804 struct timespec ts = { 0, 0 }; 805 int flush = 0; 806 807 for (const format_field *f = parsed_format->ptr; f->type != FIELD_UNSET; ++f) { 808 switch(f->type) { 809 case FIELD_STRING: 810 buffer_append_string_buffer(b, &f->string); 811 break; 812 case FIELD_FORMAT: 813 switch(f->field) { 814 case FORMAT_TIMESTAMP: 815 816 if (f->opt & ~(FORMAT_FLAG_TIME_BEGIN|FORMAT_FLAG_TIME_END)) { 817 if (f->opt & FORMAT_FLAG_TIME_SEC) { 818 time_t t = (!(f->opt & FORMAT_FLAG_TIME_BEGIN)) ? log_epoch_secs : r->start_hp.tv_sec; 819 buffer_append_int(b, (intmax_t)t); 820 } else if (f->opt & (FORMAT_FLAG_TIME_MSEC|FORMAT_FLAG_TIME_USEC|FORMAT_FLAG_TIME_NSEC)) { 821 off_t t; /*(expected to be 64-bit since large file support enabled)*/ 822 long ns; 823 if (!(f->opt & FORMAT_FLAG_TIME_BEGIN)) { 824 if (0 == ts.tv_sec) log_clock_gettime_realtime(&ts); 825 t = (off_t)ts.tv_sec; 826 ns = ts.tv_nsec; 827 } else { 828 t = (off_t)r->start_hp.tv_sec; 829 ns = r->start_hp.tv_nsec; 830 } 831 if (f->opt & FORMAT_FLAG_TIME_MSEC) { 832 t *= 1000; 833 t += (ns + 999999) / 1000000; /* ceil */ 834 } else if (f->opt & FORMAT_FLAG_TIME_USEC) { 835 t *= 1000000; 836 t += (ns + 999) / 1000; /* ceil */ 837 } else {/*(f->opt & FORMAT_FLAG_TIME_NSEC)*/ 838 t *= 1000000000; 839 t += ns; 840 } 841 buffer_append_int(b, (intmax_t)t); 842 } else { /*(FORMAT_FLAG_TIME_MSEC_FRAC|FORMAT_FLAG_TIME_USEC_FRAC|FORMAT_FLAG_TIME_NSEC_FRAC)*/ 843 long ns; 844 char *ptr; 845 if (!(f->opt & FORMAT_FLAG_TIME_BEGIN)) { 846 if (0 == ts.tv_sec) log_clock_gettime_realtime(&ts); 847 ns = ts.tv_nsec; 848 } else { 849 ns = r->start_hp.tv_nsec; 850 } 851 /*assert(t < 1000000000);*/ 852 if (f->opt & FORMAT_FLAG_TIME_MSEC_FRAC) { 853 ns += 999999; /* ceil */ 854 ns /= 1000000; 855 buffer_append_string_len(b, CONST_STR_LEN("000")); 856 } else if (f->opt & FORMAT_FLAG_TIME_USEC_FRAC) { 857 ns += 999; /* ceil */ 858 ns /= 1000; 859 buffer_append_string_len(b, CONST_STR_LEN("000000")); 860 } else {/*(f->opt & FORMAT_FLAG_TIME_NSEC_FRAC)*/ 861 buffer_append_string_len(b, CONST_STR_LEN("000000000")); 862 } 863 for (ptr = b->ptr + buffer_string_length(b); ns > 0; ns /= 10) 864 *--ptr = (ns % 10) + '0'; 865 } 866 } else { 867 buffer * const ts_accesslog_str = &parsed_format->ts_accesslog_str; 868 /* cache the generated timestamp (only if ! FORMAT_FLAG_TIME_BEGIN) */ 869 struct tm *tmptr; 870 time_t t; 871 #if defined(HAVE_STRUCT_TM_GMTOFF) 872 # ifdef HAVE_LOCALTIME_R 873 struct tm tm; 874 # endif /* HAVE_LOCALTIME_R */ 875 #else /* HAVE_STRUCT_TM_GMTOFF */ 876 # ifdef HAVE_GMTIME_R 877 struct tm tm; 878 # endif /* HAVE_GMTIME_R */ 879 #endif /* HAVE_STRUCT_TM_GMTOFF */ 880 881 if (!(f->opt & FORMAT_FLAG_TIME_BEGIN)) { 882 const time_t cur_ts = log_epoch_secs; 883 if (parsed_format->last_generated_accesslog_ts == cur_ts) { 884 buffer_append_string_buffer(b, ts_accesslog_str); 885 break; 886 } 887 t = parsed_format->last_generated_accesslog_ts = cur_ts; 888 flush = 1; 889 } else { 890 t = r->start_hp.tv_sec; 891 } 892 893 #if defined(HAVE_STRUCT_TM_GMTOFF) 894 # ifdef HAVE_LOCALTIME_R 895 tmptr = localtime_r(&t, &tm); 896 # else /* HAVE_LOCALTIME_R */ 897 tmptr = localtime(&t); 898 # endif /* HAVE_LOCALTIME_R */ 899 #else /* HAVE_STRUCT_TM_GMTOFF */ 900 # ifdef HAVE_GMTIME_R 901 tmptr = gmtime_r(&t, &tm); 902 # else /* HAVE_GMTIME_R */ 903 tmptr = gmtime(&t); 904 # endif /* HAVE_GMTIME_R */ 905 #endif /* HAVE_STRUCT_TM_GMTOFF */ 906 907 buffer_clear(ts_accesslog_str); 908 909 if (buffer_string_is_empty(&f->string)) { 910 #if defined(HAVE_STRUCT_TM_GMTOFF) 911 long scd, hrs, min; 912 buffer_append_strftime(ts_accesslog_str, "[%d/%b/%Y:%H:%M:%S ", tmptr); 913 buffer_append_string_len(ts_accesslog_str, tmptr->tm_gmtoff >= 0 ? "+" : "-", 1); 914 915 scd = labs(tmptr->tm_gmtoff); 916 hrs = scd / 3600; 917 min = (scd % 3600) / 60; 918 919 /* hours */ 920 if (hrs < 10) buffer_append_string_len(ts_accesslog_str, CONST_STR_LEN("0")); 921 buffer_append_int(ts_accesslog_str, hrs); 922 923 if (min < 10) buffer_append_string_len(ts_accesslog_str, CONST_STR_LEN("0")); 924 buffer_append_int(ts_accesslog_str, min); 925 buffer_append_string_len(ts_accesslog_str, CONST_STR_LEN("]")); 926 #else 927 buffer_append_strftime(ts_accesslog_str, "[%d/%b/%Y:%H:%M:%S +0000]", tmptr); 928 #endif /* HAVE_STRUCT_TM_GMTOFF */ 929 } else { 930 buffer_append_strftime(ts_accesslog_str, f->string.ptr, tmptr); 931 } 932 933 buffer_append_string_buffer(b, ts_accesslog_str); 934 } 935 break; 936 case FORMAT_TIME_USED: 937 case FORMAT_TIME_USED_US: 938 if (f->opt & FORMAT_FLAG_TIME_SEC) { 939 buffer_append_int(b, log_epoch_secs - r->start_hp.tv_sec); 940 } else { 941 const struct timespec * const bs = &r->start_hp; 942 off_t tdiff; /*(expected to be 64-bit since large file support enabled)*/ 943 if (0 == ts.tv_sec) log_clock_gettime_realtime(&ts); 944 tdiff = (off_t)(ts.tv_sec - bs->tv_sec)*1000000000 + (ts.tv_nsec - bs->tv_nsec); 945 if (tdiff <= 0) { 946 /* sanity check for time moving backwards 947 * (daylight savings adjustment or leap seconds or ?) */ 948 tdiff = -1; 949 } else if (f->opt & FORMAT_FLAG_TIME_MSEC) { 950 tdiff += 999999; /* ceil */ 951 tdiff /= 1000000; 952 } else if (f->opt & FORMAT_FLAG_TIME_USEC) { 953 tdiff += 999; /* ceil */ 954 tdiff /= 1000; 955 } /* else (f->opt & FORMAT_FLAG_TIME_NSEC) */ 956 buffer_append_int(b, (intmax_t)tdiff); 957 } 958 break; 959 case FORMAT_REMOTE_ADDR: 960 case FORMAT_REMOTE_HOST: 961 buffer_append_string_buffer(b, con->dst_addr_buf); 962 break; 963 case FORMAT_REMOTE_IDENT: 964 /* ident */ 965 buffer_append_string_len(b, CONST_STR_LEN("-")); 966 break; 967 case FORMAT_REMOTE_USER: 968 if (NULL != (vb = http_header_env_get(r, CONST_STR_LEN("REMOTE_USER")))) { 969 accesslog_append_escaped(b, vb); 970 } else { 971 buffer_append_string_len(b, CONST_STR_LEN("-")); 972 } 973 break; 974 case FORMAT_REQUEST_LINE: 975 /*(attempt to reconstruct request line)*/ 976 http_method_append(b, r->http_method); 977 buffer_append_string_len(b, CONST_STR_LEN(" ")); 978 accesslog_append_escaped(b, &r->target_orig); 979 buffer_append_string_len(b, CONST_STR_LEN(" ")); 980 http_version_append(b, r->http_version); 981 break; 982 case FORMAT_STATUS: 983 buffer_append_int(b, r->http_status); 984 break; 985 986 case FORMAT_BYTES_OUT_NO_HEADER: 987 { 988 off_t bytes = r->http_version <= HTTP_VERSION_1_1 989 ? con->bytes_written - r->bytes_written_ckpt 990 : r->write_queue.bytes_out; 991 if (bytes > 0) { 992 bytes -= (off_t)r->resp_header_len; 993 buffer_append_int(b, bytes > 0 ? bytes : 0); 994 } else { 995 buffer_append_string_len(b, CONST_STR_LEN("-")); 996 } 997 break; 998 } 999 case FORMAT_HEADER: 1000 if (NULL != (vb = http_header_request_get(r, f->opt, CONST_BUF_LEN(&f->string)))) { 1001 accesslog_append_escaped(b, vb); 1002 } else { 1003 buffer_append_string_len(b, CONST_STR_LEN("-")); 1004 } 1005 break; 1006 case FORMAT_RESPONSE_HEADER: 1007 if (NULL != (vb = http_header_response_get(r, f->opt, CONST_BUF_LEN(&f->string)))) { 1008 accesslog_append_escaped(b, vb); 1009 } else { 1010 buffer_append_string_len(b, CONST_STR_LEN("-")); 1011 } 1012 break; 1013 case FORMAT_ENV: 1014 case FORMAT_NOTE: 1015 if (NULL != (vb = http_header_env_get(r, CONST_BUF_LEN(&f->string)))) { 1016 accesslog_append_escaped(b, vb); 1017 } else { 1018 buffer_append_string_len(b, CONST_STR_LEN("-")); 1019 } 1020 break; 1021 case FORMAT_FILENAME: 1022 if (!buffer_string_is_empty(&r->physical.path)) { 1023 buffer_append_string_buffer(b, &r->physical.path); 1024 } else { 1025 buffer_append_string_len(b, CONST_STR_LEN("-")); 1026 } 1027 break; 1028 case FORMAT_BYTES_OUT: 1029 { 1030 off_t bytes = r->http_version <= HTTP_VERSION_1_1 1031 ? con->bytes_written - r->bytes_written_ckpt 1032 : r->write_queue.bytes_out; 1033 if (bytes > 0) { 1034 buffer_append_int(b, bytes); 1035 } else { 1036 buffer_append_string_len(b, CONST_STR_LEN("-")); 1037 } 1038 break; 1039 } 1040 case FORMAT_BYTES_IN: 1041 { 1042 off_t bytes = r->http_version <= HTTP_VERSION_1_1 1043 ? con->bytes_read - r->bytes_read_ckpt 1044 : r->read_queue.bytes_in + (off_t)r->rqst_header_len; 1045 if (bytes > 0) { 1046 buffer_append_int(b, bytes); 1047 } else { 1048 buffer_append_string_len(b, CONST_STR_LEN("-")); 1049 } 1050 break; 1051 } 1052 case FORMAT_SERVER_NAME: 1053 if (!buffer_string_is_empty(r->server_name)) { 1054 buffer_append_string_buffer(b, r->server_name); 1055 } else { 1056 buffer_append_string_len(b, CONST_STR_LEN("-")); 1057 } 1058 break; 1059 case FORMAT_HTTP_HOST: 1060 if (!buffer_string_is_empty(&r->uri.authority)) { 1061 accesslog_append_escaped(b, &r->uri.authority); 1062 } else { 1063 buffer_append_string_len(b, CONST_STR_LEN("-")); 1064 } 1065 break; 1066 case FORMAT_REQUEST_PROTOCOL: 1067 http_version_append(b, r->http_version); 1068 break; 1069 case FORMAT_REQUEST_METHOD: 1070 http_method_append(b, r->http_method); 1071 break; 1072 case FORMAT_PERCENT: 1073 buffer_append_string_len(b, CONST_STR_LEN("%")); 1074 break; 1075 case FORMAT_LOCAL_ADDR: 1076 { 1077 /* (perf: not using getsockname() and inet_ntop_cache_get_ip()) 1078 * (still useful if admin has configured explicit listen IPs) */ 1079 const char *colon; 1080 buffer *srvtoken = con->srv_socket->srv_token; 1081 if (srvtoken->ptr[0] == '[') { 1082 colon = strstr(srvtoken->ptr, "]:"); 1083 } else { 1084 colon = strchr(srvtoken->ptr, ':'); 1085 } 1086 if (colon) { 1087 buffer_append_string_len(b, srvtoken->ptr, (size_t)(colon - srvtoken->ptr)); 1088 } else { 1089 buffer_append_string_buffer(b, srvtoken); 1090 } 1091 } 1092 break; 1093 case FORMAT_SERVER_PORT: 1094 if (f->opt & FORMAT_FLAG_PORT_REMOTE) { 1095 buffer_append_int(b, sock_addr_get_port(&con->dst_addr)); 1096 } else { /* if (f->opt & FORMAT_FLAG_PORT_LOCAL) *//*(default)*/ 1097 const char *colon; 1098 buffer *srvtoken = ((server_socket*)(con->srv_socket))->srv_token; 1099 if (srvtoken->ptr[0] == '[') { 1100 colon = strstr(srvtoken->ptr, "]:"); 1101 } else { 1102 colon = strchr(srvtoken->ptr, ':'); 1103 } 1104 if (colon) { 1105 buffer_append_string(b, colon+1); 1106 } else { 1107 buffer_append_int(b, con->srv->srvconf.port); 1108 } 1109 } 1110 break; 1111 case FORMAT_QUERY_STRING: 1112 accesslog_append_escaped(b, &r->uri.query); 1113 break; 1114 case FORMAT_URL: 1115 { 1116 const uint32_t len = buffer_string_length(&r->target); 1117 const char * const qmark = memchr(r->target.ptr, '?', len); 1118 accesslog_append_escaped_str(b, r->target.ptr, qmark ? (uint32_t)(qmark - r->target.ptr) : len); 1119 } 1120 break; 1121 case FORMAT_CONNECTION_STATUS: 1122 if (r->state == CON_STATE_RESPONSE_END) { 1123 if (0 == r->keep_alive) { 1124 buffer_append_string_len(b, CONST_STR_LEN("-")); 1125 } else { 1126 buffer_append_string_len(b, CONST_STR_LEN("+")); 1127 } 1128 } else { /* CON_STATE_ERROR */ 1129 buffer_append_string_len(b, CONST_STR_LEN("X")); 1130 } 1131 break; 1132 case FORMAT_KEEPALIVE_COUNT: 1133 if (con->request_count > 1) { 1134 buffer_append_int(b, (intmax_t)(con->request_count-1)); 1135 } else { 1136 buffer_append_string_len(b, CONST_STR_LEN("0")); 1137 } 1138 break; 1139 case FORMAT_COOKIE: 1140 if (NULL != (vb = http_header_request_get(r, HTTP_HEADER_COOKIE, CONST_STR_LEN("Cookie")))) { 1141 char *str = vb->ptr; 1142 size_t len = buffer_string_length(&f->string); 1143 do { 1144 while (*str == ' ' || *str == '\t') ++str; 1145 if (0 == strncmp(str, f->string.ptr, len) && str[len] == '=') { 1146 char *v = str+len+1; 1147 for (str = v; *str != '\0' && *str != ';'; ++str) ; 1148 if (str == v) break; 1149 do { --str; } while (str > v && (*str == ' ' || *str == '\t')); 1150 accesslog_append_escaped_str(b, v, str - v + 1); 1151 break; 1152 } else { 1153 while (*str != ';' && *str != ' ' && *str != '\t' && *str != '\0') ++str; 1154 } 1155 while (*str == ' ' || *str == '\t') ++str; 1156 } while (*str++ == ';'); 1157 } 1158 break; 1159 default: 1160 break; 1161 } 1162 break; 1163 default: 1164 break; 1165 } 1166 } 1167 1168 return flush; 1169 } 1170 1171 REQUESTDONE_FUNC(log_access_write) { 1172 plugin_data * const p = p_d; 1173 mod_accesslog_patch_config(r, p); 1174 1175 /* No output device, nothing to do */ 1176 if (!p->conf.use_syslog && p->conf.log_access_fd == -1) return HANDLER_GO_ON; 1177 1178 buffer * const b = (p->conf.use_syslog) 1179 ? &p->syslog_logbuffer 1180 : p->conf.access_logbuffer; 1181 1182 const int flush = p->conf.piped_logger 1183 | log_access_record(r, b, p->conf.parsed_format); 1184 1185 if (p->conf.use_syslog) { /* syslog doesn't cache */ 1186 #ifdef HAVE_SYSLOG_H 1187 if (!buffer_string_is_empty(b)) { 1188 /*(syslog appends a \n on its own)*/ 1189 syslog(p->conf.syslog_level, "%s", b->ptr); 1190 } 1191 #endif 1192 buffer_clear(b); 1193 } 1194 else { 1195 buffer_append_string_len(b, CONST_STR_LEN("\n")); 1196 1197 if (flush || buffer_string_length(b) >= 8192) { 1198 if (!accesslog_write_all(p->conf.log_access_fd, b)) { 1199 log_perror(r->conf.errh, __FILE__, __LINE__, 1200 "writing access log entry failed: %s", 1201 p->conf.access_logfile->ptr); 1202 } 1203 } 1204 } 1205 1206 return HANDLER_GO_ON; 1207 } 1208 1209 1210 int mod_accesslog_plugin_init(plugin *p); 1211 int mod_accesslog_plugin_init(plugin *p) { 1212 p->version = LIGHTTPD_VERSION_ID; 1213 p->name = "accesslog"; 1214 1215 p->init = mod_accesslog_init; 1216 p->set_defaults= mod_accesslog_set_defaults; 1217 p->cleanup = mod_accesslog_free; 1218 1219 p->handle_request_done = log_access_write; 1220 p->handle_trigger = log_access_periodic_flush; 1221 p->handle_sighup = log_access_cycle; 1222 1223 return 0; 1224 } 1225