nginx/src/http/modules/ngx_http_log_module.c

   1
   2 /*
   3  * Copyright (C) Igor Sysoev
   4  */
   5
   6
   7 #include <ngx_config.h>
   8 #include <ngx_core.h>
   9 #include <ngx_http.h>
  10
  11
  12 typedef struct ngx_http_log_op_s  ngx_http_log_op_t;
  13
  14 typedef u_char *(*ngx_http_log_op_run_pt) (ngx_http_request_t *r, u_char *buf,
  15     ngx_http_log_op_t *op);
  16
  17 typedef size_t (*ngx_http_log_op_getlen_pt) (ngx_http_request_t *r,
  18     uintptr_t data);
  19
  20
  21 struct ngx_http_log_op_s {
  22     size_t                      len;
  23     ngx_http_log_op_getlen_pt   getlen;
  24     ngx_http_log_op_run_pt      run;
  25     uintptr_t                   data;
  26 };
  27
  28
  29 typedef struct {
  30     ngx_str_t                   name;
  31     ngx_array_t                *flushes;
  32     ngx_array_t                *ops;        /* array of ngx_http_log_op_t */
  33 } ngx_http_log_fmt_t;
  34
  35
  36 typedef struct {
  37     ngx_array_t                 formats;    /* array of ngx_http_log_fmt_t */
  38     ngx_uint_t                  combined_used; /* unsigned  combined_used:1 */
  39 } ngx_http_log_main_conf_t;
  40
  41
  42 typedef struct {
  43     ngx_array_t                *lengths;
  44     ngx_array_t                *values;
  45 } ngx_http_log_script_t;
  46
  47
  48 typedef struct {
  49     ngx_open_file_t            *file;
  50     ngx_http_log_script_t      *script;
  51     time_t                      disk_full_time;
  52     time_t                      error_log_time;
  53     ngx_http_log_fmt_t         *format;
  54 } ngx_http_log_t;
  55
  56
  57 typedef struct {
  58     ngx_array_t                *logs;       /* array of ngx_http_log_t */
  59
  60     ngx_open_file_cache_t      *open_file_cache;
  61     time_t                      open_file_cache_valid;
  62     ngx_uint_t                  open_file_cache_min_uses;
  63
  64     ngx_uint_t                  off;        /* unsigned  off:1 */
  65 } ngx_http_log_loc_conf_t;
  66
  67
  68 typedef struct {
  69     ngx_str_t                   name;
  70     size_t                      len;
  71     ngx_http_log_op_run_pt      run;
  72 } ngx_http_log_var_t;
  73
  74
  75 static void ngx_http_log_write(ngx_http_request_t *r, ngx_http_log_t *log,
  76     u_char *buf, size_t len);
  77 static ssize_t ngx_http_log_script_write(ngx_http_request_t *r,
  78     ngx_http_log_script_t *script, u_char **name, u_char *buf, size_t len);
  79
  80 static u_char *ngx_http_log_connection(ngx_http_request_t *r, u_char *buf,
  81     ngx_http_log_op_t *op);
  82 static u_char *ngx_http_log_pipe(ngx_http_request_t *r, u_char *buf,
  83     ngx_http_log_op_t *op);
  84 static u_char *ngx_http_log_time(ngx_http_request_t *r, u_char *buf,
  85     ngx_http_log_op_t *op);
  86 static u_char *ngx_http_log_msec(ngx_http_request_t *r, u_char *buf,
  87     ngx_http_log_op_t *op);
  88 static u_char *ngx_http_log_request_time(ngx_http_request_t *r, u_char *buf,
  89     ngx_http_log_op_t *op);
  90 static u_char *ngx_http_log_status(ngx_http_request_t *r, u_char *buf,
  91     ngx_http_log_op_t *op);
  92 static u_char *ngx_http_log_bytes_sent(ngx_http_request_t *r, u_char *buf,
  93     ngx_http_log_op_t *op);
  94 static u_char *ngx_http_log_body_bytes_sent(ngx_http_request_t *r,
  95     u_char *buf, ngx_http_log_op_t *op);
  96 static u_char *ngx_http_log_request_length(ngx_http_request_t *r, u_char *buf,
  97     ngx_http_log_op_t *op);
  98
  99 static ngx_int_t ngx_http_log_variable_compile(ngx_conf_t *cf,
 100     ngx_http_log_op_t *op, ngx_str_t *value);
 101 static size_t ngx_http_log_variable_getlen(ngx_http_request_t *r,
 102     uintptr_t data);
 103 static u_char *ngx_http_log_variable(ngx_http_request_t *r, u_char *buf,
 104     ngx_http_log_op_t *op);
 105 static uintptr_t ngx_http_log_escape(u_char *dst, u_char *src, size_t size);
 106
 107
 108 static void *ngx_http_log_create_main_conf(ngx_conf_t *cf);
 109 static void *ngx_http_log_create_loc_conf(ngx_conf_t *cf);
 110 static char *ngx_http_log_merge_loc_conf(ngx_conf_t *cf, void *parent,
 111     void *child);
 112 static char *ngx_http_log_set_log(ngx_conf_t *cf, ngx_command_t *cmd,
 113     void *conf);
 114 static char *ngx_http_log_set_format(ngx_conf_t *cf, ngx_command_t *cmd,
 115     void *conf);
 116 static char *ngx_http_log_compile_format(ngx_conf_t *cf,
 117     ngx_array_t *flushes, ngx_array_t *ops, ngx_array_t *args, ngx_uint_t s);
 118 static char *ngx_http_log_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd,
 119     void *conf);
 120 static ngx_int_t ngx_http_log_init(ngx_conf_t *cf);
 121
 122
 123 static ngx_command_t  ngx_http_log_commands[] = {
 124
 125     { ngx_string("log_format"),
 126       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_2MORE,
 127       ngx_http_log_set_format,
 128       NGX_HTTP_MAIN_CONF_OFFSET,
 129       0,
 130       NULL },
 131
 132     { ngx_string("access_log"),
 133       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
 134                         |NGX_HTTP_LMT_CONF|NGX_CONF_TAKE123,
 135       ngx_http_log_set_log,
 136       NGX_HTTP_LOC_CONF_OFFSET,
 137       0,
 138       NULL },
 139
 140     { ngx_string("open_log_file_cache"),
 141       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
 142       ngx_http_log_open_file_cache,
 143       NGX_HTTP_LOC_CONF_OFFSET,
 144       0,
 145       NULL },
 146
 147       ngx_null_command
 148 };
 149
 150
 151 static ngx_http_module_t  ngx_http_log_module_ctx = {
 152     NULL,                                  /* preconfiguration */
 153     ngx_http_log_init,                     /* postconfiguration */
 154
 155     ngx_http_log_create_main_conf,         /* create main configuration */
 156     NULL,                                  /* init main configuration */
 157
 158     NULL,                                  /* create server configuration */
 159     NULL,                                  /* merge server configuration */
 160
 161     ngx_http_log_create_loc_conf,          /* create location configration */
 162     ngx_http_log_merge_loc_conf            /* merge location configration */
 163 };
 164
 165
 166 ngx_module_t  ngx_http_log_module = {
 167     NGX_MODULE_V1,
 168     &ngx_http_log_module_ctx,              /* module context */
 169     ngx_http_log_commands,                 /* module directives */
 170     NGX_HTTP_MODULE,                       /* module type */
 171     NULL,                                  /* init master */
 172     NULL,                                  /* init module */
 173     NULL,                                  /* init process */
 174     NULL,                                  /* init thread */
 175     NULL,                                  /* exit thread */
 176     NULL,                                  /* exit process */
 177     NULL,                                  /* exit master */
 178     NGX_MODULE_V1_PADDING
 179 };
 180
 181
 182 static ngx_str_t  ngx_http_access_log = ngx_string(NGX_HTTP_LOG_PATH);
 183
 184
 185 static ngx_str_t  ngx_http_combined_fmt =
 186     ngx_string("$remote_addr - $remote_user [$time_local] "
 187                "\"$request\" $status $body_bytes_sent "
 188                "\"$http_referer\" \"$http_user_agent\"");
 189
 190
 191 static ngx_http_log_var_t  ngx_http_log_vars[] = {
 192     { ngx_string("connection"), NGX_ATOMIC_T_LEN, ngx_http_log_connection },
 193     { ngx_string("pipe"), 1, ngx_http_log_pipe },
 194     { ngx_string("time_local"), sizeof("28/Sep/1970:12:00:00 +0600") - 1,
 195                           ngx_http_log_time },
 196     { ngx_string("msec"), NGX_TIME_T_LEN + 4, ngx_http_log_msec },
 197     { ngx_string("request_time"), NGX_TIME_T_LEN + 4,
 198                           ngx_http_log_request_time },
 199     { ngx_string("status"), 3, ngx_http_log_status },
 200     { ngx_string("bytes_sent"), NGX_OFF_T_LEN, ngx_http_log_bytes_sent },
 201     { ngx_string("body_bytes_sent"), NGX_OFF_T_LEN,
 202                           ngx_http_log_body_bytes_sent },
 203     { ngx_string("apache_bytes_sent"), NGX_OFF_T_LEN,
 204                           ngx_http_log_body_bytes_sent },
 205     { ngx_string("request_length"), NGX_SIZE_T_LEN,
 206                           ngx_http_log_request_length },
 207
 208     { ngx_null_string, 0, NULL }
 209 };
 210
 211
 212 ngx_int_t
 213 ngx_http_log_handler(ngx_http_request_t *r)
 214 {
 215     u_char                   *line, *p;
 216     size_t                    len;
 217     ngx_uint_t                i, l;
 218     ngx_http_log_t           *log;
 219     ngx_open_file_t          *file;
 220     ngx_http_log_op_t        *op;
 221     ngx_http_log_loc_conf_t  *lcf;
 222
 223     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
 224                    "http log handler");
 225
 226     lcf = ngx_http_get_module_loc_conf(r, ngx_http_log_module);
 227
 228     if (lcf->off) {
 229         return NGX_OK;
 230     }
 231
 232     log = lcf->logs->elts;
 233     for (l = 0; l < lcf->logs->nelts; l++) {
 234
 235         if (ngx_time() == log[l].disk_full_time) {
 236
 237             /*
 238              * on FreeBSD writing to a full filesystem with enabled softupdates
 239              * may block process for much longer time than writing to non-full
 240              * filesystem, so we skip writing to a log for one second
 241              */
 242
 243             continue;
 244         }
 245
 246         ngx_http_script_flush_no_cacheable_variables(r, log[l].format->flushes);
 247
 248         len = 0;
 249         op = log[l].format->ops->elts;
 250         for (i = 0; i < log[l].format->ops->nelts; i++) {
 251             if (op[i].len == 0) {
 252                 len += op[i].getlen(r, op[i].data);
 253
 254             } else {
 255                 len += op[i].len;
 256             }
 257         }
 258
 259         len += NGX_LINEFEED_SIZE;
 260
 261         file = log[l].file;
 262
 263         if (file && file->buffer) {
 264
 265             if (len > (size_t) (file->last - file->pos)) {
 266
 267                 ngx_http_log_write(r, &log[l], file->buffer,
 268                                    file->pos - file->buffer);
 269
 270                 file->pos = file->buffer;
 271             }
 272
 273             if (len <= (size_t) (file->last - file->pos)) {
 274
 275                 p = file->pos;
 276
 277                 for (i = 0; i < log[l].format->ops->nelts; i++) {
 278                     p = op[i].run(r, p, &op[i]);
 279                 }
 280
 281                 ngx_linefeed(p);
 282
 283                 file->pos = p;
 284
 285                 continue;
 286             }
 287         }
 288
 289         line = ngx_pnalloc(r->pool, len);
 290         if (line == NULL) {
 291             return NGX_ERROR;
 292         }
 293
 294         p = line;
 295
 296         for (i = 0; i < log[l].format->ops->nelts; i++) {
 297             p = op[i].run(r, p, &op[i]);
 298         }
 299
 300         ngx_linefeed(p);
 301
 302         ngx_http_log_write(r, &log[l], line, p - line);
 303     }
 304
 305     return NGX_OK;
 306 }
 307
 308
 309 static void
 310 ngx_http_log_write(ngx_http_request_t *r, ngx_http_log_t *log, u_char *buf,
 311     size_t len)
 312 {
 313     u_char     *name;
 314     time_t      now;
 315     ssize_t     n;
 316     ngx_err_t   err;
 317
 318     if (log->script == NULL) {
 319         name = log->file->name.data;
 320         n = ngx_write_fd(log->file->fd, buf, len);
 321
 322     } else {
 323         name = NULL;
 324         n = ngx_http_log_script_write(r, log->script, &name, buf, len);
 325     }
 326
 327     if (n == (ssize_t) len) {
 328         return;
 329     }
 330
 331     now = ngx_time();
 332
 333     if (n == -1) {
 334         err = ngx_errno;
 335
 336         if (err == NGX_ENOSPC) {
 337             log->disk_full_time = now;
 338         }
 339
 340         if (now - log->error_log_time > 59) {
 341             ngx_log_error(NGX_LOG_ALERT, r->connection->log, err,
 342                           ngx_write_fd_n " to \"%s\" failed", name);
 343
 344             log->error_log_time = now;
 345         }
 346
 347         return;
 348     }
 349
 350     if (now - log->error_log_time > 59) {
 351         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
 352                       ngx_write_fd_n " to \"%s\" was incomplete: %z of %uz",
 353                       name, n, len);
 354
 355         log->error_log_time = now;
 356     }
 357 }
 358
 359
 360 static ssize_t
 361 ngx_http_log_script_write(ngx_http_request_t *r, ngx_http_log_script_t *script,
 362     u_char **name, u_char *buf, size_t len)
 363 {
 364     size_t                     root;
 365     ssize_t                    n;
 366     ngx_str_t                  log, path;
 367     ngx_open_file_info_t       of;
 368     ngx_http_log_loc_conf_t   *llcf;
 369     ngx_http_core_loc_conf_t  *clcf;
 370
 371     if (!r->root_tested) {
 372
 373         /* test root directory existance */
 374
 375         if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
 376             /* simulate successfull logging */
 377             return len;
 378         }
 379
 380         path.data[root] = '\0';
 381
 382         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
 383
 384         ngx_memzero(&of, sizeof(ngx_open_file_info_t));
 385
 386         of.valid = clcf->open_file_cache_valid;
 387         of.min_uses = clcf->open_file_cache_min_uses;
 388         of.errors = clcf->open_file_cache_errors;
 389         of.events = clcf->open_file_cache_events;
 390
 391         if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
 392             != NGX_OK)
 393         {
 394             if (of.err == 0) {
 395                 /* simulate successfull logging */
 396                 return len;
 397             }
 398
 399             ngx_log_error(NGX_LOG_ERR, r->connection->log, of.err,
 400                           "testing \"%s\" existence failed", path.data);
 401
 402             /* simulate successfull logging */
 403             return len;
 404         }
 405
 406         if (!of.is_dir) {
 407             ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_ENOTDIR,
 408                           "testing \"%s\" existence failed", path.data);
 409
 410             /* simulate successfull logging */
 411             return len;
 412         }
 413     }
 414
 415     if (ngx_http_script_run(r, &log, script->lengths->elts, 1,
 416                             script->values->elts)
 417         == NULL)
 418     {
 419         /* simulate successfull logging */
 420         return len;
 421     }
 422
 423     log.data[log.len - 1] = '\0';
 424     *name = log.data;
 425
 426     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
 427                    "http log \"%s\"", log.data);
 428
 429     llcf = ngx_http_get_module_loc_conf(r, ngx_http_log_module);
 430
 431     ngx_memzero(&of, sizeof(ngx_open_file_info_t));
 432
 433     of.log = 1;
 434     of.valid = llcf->open_file_cache_valid;
 435     of.min_uses = llcf->open_file_cache_min_uses;
 436     of.directio = NGX_OPEN_FILE_DIRECTIO_OFF;
 437
 438     if (ngx_open_cached_file(llcf->open_file_cache, &log, &of, r->pool)
 439         != NGX_OK)
 440     {
 441         ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
 442                       ngx_open_file_n " \"%s\" failed", log.data);
 443         /* simulate successfull logging */
 444         return len;
 445     }
 446
 447     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
 448                    "http log #%d", of.fd);
 449
 450     n = ngx_write_fd(of.fd, buf, len);
 451
 452     return n;
 453 }
 454
 455
 456 static u_char *
 457 ngx_http_log_copy_short(ngx_http_request_t *r, u_char *buf,
 458     ngx_http_log_op_t *op)
 459 {
 460     size_t     len;
 461     uintptr_t  data;
 462
 463     len = op->len;
 464     data = op->data;
 465
 466     while (len--) {
 467         *buf++ = (u_char) (data & 0xff);
 468         data >>= 8;
 469     }
 470
 471     return buf;
 472 }
 473
 474
 475 static u_char *
 476 ngx_http_log_copy_long(ngx_http_request_t *r, u_char *buf,
 477     ngx_http_log_op_t *op)
 478 {
 479     return ngx_cpymem(buf, (u_char *) op->data, op->len);
 480 }
 481
 482
 483 static u_char *
 484 ngx_http_log_connection(ngx_http_request_t *r, u_char *buf,
 485     ngx_http_log_op_t *op)
 486 {
 487     return ngx_sprintf(buf, "%ui", r->connection->number);
 488 }
 489
 490
 491 static u_char *
 492 ngx_http_log_pipe(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
 493 {
 494     if (r->pipeline) {
 495         *buf = 'p';
 496     } else {
 497         *buf = '.';
 498     }
 499
 500     return buf + 1;
 501 }
 502
 503
 504 static u_char *
 505 ngx_http_log_time(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
 506 {
 507     return ngx_cpymem(buf, ngx_cached_http_log_time.data,
 508                       ngx_cached_http_log_time.len);
 509 }
 510
 511
 512 static u_char *
 513 ngx_http_log_msec(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
 514 {
 515     ngx_time_t  *tp;
 516
 517     tp = ngx_timeofday();
 518
 519     return ngx_sprintf(buf, "%T.%03M", tp->sec, tp->msec);
 520 }
 521
 522
 523 static u_char *
 524 ngx_http_log_request_time(ngx_http_request_t *r, u_char *buf,
 525     ngx_http_log_op_t *op)
 526 {
 527     ngx_time_t      *tp;
 528     ngx_msec_int_t   ms;
 529
 530     tp = ngx_timeofday();
 531
 532     ms = (ngx_msec_int_t)
 533              ((tp->sec - r->start_sec) * 1000 + (tp->msec - r->start_msec));
 534     ms = (ms >= 0) ? ms : 0;
 535
 536     return ngx_sprintf(buf, "%T.%03M", ms / 1000, ms % 1000);
 537 }
 538
 539
 540 static u_char *
 541 ngx_http_log_status(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
 542 {
 543     return ngx_sprintf(buf, "%ui",
 544                        r->err_status ? r->err_status : r->headers_out.status);
 545 }
 546
 547
 548 static u_char *
 549 ngx_http_log_bytes_sent(ngx_http_request_t *r, u_char *buf,
 550     ngx_http_log_op_t *op)
 551 {
 552     return ngx_sprintf(buf, "%O", r->connection->sent);
 553 }
 554
 555
 556 /*
 557  * although there is a real $body_bytes_sent variable,
 558  * this log operation code function is more optimized for logging
 559  */
 560
 561 static u_char *
 562 ngx_http_log_body_bytes_sent(ngx_http_request_t *r, u_char *buf,
 563     ngx_http_log_op_t *op)
 564 {
 565     off_t  length;
 566
 567     length = r->connection->sent - r->header_size;
 568
 569     if (length > 0) {
 570         return ngx_sprintf(buf, "%O", length);
 571     }
 572
 573     *buf = '0';
 574
 575     return buf + 1;
 576 }
 577
 578
 579 static u_char *
 580 ngx_http_log_request_length(ngx_http_request_t *r, u_char *buf,
 581     ngx_http_log_op_t *op)
 582 {
 583     return ngx_sprintf(buf, "%O", r->request_length);
 584 }
 585
 586
 587 static ngx_int_t
 588 ngx_http_log_variable_compile(ngx_conf_t *cf, ngx_http_log_op_t *op,
 589     ngx_str_t *value)
 590 {
 591     ngx_int_t  index;
 592
 593     index = ngx_http_get_variable_index(cf, value);
 594     if (index == NGX_ERROR) {
 595         return NGX_ERROR;
 596     }
 597
 598     op->len = 0;
 599     op->getlen = ngx_http_log_variable_getlen;
 600     op->run = ngx_http_log_variable;
 601     op->data = index;
 602
 603     return NGX_OK;
 604 }
 605
 606
 607 static size_t
 608 ngx_http_log_variable_getlen(ngx_http_request_t *r, uintptr_t data)
 609 {
 610     uintptr_t                   len;
 611     ngx_http_variable_value_t  *value;
 612
 613     value = ngx_http_get_indexed_variable(r, data);
 614
 615     if (value == NULL || value->not_found) {
 616         return 1;
 617     }
 618
 619     len = ngx_http_log_escape(NULL, value->data, value->len);
 620
 621     value->escape = len ? 1 : 0;
 622
 623     return value->len + len * 3;
 624 }
 625
 626
 627 static u_char *
 628 ngx_http_log_variable(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
 629 {
 630     ngx_http_variable_value_t  *value;
 631
 632     value = ngx_http_get_indexed_variable(r, op->data);
 633
 634     if (value == NULL || value->not_found) {
 635         *buf = '-';
 636         return buf + 1;
 637     }
 638
 639     if (value->escape == 0) {
 640         return ngx_cpymem(buf, value->data, value->len);
 641
 642     } else {
 643         return (u_char *) ngx_http_log_escape(buf, value->data, value->len);
 644     }
 645 }
 646
 647
 648 static uintptr_t
 649 ngx_http_log_escape(u_char *dst, u_char *src, size_t size)
 650 {
 651     ngx_uint_t      i, n;
 652     static u_char   hex[] = "0123456789ABCDEF";
 653
 654     static uint32_t   escape[] = {
 655         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
 656
 657                     /* ?>=< ;:98 7654 3210  /.-, +*)( '&%$ #"!  */
 658         0x00000004, /* 0000 0000 0000 0000  0000 0000 0000 0100 */
 659
 660                     /* _^]\ [ZYX WVUT SRQP  ONML KJIH GFED CBA@ */
 661         0x10000000, /* 0001 0000 0000 0000  0000 0000 0000 0000 */
 662
 663                     /*  ~}| {zyx wvut srqp  onml kjih gfed cba` */
 664         0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */
 665
 666         0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */
 667         0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */
 668         0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */
 669         0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */
 670     };
 671
 672
 673     if (dst == NULL) {
 674
 675         /* find the number of the characters to be escaped */
 676
 677         n  = 0;
 678
 679         for (i = 0; i < size; i++) {
 680             if (escape[*src >> 5] & (1 << (*src & 0x1f))) {
 681                 n++;
 682             }
 683             src++;
 684         }
 685
 686         return (uintptr_t) n;
 687     }
 688
 689     for (i = 0; i < size; i++) {
 690         if (escape[*src >> 5] & (1 << (*src & 0x1f))) {
 691             *dst++ = '\\';
 692             *dst++ = 'x';
 693             *dst++ = hex[*src >> 4];
 694             *dst++ = hex[*src & 0xf];
 695             src++;
 696
 697         } else {
 698             *dst++ = *src++;
 699         }
 700     }
 701
 702     return (uintptr_t) dst;
 703 }
 704
 705
 706 static void *
 707 ngx_http_log_create_main_conf(ngx_conf_t *cf)
 708 {
 709     ngx_http_log_main_conf_t  *conf;
 710
 711     ngx_http_log_fmt_t  *fmt;
 712
 713     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_log_main_conf_t));
 714     if (conf == NULL) {
 715         return NGX_CONF_ERROR;
 716     }
 717
 718     if (ngx_array_init(&conf->formats, cf->pool, 4, sizeof(ngx_http_log_fmt_t))
 719         != NGX_OK)
 720     {
 721         return NGX_CONF_ERROR;
 722     }
 723
 724     fmt = ngx_array_push(&conf->formats);
 725     if (fmt == NULL) {
 726         return NGX_CONF_ERROR;
 727     }
 728
 729     fmt->name.len = sizeof("combined") - 1;
 730     fmt->name.data = (u_char *) "combined";
 731
 732     fmt->flushes = NULL;
 733
 734     fmt->ops = ngx_array_create(cf->pool, 16, sizeof(ngx_http_log_op_t));
 735     if (fmt->ops == NULL) {
 736         return NGX_CONF_ERROR;
 737     }
 738
 739     return conf;
 740 }
 741
 742
 743 static void *
 744 ngx_http_log_create_loc_conf(ngx_conf_t *cf)
 745 {
 746     ngx_http_log_loc_conf_t  *conf;
 747
 748     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_log_loc_conf_t));
 749     if (conf == NULL) {
 750         return NGX_CONF_ERROR;
 751     }
 752
 753     conf->open_file_cache = NGX_CONF_UNSET_PTR;
 754
 755     return conf;
 756 }
 757
 758
 759 static char *
 760 ngx_http_log_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
 761 {
 762     ngx_http_log_loc_conf_t *prev = parent;
 763     ngx_http_log_loc_conf_t *conf = child;
 764
 765     ngx_http_log_t            *log;
 766     ngx_http_log_fmt_t        *fmt;
 767     ngx_http_log_main_conf_t  *lmcf;
 768
 769     if (conf->open_file_cache == NGX_CONF_UNSET_PTR) {
 770
 771         conf->open_file_cache = prev->open_file_cache;
 772         conf->open_file_cache_valid = prev->open_file_cache_valid;
 773         conf->open_file_cache_min_uses = prev->open_file_cache_min_uses;
 774
 775         if (conf->open_file_cache == NGX_CONF_UNSET_PTR) {
 776             conf->open_file_cache = NULL;
 777         }
 778     }
 779
 780     if (conf->logs || conf->off) {
 781         return NGX_CONF_OK;
 782     }
 783
 784     conf->logs = prev->logs;
 785     conf->off = prev->off;
 786
 787     if (conf->logs || conf->off) {
 788         return NGX_CONF_OK;
 789     }
 790
 791     conf->logs = ngx_array_create(cf->pool, 2, sizeof(ngx_http_log_t));
 792     if (conf->logs == NULL) {
 793         return NGX_CONF_ERROR;
 794     }
 795
 796     log = ngx_array_push(conf->logs);
 797     if (log == NULL) {
 798         return NGX_CONF_ERROR;
 799     }
 800
 801     log->file = ngx_conf_open_file(cf->cycle, &ngx_http_access_log);
 802     if (log->file == NULL) {
 803         return NGX_CONF_ERROR;
 804     }
 805
 806     log->script = NULL;
 807     log->disk_full_time = 0;
 808     log->error_log_time = 0;
 809
 810     lmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_log_module);
 811     fmt = lmcf->formats.elts;
 812
 813     /* the default "combined" format */
 814     log->format = &fmt[0];
 815     lmcf->combined_used = 1;
 816
 817     return NGX_CONF_OK;
 818 }
 819
 820
 821 static char *
 822 ngx_http_log_set_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 823 {
 824     ngx_http_log_loc_conf_t *llcf = conf;
 825
 826     ssize_t                     buf;
 827     ngx_uint_t                  i, n;
 828     ngx_str_t                  *value, name;
 829     ngx_http_log_t             *log;
 830     ngx_http_log_fmt_t         *fmt;
 831     ngx_http_log_main_conf_t   *lmcf;
 832     ngx_http_script_compile_t   sc;
 833
 834     value = cf->args->elts;
 835
 836     if (ngx_strcmp(value[1].data, "off") == 0) {
 837         llcf->off = 1;
 838         return NGX_CONF_OK;
 839     }
 840
 841     if (llcf->logs == NULL) {
 842         llcf->logs = ngx_array_create(cf->pool, 2, sizeof(ngx_http_log_t));
 843         if (llcf->logs == NULL) {
 844             return NGX_CONF_ERROR;
 845         }
 846     }
 847
 848     lmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_log_module);
 849
 850     log = ngx_array_push(llcf->logs);
 851     if (log == NULL) {
 852         return NGX_CONF_ERROR;
 853     }
 854
 855     ngx_memzero(log, sizeof(ngx_http_log_t));
 856
 857     n = ngx_http_script_variables_count(&value[1]);
 858
 859     if (n == 0) {
 860         log->file = ngx_conf_open_file(cf->cycle, &value[1]);
 861         if (log->file == NULL) {
 862             return NGX_CONF_ERROR;
 863         }
 864
 865     } else {
 866         if (ngx_conf_full_name(cf->cycle, &value[1], 0) == NGX_ERROR) {
 867             return NGX_CONF_ERROR;
 868         }
 869
 870         log->script = ngx_pcalloc(cf->pool, sizeof(ngx_http_log_script_t));
 871         if (log->script == NULL) {
 872             return NGX_CONF_ERROR;
 873         }
 874
 875         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
 876
 877         sc.cf = cf;
 878         sc.source = &value[1];
 879         sc.lengths = &log->script->lengths;
 880         sc.values = &log->script->values;
 881         sc.variables = n;
 882         sc.complete_lengths = 1;
 883         sc.complete_values = 1;
 884
 885         if (ngx_http_script_compile(&sc) != NGX_OK) {
 886             return NGX_CONF_ERROR;
 887         }
 888     }
 889
 890     if (cf->args->nelts >= 3) {
 891         name = value[2];
 892
 893         if (ngx_strcmp(name.data, "combined") == 0) {
 894             lmcf->combined_used = 1;
 895         }
 896
 897     } else {
 898         name.len = sizeof("combined") - 1;
 899         name.data = (u_char *) "combined";
 900         lmcf->combined_used = 1;
 901     }
 902
 903     fmt = lmcf->formats.elts;
 904     for (i = 0; i < lmcf->formats.nelts; i++) {
 905         if (fmt[i].name.len == name.len
 906             && ngx_strcasecmp(fmt[i].name.data, name.data) == 0)
 907         {
 908             log->format = &fmt[i];
 909             goto buffer;
 910         }
 911     }
 912
 913     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 914                        "unknown log format \"%V\"", &name);
 915     return NGX_CONF_ERROR;
 916
 917 buffer:
 918
 919     if (cf->args->nelts == 4) {
 920         if (ngx_strncmp(value[3].data, "buffer=", 7) != 0) {
 921             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 922                                "invalid parameter \"%V\"", &value[3]);
 923             return NGX_CONF_ERROR;
 924         }
 925
 926         if (log->script) {
 927             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 928                                "buffered logs can not have variables in name");
 929             return NGX_CONF_ERROR;
 930         }
 931
 932         name.len = value[3].len - 7;
 933         name.data = value[3].data + 7;
 934
 935         buf = ngx_parse_size(&name);
 936
 937         if (buf == NGX_ERROR) {
 938             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 939                                "invalid parameter \"%V\"", &value[3]);
 940             return NGX_CONF_ERROR;
 941         }
 942
 943         if (log->file->buffer && log->file->last - log->file->pos != buf) {
 944             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 945                                "access_log \"%V\" already defined "
 946                                "with different buffer size", &value[1]);
 947             return NGX_CONF_ERROR;
 948         }
 949
 950         log->file->buffer = ngx_palloc(cf->pool, buf);
 951         if (log->file->buffer == NULL) {
 952             return NGX_CONF_ERROR;
 953         }
 954
 955         log->file->pos = log->file->buffer;
 956         log->file->last = log->file->buffer + buf;
 957     }
 958
 959     return NGX_CONF_OK;
 960 }
 961
 962
 963 static char *
 964 ngx_http_log_set_format(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 965 {
 966     ngx_http_log_main_conf_t *lmcf = conf;
 967
 968     ngx_str_t           *value;
 969     ngx_uint_t           i;
 970     ngx_http_log_fmt_t  *fmt;
 971
 972     value = cf->args->elts;
 973
 974     fmt = lmcf->formats.elts;
 975     for (i = 0; i < lmcf->formats.nelts; i++) {
 976         if (fmt[i].name.len == value[1].len
 977             && ngx_strcmp(fmt[i].name.data, value[1].data) == 0)
 978         {
 979             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 980                                "duplicate \"log_format\" name \"%V\"",
 981                                &value[1]);
 982             return NGX_CONF_ERROR;
 983         }
 984     }
 985
 986     fmt = ngx_array_push(&lmcf->formats);
 987     if (fmt == NULL) {
 988         return NGX_CONF_ERROR;
 989     }
 990
 991     fmt->name = value[1];
 992
 993     fmt->flushes = ngx_array_create(cf->pool, 4, sizeof(ngx_int_t));
 994     if (fmt->flushes == NULL) {
 995         return NGX_CONF_ERROR;
 996     }
 997
 998     fmt->ops = ngx_array_create(cf->pool, 16, sizeof(ngx_http_log_op_t));
 999     if (fmt->ops == NULL) {
1000         return NGX_CONF_ERROR;
1001     }
1002
1003     return ngx_http_log_compile_format(cf, fmt->flushes, fmt->ops, cf->args, 2);
1004 }
1005
1006
1007 static char *
1008 ngx_http_log_compile_format(ngx_conf_t *cf, ngx_array_t *flushes,
1009     ngx_array_t *ops, ngx_array_t *args, ngx_uint_t s)
1010 {
1011     u_char              *data, *p, ch;
1012     size_t               i, len;
1013     ngx_str_t           *value, var;
1014     ngx_int_t           *flush;
1015     ngx_uint_t           bracket;
1016     ngx_http_log_op_t   *op;
1017     ngx_http_log_var_t  *v;
1018
1019     value = args->elts;
1020
1021     for ( /* void */ ; s < args->nelts; s++) {
1022
1023         for (i = 0; i < value[s].len; i++) {
1024             if (value[s].data[i] != '%') {
1025                 continue;
1026             }
1027
1028             ch = value[s].data[i + 1];
1029
1030             if ((ch >= 'A' && ch <= 'Z')
1031                  || (ch >= 'a' && ch <= 'z')
1032                  || ch == '{')
1033             {
1034                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1035                      "the parameters in the \"%%name\" form are not supported, "
1036                      "use the \"$variable\" instead");
1037
1038                 return NGX_CONF_ERROR;
1039             }
1040         }
1041
1042         i = 0;
1043
1044         while (i < value[s].len) {
1045
1046             op = ngx_array_push(ops);
1047             if (op == NULL) {
1048                 return NGX_CONF_ERROR;
1049             }
1050
1051             data = &value[s].data[i];
1052
1053             if (value[s].data[i] == '$') {
1054
1055                 if (++i == value[s].len) {
1056                     goto invalid;
1057                 }
1058
1059                 if (value[s].data[i] == '{') {
1060                     bracket = 1;
1061
1062                     if (++i == value[s].len) {
1063                         goto invalid;
1064                     }
1065
1066                     var.data = &value[s].data[i];
1067
1068                 } else {
1069                     bracket = 0;
1070                     var.data = &value[s].data[i];
1071                 }
1072
1073                 for (var.len = 0; i < value[s].len; i++, var.len++) {
1074                     ch = value[s].data[i];
1075
1076                     if (ch == '}' && bracket) {
1077                         i++;
1078                         bracket = 0;
1079                         break;
1080                     }
1081
1082                     if ((ch >= 'A' && ch <= 'Z')
1083                         || (ch >= 'a' && ch <= 'z')
1084                         || (ch >= '0' && ch <= '9')
1085                         || ch == '_')
1086                     {
1087                         continue;
1088                     }
1089
1090                     break;
1091                 }
1092
1093                 if (bracket) {
1094                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1095                                        "the closing bracket in \"%V\" "
1096                                        "variable is missing", &var);
1097                     return NGX_CONF_ERROR;
1098                 }
1099
1100                 if (var.len == 0) {
1101                     goto invalid;
1102                 }
1103
1104                 if (ngx_strncmp(var.data, "apache_bytes_sent", 17) == 0) {
1105                     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1106                         "use \"$body_bytes_sent\" instead of "
1107                         "\"$apache_bytes_sent\"");
1108                 }
1109
1110                 for (v = ngx_http_log_vars; v->name.len; v++) {
1111
1112                     if (v->name.len == var.len
1113                         && ngx_strncmp(v->name.data, var.data, var.len) == 0)
1114                     {
1115                         op->len = v->len;
1116                         op->getlen = NULL;
1117                         op->run = v->run;
1118                         op->data = 0;
1119
1120                         goto found;
1121                     }
1122                 }
1123
1124                 if (ngx_http_log_variable_compile(cf, op, &var) != NGX_OK) {
1125                     return NGX_CONF_ERROR;
1126                 }
1127
1128                 if (flushes) {
1129
1130                     flush = ngx_array_push(flushes);
1131                     if (flush == NULL) {
1132                         return NGX_CONF_ERROR;
1133                     }
1134
1135                     *flush = op->data; /* variable index */
1136                 }
1137
1138             found:
1139
1140                 continue;
1141             }
1142
1143             i++;
1144
1145             while (i < value[s].len && value[s].data[i] != '$') {
1146                 i++;
1147             }
1148
1149             len = &value[s].data[i] - data;
1150
1151             if (len) {
1152
1153                 op->len = len;
1154                 op->getlen = NULL;
1155
1156                 if (len <= sizeof(uintptr_t)) {
1157                     op->run = ngx_http_log_copy_short;
1158                     op->data = 0;
1159
1160                     while (len--) {
1161                         op->data <<= 8;
1162                         op->data |= data[len];
1163                     }
1164
1165                 } else {
1166                     op->run = ngx_http_log_copy_long;
1167
1168                     p = ngx_pnalloc(cf->pool, len);
1169                     if (p == NULL) {
1170                         return NGX_CONF_ERROR;
1171                     }
1172
1173                     ngx_memcpy(p, data, len);
1174                     op->data = (uintptr_t) p;
1175                 }
1176             }
1177         }
1178     }
1179
1180     return NGX_CONF_OK;
1181
1182 invalid:
1183
1184     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%s\"", data);
1185
1186     return NGX_CONF_ERROR;
1187 }
1188
1189
1190 static char *
1191 ngx_http_log_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1192 {
1193     ngx_http_log_loc_conf_t *llcf = conf;
1194
1195     time_t       inactive, valid;
1196     ngx_str_t   *value, s;
1197     ngx_int_t    max, min_uses;
1198     ngx_uint_t   i;
1199
1200     if (llcf->open_file_cache != NGX_CONF_UNSET_PTR) {
1201         return "is duplicate";
1202     }
1203
1204     value = cf->args->elts;
1205
1206     max = 0;
1207     inactive = 10;
1208     valid = 60;
1209     min_uses = 1;
1210
1211     for (i = 1; i < cf->args->nelts; i++) {
1212
1213         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {
1214
1215             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
1216             if (max == NGX_ERROR) {
1217                 goto failed;
1218             }
1219
1220             continue;
1221         }
1222
1223         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {
1224
1225             s.len = value[i].len - 9;
1226             s.data = value[i].data + 9;
1227
1228             inactive = ngx_parse_time(&s, 1);
1229             if (inactive < 0) {
1230                 goto failed;
1231             }
1232
1233             continue;
1234         }
1235
1236         if (ngx_strncmp(value[i].data, "min_uses=", 9) == 0) {
1237
1238             min_uses = ngx_atoi(value[i].data + 9, value[i].len - 9);
1239             if (min_uses == NGX_ERROR) {
1240                 goto failed;
1241             }
1242
1243             continue;
1244         }
1245
1246         if (ngx_strncmp(value[i].data, "valid=", 6) == 0) {
1247
1248             s.len = value[i].len - 6;
1249             s.data = value[i].data + 6;
1250
1251             valid = ngx_parse_time(&s, 1);
1252             if (valid < 0) {
1253                 goto failed;
1254             }
1255
1256             continue;
1257         }
1258
1259         if (ngx_strcmp(value[i].data, "off") == 0) {
1260
1261             llcf->open_file_cache = NULL;
1262
1263             continue;
1264         }
1265
1266     failed:
1267
1268         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1269                            "invalid \"open_log_file_cache\" parameter \"%V\"",
1270                            &value[i]);
1271         return NGX_CONF_ERROR;
1272     }
1273
1274     if (llcf->open_file_cache == NULL) {
1275         return NGX_CONF_OK;
1276     }
1277
1278     if (max == 0) {
1279         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1280                         "\"open_log_file_cache\" must have \"max\" parameter");
1281         return NGX_CONF_ERROR;
1282     }
1283
1284     llcf->open_file_cache = ngx_open_file_cache_init(cf->pool, max, inactive);
1285
1286     if (llcf->open_file_cache) {
1287
1288         llcf->open_file_cache_valid = valid;
1289         llcf->open_file_cache_min_uses = min_uses;
1290
1291         return NGX_CONF_OK;
1292     }
1293
1294     return NGX_CONF_ERROR;
1295 }
1296
1297
1298 static ngx_int_t
1299 ngx_http_log_init(ngx_conf_t *cf)
1300 {
1301     ngx_str_t                  *value;
1302     ngx_array_t                 a;
1303     ngx_http_handler_pt        *h;
1304     ngx_http_log_fmt_t         *fmt;
1305     ngx_http_log_main_conf_t   *lmcf;
1306     ngx_http_core_main_conf_t  *cmcf;
1307
1308     lmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_log_module);
1309
1310     if (lmcf->combined_used) {
1311         if (ngx_array_init(&a, cf->pool, 1, sizeof(ngx_str_t)) != NGX_OK) {
1312             return NGX_ERROR;
1313         }
1314
1315         value = ngx_array_push(&a);
1316         if (value == NULL) {
1317             return NGX_ERROR;
1318         }
1319
1320         *value = ngx_http_combined_fmt;
1321         fmt = lmcf->formats.elts;
1322
1323         if (ngx_http_log_compile_format(cf, NULL, fmt->ops, &a, 0)
1324             != NGX_CONF_OK)
1325         {
1326             return NGX_ERROR;
1327         }
1328     }
1329
1330     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
1331
1332     h = ngx_array_push(&cmcf->phases[NGX_HTTP_LOG_PHASE].handlers);
1333     if (h == NULL) {
1334         return NGX_ERROR;
1335     }
1336
1337     *h = ngx_http_log_handler;
1338
1339     return NGX_OK;
1340 }