One Level Up Top Level

src/stream/ngx_stream_log_module.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_stream.h>

  12. #if (NGX_ZLIB)
  13. #include <zlib.h>
  14. #endif


  17. ‌typedef struct ngx_stream_log_op_s  ngx_stream_log_op_t;

  19. ‌typedef u_char *(*ngx_stream_log_op_run_pt) (ngx_stream_session_t *s,
  20.     u_char *buf, u_char *end, ngx_stream_log_op_t *op);

  22. ‌typedef size_t (*ngx_stream_log_op_getlen_pt) (ngx_stream_session_t *s,
  23.     uintptr_t data);


  26. ‌struct ngx_stream_log_op_s {
  27.     size_t                       len;
  28.     ngx_stream_log_op_getlen_pt  getlen;
  29.     ngx_stream_log_op_run_pt     run;
  30.     uintptr_t                    data;
  31. };


  34. ‌typedef struct {
  35.     ngx_str_t                    name;
  36.     ngx_array_t                 *flushes;
  37.     ngx_array_t                 *ops;        /* array of ngx_stream_log_op_t */
  38. ‌} ngx_stream_log_fmt_t;


  41. ‌typedef struct {
  42.     ngx_array_t                  formats;    /* array of ngx_stream_log_fmt_t */
  43. ‌} ngx_stream_log_main_conf_t;


  46. ‌typedef struct {
  47.     u_char                      *start;
  48.     u_char                      *pos;
  49.     u_char                      *last;

  51.     ngx_event_t                 *event;
  52.     ngx_msec_t                   flush;
  53.     ngx_int_t                    gzip;
  54. ‌} ngx_stream_log_buf_t;


  57. ‌typedef struct {
  58.     ngx_array_t                 *lengths;
  59.     ngx_array_t                 *values;
  60. ‌} ngx_stream_log_script_t;


  63. ‌typedef struct {
  64.     ngx_open_file_t             *file;
  65.     ngx_stream_log_script_t     *script;
  66.     time_t                       disk_full_time;
  67.     time_t                       error_log_time;
  68.     ngx_syslog_peer_t           *syslog_peer;
  69.     ngx_stream_log_fmt_t        *format;
  70.     ngx_stream_complex_value_t  *filter;
  71. ‌} ngx_stream_log_t;


  74. ‌typedef struct {
  75.     ngx_array_t                 *logs;       /* array of ngx_stream_log_t */

  77.     ngx_open_file_cache_t       *open_file_cache;
  78.     time_t                       open_file_cache_valid;
  79.     ngx_uint_t                   open_file_cache_min_uses;

  81.     ngx_uint_t                   off;        /* unsigned  off:1 */
  82. ‌} ngx_stream_log_srv_conf_t;


  85. ‌typedef struct {
  86.     ngx_str_t                    name;
  87.     size_t                       len;
  88.     ngx_stream_log_op_run_pt     run;
  89. ‌} ngx_stream_log_var_t;


  92. ‌#define NGX_STREAM_LOG_ESCAPE_DEFAULT  0
  93. ‌#define NGX_STREAM_LOG_ESCAPE_JSON     1
  94. ‌#define NGX_STREAM_LOG_ESCAPE_NONE     2


  97. static void ngx_stream_log_write(ngx_stream_session_t *s, ngx_stream_log_t *log,
  98.     u_char *buf, size_t len);
  99. static ssize_t ngx_stream_log_script_write(ngx_stream_session_t *s,
  100.     ngx_stream_log_script_t *script, u_char **name, u_char *buf, size_t len);

  102. #if (NGX_ZLIB)
  103. static ssize_t ngx_stream_log_gzip(ngx_fd_t fd, u_char *buf, size_t len,
  104.     ngx_int_t level, ngx_log_t *log);

  106. static void *ngx_stream_log_gzip_alloc(void *opaque, u_int items, u_int size);
  107. static void ngx_stream_log_gzip_free(void *opaque, void *address);
  108. #endif

  110. static void ngx_stream_log_flush(ngx_open_file_t *file, ngx_log_t *log);
  111. static void ngx_stream_log_flush_handler(ngx_event_t *ev);

  113. static ngx_int_t ngx_stream_log_variable_compile(ngx_conf_t *cf,
  114.     ngx_stream_log_op_t *op, ngx_str_t *value, ngx_uint_t escape);
  115. static size_t ngx_stream_log_variable_getlen(ngx_stream_session_t *s,
  116.     uintptr_t data);
  117. static u_char *ngx_stream_log_variable(ngx_stream_session_t *s, u_char *buf,
  118.     u_char *end, ngx_stream_log_op_t *op);
  119. static uintptr_t ngx_stream_log_escape(u_char *dst, u_char *src, size_t size);
  120. static size_t ngx_stream_log_json_variable_getlen(ngx_stream_session_t *s,
  121.     uintptr_t data);
  122. static u_char *ngx_stream_log_json_variable(ngx_stream_session_t *s,
  123.     u_char *buf, u_char *end, ngx_stream_log_op_t *op);
  124. static size_t ngx_stream_log_unescaped_variable_getlen(ngx_stream_session_t *s,
  125.     uintptr_t data);
  126. static u_char *ngx_stream_log_unescaped_variable(ngx_stream_session_t *s,
  127.     u_char *buf, u_char *end, ngx_stream_log_op_t *op);

  129. static ngx_int_t ngx_stream_log_check_length(ngx_stream_session_t *s,
  130.     u_char *buf, u_char *end, size_t len);


  133. static void *ngx_stream_log_create_main_conf(ngx_conf_t *cf);
  134. static void *ngx_stream_log_create_srv_conf(ngx_conf_t *cf);
  135. static char *ngx_stream_log_merge_srv_conf(ngx_conf_t *cf, void *parent,
  136.     void *child);
  137. static char *ngx_stream_log_set_log(ngx_conf_t *cf, ngx_command_t *cmd,
  138.     void *conf);
  139. static char *ngx_stream_log_set_format(ngx_conf_t *cf, ngx_command_t *cmd,
  140.     void *conf);
  141. static char *ngx_stream_log_compile_format(ngx_conf_t *cf,
  142.     ngx_array_t *flushes, ngx_array_t *ops, ngx_array_t *args, ngx_uint_t s);
  143. static char *ngx_stream_log_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  144.     void *conf);
  145. static ngx_int_t ngx_stream_log_init(ngx_conf_t *cf);


  148. ‌static ngx_command_t  ngx_stream_log_commands[] = {

  150.     { ngx_string("log_format"),
  151.       NGX_STREAM_MAIN_CONF|NGX_CONF_2MORE,
  152.       ngx_stream_log_set_format,
  153.       NGX_STREAM_MAIN_CONF_OFFSET,
  154.       0,
  155.       NULL },

  157.     { ngx_string("access_log"),
  158.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  159.       ngx_stream_log_set_log,
  160.       NGX_STREAM_SRV_CONF_OFFSET,
  161.       0,
  162.       NULL },

  164.     { ngx_string("open_log_file_cache"),
  165.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1234,
  166.       ngx_stream_log_open_file_cache,
  167.       NGX_STREAM_SRV_CONF_OFFSET,
  168.       0,
  169.       NULL },

  171.       ngx_null_command
  172. };


  175. ‌static ngx_stream_module_t  ngx_stream_log_module_ctx = {
  176.     NULL,                                  /* preconfiguration */
  177.     ngx_stream_log_init,                   /* postconfiguration */

  179.     ngx_stream_log_create_main_conf,       /* create main configuration */
  180.     NULL,                                  /* init main configuration */

  182.     ngx_stream_log_create_srv_conf,        /* create server configuration */
  183.     ngx_stream_log_merge_srv_conf          /* merge server configuration */
  184. };


  187. ‌ngx_module_t  ngx_stream_log_module = {
  188.     NGX_MODULE_V1,
  189.     &ngx_stream_log_module_ctx,            /* module context */
  190.     ngx_stream_log_commands,               /* module directives */
  191.     NGX_STREAM_MODULE,                     /* module type */
  192.     NULL,                                  /* init master */
  193.     NULL,                                  /* init module */
  194.     NULL,                                  /* init process */
  195.     NULL,                                  /* init thread */
  196.     NULL,                                  /* exit thread */
  197.     NULL,                                  /* exit process */
  198.     NULL,                                  /* exit master */
  199.     NGX_MODULE_V1_PADDING
  200. };


  203. static ngx_int_t
  204. ‌ngx_stream_log_handler(ngx_stream_session_t *s)
  205. {
  206.     u_char                     *line, *p, *end;
  207.     size_t                      len, size;
  208.     ssize_t                     n;
  209.     ngx_str_t                   val;
  210.     ngx_uint_t                  i, l;
  211.     ngx_stream_log_t           *log;
  212.     ngx_stream_log_op_t        *op;
  213.     ngx_stream_log_buf_t       *buffer;
  214.     ngx_stream_log_srv_conf_t  *lscf;

  216.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  217.                    "stream log handler");

  219.     lscf = ngx_stream_get_module_srv_conf(s, ngx_stream_log_module);

  221.     if (lscf->off || lscf->logs == NULL) {
  222.         return NGX_OK;
  223.     }

  225.     log = lscf->logs->elts;
  226.     for (l = 0; l < lscf->logs->nelts; l++) {

  228.         if (log[l].filter) {
  229.             if (ngx_stream_complex_value(s, log[l].filter, &val) != NGX_OK) {
  230.                 return NGX_ERROR;
  231.             }

  233.             if (val.len == 0 || (val.len == 1 && val.data[0] == '0')) {
  234.                 continue;
  235.             }
  236.         }

  238.         if (ngx_time() == log[l].disk_full_time) {

  240.             /*
  241.              * on FreeBSD writing to a full filesystem with enabled softupdates
  242.              * may block process for much longer time than writing to non-full
  243.              * filesystem, so we skip writing to a log for one second
  244.              */

  246.             continue;
  247.         }

  249.         ngx_stream_script_flush_no_cacheable_variables(s,
  250.                                                        log[l].format->flushes);

  252.         len = 0;
  253.         op = log[l].format->ops->elts;
  254.         for (i = 0; i < log[l].format->ops->nelts; i++) {
  255.             if (op[i].len == 0) {
  256.                 len += op[i].getlen(s, op[i].data);

  258.             } else {
  259.                 len += op[i].len;
  260.             }
  261.         }

  263.         len += NGX_LINEFEED_SIZE;

  265.         if (log[l].syslog_peer) {

  267.             /* length of syslog's PRI and HEADER message parts */
  268.             len += sizeof("<255>Jan 01 00:00:00 ") - 1
  269.                    + ngx_cycle->hostname.len + 1
  270.                    + log[l].syslog_peer->tag.len + 2;

  272.             goto alloc_line;
  273.         }

  275.         buffer = log[l].file ? log[l].file->data : NULL;

  277.         if (buffer) {

  279.             if (len > (size_t) (buffer->last - buffer->pos)) {

  281.                 ngx_stream_log_write(s, &log[l], buffer->start,
  282.                                      buffer->pos - buffer->start);

  284.                 buffer->pos = buffer->start;
  285.             }

  287.             if (len <= (size_t) (buffer->last - buffer->pos)) {

  289.                 p = buffer->pos;
  290.                 end = p + len - NGX_LINEFEED_SIZE;

  292.                 if (buffer->event && p == buffer->start) {
  293.                     ngx_add_timer(buffer->event, buffer->flush);
  294.                 }

  296.                 for (i = 0; i < log[l].format->ops->nelts && p; i++) {
  297.                     p = op[i].run(s, p, end, &op[i]);
  298.                 }

  300.                 if (p == NULL) {
  301.                     return NGX_ERROR;
  302.                 }

  304.                 ngx_linefeed(p);

  306.                 buffer->pos = p;

  308.                 continue;
  309.             }

  311.             if (buffer->event && buffer->event->timer_set) {
  312.                 ngx_del_timer(buffer->event);
  313.             }
  314.         }

  316.     alloc_line:

  318.         line = ngx_pnalloc(s->connection->pool, len);
  319.         if (line == NULL) {
  320.             return NGX_ERROR;
  321.         }

  323.         p = line;
  324.         end = p + len - NGX_LINEFEED_SIZE;

  326.         if (log[l].syslog_peer) {
  327.             p = ngx_syslog_add_header(log[l].syslog_peer, line);
  328.         }

  330.         for (i = 0; i < log[l].format->ops->nelts && p; i++) {
  331.             p = op[i].run(s, p, end, &op[i]);
  332.         }

  334.         if (p == NULL) {
  335.             return NGX_ERROR;
  336.         }

  338.         if (log[l].syslog_peer) {

  340.             size = p - line;

  342.             n = ngx_syslog_send(log[l].syslog_peer, line, size);

  344.             if (n < 0) {
  345.                 ngx_log_error(NGX_LOG_WARN, s->connection->log, 0,
  346.                               "send() to syslog failed");

  348.             } else if ((size_t) n != size) {
  349.                 ngx_log_error(NGX_LOG_WARN, s->connection->log, 0,
  350.                               "send() to syslog has written only %z of %uz",
  351.                               n, size);
  352.             }

  354.             continue;
  355.         }

  357.         ngx_linefeed(p);

  359.         ngx_stream_log_write(s, &log[l], line, p - line);
  360.     }

  362.     return NGX_OK;
  363. }


  366. static void
  367. ‌ngx_stream_log_write(ngx_stream_session_t *s, ngx_stream_log_t *log,
  368.     u_char *buf, size_t len)
  369. {
  370.     u_char                *name;
  371.     time_t                 now;
  372.     ssize_t                n;
  373.     ngx_err_t              err;
  374. #if (NGX_ZLIB)
  375.     ngx_stream_log_buf_t  *buffer;
  376. #endif

  378.     if (log->script == NULL) {
  379.         name = log->file->name.data;

  381. #if (NGX_ZLIB)
  382.         buffer = log->file->data;

  384.         if (buffer && buffer->gzip) {
  385.             n = ngx_stream_log_gzip(log->file->fd, buf, len, buffer->gzip,
  386.                                     s->connection->log);
  387.         } else {
  388.             n = ngx_write_fd(log->file->fd, buf, len);
  389.         }
  390. #else
  391.         n = ngx_write_fd(log->file->fd, buf, len);
  392. #endif

  394.     } else {
  395.         name = NULL;
  396.         n = ngx_stream_log_script_write(s, log->script, &name, buf, len);
  397.     }

  399.     if (n == (ssize_t) len) {
  400.         return;
  401.     }

  403.     now = ngx_time();

  405.     if (n == -1) {
  406.         err = ngx_errno;

  408.         if (err == NGX_ENOSPC) {
  409.             log->disk_full_time = now;
  410.         }

  412.         if (now - log->error_log_time > 59) {
  413.             ngx_log_error(NGX_LOG_ALERT, s->connection->log, err,
  414.                           ngx_write_fd_n " to \"%s\" failed", name);

  416.             log->error_log_time = now;
  417.         }

  419.         return;
  420.     }

  422.     if (now - log->error_log_time > 59) {
  423.         ngx_log_error(NGX_LOG_ALERT, s->connection->log, 0,
  424.                       ngx_write_fd_n " to \"%s\" was incomplete: %z of %uz",
  425.                       name, n, len);

  427.         log->error_log_time = now;
  428.     }
  429. }


  432. static ssize_t
  433. ‌ngx_stream_log_script_write(ngx_stream_session_t *s,
  434.     ngx_stream_log_script_t *script, u_char **name, u_char *buf, size_t len)
  435. {
  436.     ssize_t                     n;
  437.     ngx_str_t                   log;
  438.     ngx_open_file_info_t        of;
  439.     ngx_stream_log_srv_conf_t  *lscf;

  441.     if (ngx_stream_script_run(s, &log, script->lengths->elts, 1,
  442.                               script->values->elts)
  443.         == NULL)
  444.     {
  445.         /* simulate successful logging */
  446.         return len;
  447.     }

  449.     log.data[log.len - 1] = '\0';
  450.     *name = log.data;

  452.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  453.                    "stream log \"%s\"", log.data);

  455.     lscf = ngx_stream_get_module_srv_conf(s, ngx_stream_log_module);

  457.     ngx_memzero(&of, sizeof(ngx_open_file_info_t));

  459.     of.log = 1;
  460.     of.valid = lscf->open_file_cache_valid;
  461.     of.min_uses = lscf->open_file_cache_min_uses;
  462.     of.directio = NGX_OPEN_FILE_DIRECTIO_OFF;

  464.     if (ngx_open_cached_file(lscf->open_file_cache, &log, &of,
  465.                              s->connection->pool)
  466.         != NGX_OK)
  467.     {
  468.         if (of.err == 0) {
  469.             /* simulate successful logging */
  470.             return len;
  471.         }

  473.         ngx_log_error(NGX_LOG_CRIT, s->connection->log, ngx_errno,
  474.                       "%s \"%s\" failed", of.failed, log.data);
  475.         /* simulate successful logging */
  476.         return len;
  477.     }

  479.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  480.                    "stream log #%d", of.fd);

  482.     n = ngx_write_fd(of.fd, buf, len);

  484.     return n;
  485. }


  488. #if (NGX_ZLIB)

  490. static ssize_t
  491. ‌ngx_stream_log_gzip(ngx_fd_t fd, u_char *buf, size_t len, ngx_int_t level,
  492.     ngx_log_t *log)
  493. {
  494.     int          rc, wbits, memlevel;
  495.     u_char      *out;
  496.     size_t       size;
  497.     ssize_t      n;
  498.     z_stream     zstream;
  499.     ngx_err_t    err;
  500.     ngx_pool_t  *pool;

  502.     wbits = MAX_WBITS;
  503.     memlevel = MAX_MEM_LEVEL - 1;

  505.     while ((ssize_t) len < ((1 << (wbits - 1)) - 262)) {
  506.         wbits--;
  507.         memlevel--;
  508.     }

  510.     /*
  511.      * This is a formula from deflateBound() for conservative upper bound of
  512.      * compressed data plus 18 bytes of gzip wrapper.
  513.      */

  515.     size = len + ((len + 7) >> 3) + ((len + 63) >> 6) + 5 + 18;

  517.     ngx_memzero(&zstream, sizeof(z_stream));

  519.     pool = ngx_create_pool(256, log);
  520.     if (pool == NULL) {
  521.         /* simulate successful logging */
  522.         return len;
  523.     }

  525.     pool->log = log;

  527.     zstream.zalloc = ngx_stream_log_gzip_alloc;
  528.     zstream.zfree = ngx_stream_log_gzip_free;
  529.     zstream.opaque = pool;

  531.     out = ngx_pnalloc(pool, size);
  532.     if (out == NULL) {
  533.         goto done;
  534.     }

  536.     zstream.next_in = buf;
  537.     zstream.avail_in = len;
  538.     zstream.next_out = out;
  539.     zstream.avail_out = size;

  541.     rc = deflateInit2(&zstream, (int) level, Z_DEFLATED, wbits + 16, memlevel,
  542.                       Z_DEFAULT_STRATEGY);

  544.     if (rc != Z_OK) {
  545.         ngx_log_error(NGX_LOG_ALERT, log, 0, "deflateInit2() failed: %d", rc);
  546.         goto done;
  547.     }

  549.     ngx_log_debug4(NGX_LOG_DEBUG_STREAM, log, 0,
  550.                    "deflate in: ni:%p no:%p ai:%ud ao:%ud",
  551.                    zstream.next_in, zstream.next_out,
  552.                    zstream.avail_in, zstream.avail_out);

  554.     rc = deflate(&zstream, Z_FINISH);

  556.     if (rc != Z_STREAM_END) {
  557.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  558.                       "deflate(Z_FINISH) failed: %d", rc);
  559.         goto done;
  560.     }

  562.     ngx_log_debug5(NGX_LOG_DEBUG_STREAM, log, 0,
  563.                    "deflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
  564.                    zstream.next_in, zstream.next_out,
  565.                    zstream.avail_in, zstream.avail_out,
  566.                    rc);

  568.     size -= zstream.avail_out;

  570.     rc = deflateEnd(&zstream);

  572.     if (rc != Z_OK) {
  573.         ngx_log_error(NGX_LOG_ALERT, log, 0, "deflateEnd() failed: %d", rc);
  574.         goto done;
  575.     }

  577.     n = ngx_write_fd(fd, out, size);

  579.     if (n != (ssize_t) size) {
  580.         err = (n == -1) ? ngx_errno : 0;

  582.         ngx_destroy_pool(pool);

  584.         ngx_set_errno(err);
  585.         return -1;
  586.     }

  588. done:

  590.     ngx_destroy_pool(pool);

  592.     /* simulate successful logging */
  593.     return len;
  594. }


  597. static void *
  598. ‌ngx_stream_log_gzip_alloc(void *opaque, u_int items, u_int size)
  599. {
  600.     ngx_pool_t *pool = opaque;

  602.     ngx_log_debug2(NGX_LOG_DEBUG_STREAM, pool->log, 0,
  603.                    "gzip alloc: n:%ud s:%ud", items, size);

  605.     return ngx_palloc(pool, items * size);
  606. }


  609. static void
  610. ‌ngx_stream_log_gzip_free(void *opaque, void *address)
  611. {
  612. #if 0
  613.     ngx_pool_t *pool = opaque;

  615.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, pool->log, 0,
  616.                    "gzip free: %p", address);
  617. #endif
  618. }

  620. #endif


  623. static void
  624. ‌ngx_stream_log_flush(ngx_open_file_t *file, ngx_log_t *log)
  625. {
  626.     size_t                 len;
  627.     ssize_t                n;
  628.     ngx_stream_log_buf_t  *buffer;

  630.     buffer = file->data;

  632.     len = buffer->pos - buffer->start;

  634.     if (len == 0) {
  635.         return;
  636.     }

  638. #if (NGX_ZLIB)
  639.     if (buffer->gzip) {
  640.         n = ngx_stream_log_gzip(file->fd, buffer->start, len, buffer->gzip,
  641.                                 log);
  642.     } else {
  643.         n = ngx_write_fd(file->fd, buffer->start, len);
  644.     }
  645. #else
  646.     n = ngx_write_fd(file->fd, buffer->start, len);
  647. #endif

  649.     if (n == -1) {
  650.         ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
  651.                       ngx_write_fd_n " to \"%s\" failed",
  652.                       file->name.data);

  654.     } else if ((size_t) n != len) {
  655.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  656.                       ngx_write_fd_n " to \"%s\" was incomplete: %z of %uz",
  657.                       file->name.data, n, len);
  658.     }

  660.     buffer->pos = buffer->start;

  662.     if (buffer->event && buffer->event->timer_set) {
  663.         ngx_del_timer(buffer->event);
  664.     }
  665. }


  668. static void
  669. ‌ngx_stream_log_flush_handler(ngx_event_t *ev)
  670. {
  671.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  672.                    "stream log buffer flush handler");

  674.     ngx_stream_log_flush(ev->data, ev->log);
  675. }


  678. static u_char *
  679. ‌ngx_stream_log_copy_short(ngx_stream_session_t *s, u_char *buf, u_char *end,
  680.     ngx_stream_log_op_t *op)
  681. {
  682.     size_t     len;
  683.     uintptr_t  data;

  685.     len = op->len;
  686.     data = op->data;

  688.     if (ngx_stream_log_check_length(s, buf, end, len) != NGX_OK) {
  689.         return NULL;
  690.     }

  692.     while (len--) {
  693.         *buf++ = (u_char) (data & 0xff);
  694.         data >>= 8;
  695.     }

  697.     return buf;
  698. }


  701. static u_char *
  702. ‌ngx_stream_log_copy_long(ngx_stream_session_t *s, u_char *buf, u_char *end,
  703.     ngx_stream_log_op_t *op)
  704. {
  705.     if (ngx_stream_log_check_length(s, buf, end, op->len) != NGX_OK) {
  706.         return NULL;
  707.     }

  709.     return ngx_cpymem(buf, (u_char *) op->data, op->len);
  710. }


  713. static ngx_int_t
  714. ‌ngx_stream_log_variable_compile(ngx_conf_t *cf, ngx_stream_log_op_t *op,
  715.     ngx_str_t *value, ngx_uint_t escape)
  716. {
  717.     ngx_int_t  index;

  719.     index = ngx_stream_get_variable_index(cf, value);
  720.     if (index == NGX_ERROR) {
  721.         return NGX_ERROR;
  722.     }

  724.     op->len = 0;

  726.     switch (escape) {
  727.     case NGX_STREAM_LOG_ESCAPE_JSON:
  728.         op->getlen = ngx_stream_log_json_variable_getlen;
  729.         op->run = ngx_stream_log_json_variable;
  730.         break;

  732.     case NGX_STREAM_LOG_ESCAPE_NONE:
  733.         op->getlen = ngx_stream_log_unescaped_variable_getlen;
  734.         op->run = ngx_stream_log_unescaped_variable;
  735.         break;

  737.     default: /* NGX_STREAM_LOG_ESCAPE_DEFAULT */
  738.         op->getlen = ngx_stream_log_variable_getlen;
  739.         op->run = ngx_stream_log_variable;
  740.     }

  742.     op->data = index;

  744.     return NGX_OK;
  745. }


  748. static size_t
  749. ‌ngx_stream_log_variable_getlen(ngx_stream_session_t *s, uintptr_t data)
  750. {
  751.     uintptr_t                     len;
  752.     ngx_stream_variable_value_t  *value;

  754.     value = ngx_stream_get_indexed_variable(s, data);

  756.     if (value == NULL || value->not_found) {
  757.         return 1;
  758.     }

  760.     len = ngx_stream_log_escape(NULL, value->data, value->len);

  762.     value->escape = len ? 1 : 0;

  764.     return value->len + len * 3;
  765. }


  768. static u_char *
  769. ‌ngx_stream_log_variable(ngx_stream_session_t *s, u_char *buf, u_char *end,
  770.     ngx_stream_log_op_t *op)
  771. {
  772.     uintptr_t                     len;
  773.     ngx_stream_variable_value_t  *value;

  775.     value = ngx_stream_get_indexed_variable(s, op->data);

  777.     if (value == NULL || value->not_found) {
  778.         if (ngx_stream_log_check_length(s, buf, end, 1) != NGX_OK) {
  779.             return NULL;
  780.         }

  782.         *buf = '-';
  783.         return buf + 1;
  784.     }

  786.     if (value->escape == 0) {
  787.         if (ngx_stream_log_check_length(s, buf, end, value->len) != NGX_OK) {
  788.             return NULL;
  789.         }

  791.         return ngx_cpymem(buf, value->data, value->len);

  793.     } else {
  794.         len = ngx_stream_log_escape(NULL, value->data, value->len);

  796.         if (ngx_stream_log_check_length(s, buf, end, value->len + len * 3)
  797.             != NGX_OK)
  798.         {
  799.             return NULL;
  800.         }

  802.         return (u_char *) ngx_stream_log_escape(buf, value->data, value->len);
  803.     }
  804. }


  807. static uintptr_t
  808. ‌ngx_stream_log_escape(u_char *dst, u_char *src, size_t size)
  809. {
  810.     ngx_uint_t      n;
  811.     static u_char   hex[] = "0123456789ABCDEF";

  813.     static uint32_t   escape[] = {
  814.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */

  816.                     /* ?>=< ;:98 7654 3210  /.-, +*)( '&%$ #"!  */
  817.         0x00000004, /* 0000 0000 0000 0000  0000 0000 0000 0100 */

  819.                     /* _^]\ [ZYX WVUT SRQP  ONML KJIH GFED CBA@ */
  820.         0x10000000, /* 0001 0000 0000 0000  0000 0000 0000 0000 */

  822.                     /*  ~}| {zyx wvut srqp  onml kjih gfed cba` */
  823.         0x80000000, /* 1000 0000 0000 0000  0000 0000 0000 0000 */

  825.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  826.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  827.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  828.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  829.     };


  832.     if (dst == NULL) {

  834.         /* find the number of the characters to be escaped */

  836.         n = 0;

  838.         while (size) {
  839.             if (escape[*src >> 5] & (1U << (*src & 0x1f))) {
  840.                 n++;
  841.             }
  842.             src++;
  843.             size--;
  844.         }

  846.         return (uintptr_t) n;
  847.     }

  849.     while (size) {
  850.         if (escape[*src >> 5] & (1U << (*src & 0x1f))) {
  851.             *dst++ = '\\';
  852.             *dst++ = 'x';
  853.             *dst++ = hex[*src >> 4];
  854.             *dst++ = hex[*src & 0xf];
  855.             src++;

  857.         } else {
  858.             *dst++ = *src++;
  859.         }
  860.         size--;
  861.     }

  863.     return (uintptr_t) dst;
  864. }


  867. static size_t
  868. ‌ngx_stream_log_json_variable_getlen(ngx_stream_session_t *s, uintptr_t data)
  869. {
  870.     uintptr_t                     len;
  871.     ngx_stream_variable_value_t  *value;

  873.     value = ngx_stream_get_indexed_variable(s, data);

  875.     if (value == NULL || value->not_found) {
  876.         return 0;
  877.     }

  879.     len = ngx_escape_json(NULL, value->data, value->len);

  881.     value->escape = len ? 1 : 0;

  883.     return value->len + len;
  884. }


  887. static u_char *
  888. ‌ngx_stream_log_json_variable(ngx_stream_session_t *s, u_char *buf, u_char *end,
  889.     ngx_stream_log_op_t *op)
  890. {
  891.     uintptr_t                     len;
  892.     ngx_stream_variable_value_t  *value;

  894.     value = ngx_stream_get_indexed_variable(s, op->data);

  896.     if (value == NULL || value->not_found) {
  897.         return buf;
  898.     }

  900.     if (value->escape == 0) {
  901.         if (ngx_stream_log_check_length(s, buf, end, value->len) != NGX_OK) {
  902.             return NULL;
  903.         }

  905.         return ngx_cpymem(buf, value->data, value->len);

  907.     } else {
  908.         len = ngx_escape_json(NULL, value->data, value->len);

  910.         if (ngx_stream_log_check_length(s, buf, end, value->len + len)
  911.             != NGX_OK)
  912.         {
  913.             return NULL;
  914.         }

  916.         return (u_char *) ngx_escape_json(buf, value->data, value->len);
  917.     }
  918. }


  921. static size_t
  922. ‌ngx_stream_log_unescaped_variable_getlen(ngx_stream_session_t *s,
  923.     uintptr_t data)
  924. {
  925.     ngx_stream_variable_value_t  *value;

  927.     value = ngx_stream_get_indexed_variable(s, data);

  929.     if (value == NULL || value->not_found) {
  930.         return 0;
  931.     }

  933.     value->escape = 0;

  935.     return value->len;
  936. }


  939. static u_char *
  940. ‌ngx_stream_log_unescaped_variable(ngx_stream_session_t *s, u_char *buf,
  941.     u_char *end, ngx_stream_log_op_t *op)
  942. {
  943.     ngx_stream_variable_value_t  *value;

  945.     value = ngx_stream_get_indexed_variable(s, op->data);

  947.     if (value == NULL || value->not_found) {
  948.         return buf;
  949.     }

  951.     if (ngx_stream_log_check_length(s, buf, end, value->len) != NGX_OK) {
  952.         return NULL;
  953.     }

  955.     return ngx_cpymem(buf, value->data, value->len);
  956. }


  959. static ngx_int_t
  960. ‌ngx_stream_log_check_length(ngx_stream_session_t *s, u_char *buf, u_char *end,
  961.     size_t len)
  962. {
  963.     if (end - buf < (ssize_t) len) {
  964.         ngx_log_error(NGX_LOG_ALERT, s->connection->log, 0,
  965.                       "no buffer space in log script copy");
  966.         return NGX_ERROR;
  967.     }

  969.     return NGX_OK;
  970. }


  973. static void *
  974. ‌ngx_stream_log_create_main_conf(ngx_conf_t *cf)
  975. {
  976.     ngx_stream_log_main_conf_t  *conf;

  978.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_log_main_conf_t));
  979.     if (conf == NULL) {
  980.         return NULL;
  981.     }

  983.     if (ngx_array_init(&conf->formats, cf->pool, 4,
  984.                        sizeof(ngx_stream_log_fmt_t))
  985.         != NGX_OK)
  986.     {
  987.         return NULL;
  988.     }

  990.     return conf;
  991. }


  994. static void *
  995. ‌ngx_stream_log_create_srv_conf(ngx_conf_t *cf)
  996. {
  997.     ngx_stream_log_srv_conf_t  *conf;

  999.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_log_srv_conf_t));
  1000.     if (conf == NULL) {
  1001.         return NULL;
  1002.     }

  1004.     conf->open_file_cache = NGX_CONF_UNSET_PTR;

  1006.     return conf;
  1007. }


  1010. static char *
  1011. ‌ngx_stream_log_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  1012. {
  1013.     ngx_stream_log_srv_conf_t *prev = parent;
  1014.     ngx_stream_log_srv_conf_t *conf = child;

  1016.     if (conf->open_file_cache == NGX_CONF_UNSET_PTR) {

  1018.         conf->open_file_cache = prev->open_file_cache;
  1019.         conf->open_file_cache_valid = prev->open_file_cache_valid;
  1020.         conf->open_file_cache_min_uses = prev->open_file_cache_min_uses;

  1022.         if (conf->open_file_cache == NGX_CONF_UNSET_PTR) {
  1023.             conf->open_file_cache = NULL;
  1024.         }
  1025.     }

  1027.     if (conf->logs || conf->off) {
  1028.         return NGX_CONF_OK;
  1029.     }

  1031.     conf->logs = prev->logs;
  1032.     conf->off = prev->off;

  1034.     return NGX_CONF_OK;
  1035. }


  1038. static char *
  1039. ‌ngx_stream_log_set_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1040. {
  1041.     ngx_stream_log_srv_conf_t *lscf = conf;

  1043.     ssize_t                              size;
  1044.     ngx_int_t                            gzip;
  1045.     ngx_uint_t                           i, n;
  1046.     ngx_msec_t                           flush;
  1047.     ngx_str_t                           *value, name, s;
  1048.     ngx_stream_log_t                    *log;
  1049.     ngx_syslog_peer_t                   *peer;
  1050.     ngx_stream_log_buf_t                *buffer;
  1051.     ngx_stream_log_fmt_t                *fmt;
  1052.     ngx_stream_script_compile_t          sc;
  1053.     ngx_stream_log_main_conf_t          *lmcf;
  1054.     ngx_stream_compile_complex_value_t   ccv;

  1056.     value = cf->args->elts;

  1058.     if (ngx_strcmp(value[1].data, "off") == 0) {
  1059.         lscf->off = 1;
  1060.         if (cf->args->nelts == 2) {
  1061.             return NGX_CONF_OK;
  1062.         }

  1064.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1065.                            "invalid parameter \"%V\"", &value[2]);
  1066.         return NGX_CONF_ERROR;
  1067.     }

  1069.     if (lscf->logs == NULL) {
  1070.         lscf->logs = ngx_array_create(cf->pool, 2, sizeof(ngx_stream_log_t));
  1071.         if (lscf->logs == NULL) {
  1072.             return NGX_CONF_ERROR;
  1073.         }
  1074.     }

  1076.     lmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_log_module);

  1078.     log = ngx_array_push(lscf->logs);
  1079.     if (log == NULL) {
  1080.         return NGX_CONF_ERROR;
  1081.     }

  1083.     ngx_memzero(log, sizeof(ngx_stream_log_t));


  1086.     if (ngx_strncmp(value[1].data, "syslog:", 7) == 0) {

  1088.         peer = ngx_pcalloc(cf->pool, sizeof(ngx_syslog_peer_t));
  1089.         if (peer == NULL) {
  1090.             return NGX_CONF_ERROR;
  1091.         }

  1093.         if (ngx_syslog_process_conf(cf, peer) != NGX_CONF_OK) {
  1094.             return NGX_CONF_ERROR;
  1095.         }

  1097.         log->syslog_peer = peer;

  1099.         goto process_formats;
  1100.     }

  1102.     n = ngx_stream_script_variables_count(&value[1]);

  1104.     if (n == 0) {
  1105.         log->file = ngx_conf_open_file(cf->cycle, &value[1]);
  1106.         if (log->file == NULL) {
  1107.             return NGX_CONF_ERROR;
  1108.         }

  1110.     } else {
  1111.         if (ngx_conf_full_name(cf->cycle, &value[1], 0) != NGX_OK) {
  1112.             return NGX_CONF_ERROR;
  1113.         }

  1115.         log->script = ngx_pcalloc(cf->pool, sizeof(ngx_stream_log_script_t));
  1116.         if (log->script == NULL) {
  1117.             return NGX_CONF_ERROR;
  1118.         }

  1120.         ngx_memzero(&sc, sizeof(ngx_stream_script_compile_t));

  1122.         sc.cf = cf;
  1123.         sc.source = &value[1];
  1124.         sc.lengths = &log->script->lengths;
  1125.         sc.values = &log->script->values;
  1126.         sc.variables = n;
  1127.         sc.complete_lengths = 1;
  1128.         sc.complete_values = 1;

  1130.         if (ngx_stream_script_compile(&sc) != NGX_OK) {
  1131.             return NGX_CONF_ERROR;
  1132.         }
  1133.     }

  1135. process_formats:

  1137.     if (cf->args->nelts >= 3) {
  1138.         name = value[2];

  1140.     } else {
  1141.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1142.                            "log format is not specified");
  1143.         return NGX_CONF_ERROR;
  1144.     }

  1146.     fmt = lmcf->formats.elts;
  1147.     for (i = 0; i < lmcf->formats.nelts; i++) {
  1148.         if (fmt[i].name.len == name.len
  1149.             && ngx_strcasecmp(fmt[i].name.data, name.data) == 0)
  1150.         {
  1151.             log->format = &fmt[i];
  1152.             break;
  1153.         }
  1154.     }

  1156.     if (log->format == NULL) {
  1157.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1158.                            "unknown log format \"%V\"", &name);
  1159.         return NGX_CONF_ERROR;
  1160.     }

  1162.     size = 0;
  1163.     flush = 0;
  1164.     gzip = 0;

  1166.     for (i = 3; i < cf->args->nelts; i++) {

  1168.         if (ngx_strncmp(value[i].data, "buffer=", 7) == 0) {
  1169.             s.len = value[i].len - 7;
  1170.             s.data = value[i].data + 7;

  1172.             size = ngx_parse_size(&s);

  1174.             if (size == NGX_ERROR || size == 0) {
  1175.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1176.                                    "invalid buffer size \"%V\"", &s);
  1177.                 return NGX_CONF_ERROR;
  1178.             }

  1180.             continue;
  1181.         }

  1183.         if (ngx_strncmp(value[i].data, "flush=", 6) == 0) {
  1184.             s.len = value[i].len - 6;
  1185.             s.data = value[i].data + 6;

  1187.             flush = ngx_parse_time(&s, 0);

  1189.             if (flush == (ngx_msec_t) NGX_ERROR || flush == 0) {
  1190.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1191.                                    "invalid flush time \"%V\"", &s);
  1192.                 return NGX_CONF_ERROR;
  1193.             }

  1195.             continue;
  1196.         }

  1198.         if (ngx_strncmp(value[i].data, "gzip", 4) == 0
  1199.             && (value[i].len == 4 || value[i].data[4] == '='))
  1200.         {
  1201. #if (NGX_ZLIB)
  1202.             if (size == 0) {
  1203.                 size = 64 * 1024;
  1204.             }

  1206.             if (value[i].len == 4) {
  1207.                 gzip = Z_BEST_SPEED;
  1208.                 continue;
  1209.             }

  1211.             s.len = value[i].len - 5;
  1212.             s.data = value[i].data + 5;

  1214.             gzip = ngx_atoi(s.data, s.len);

  1216.             if (gzip < 1 || gzip > 9) {
  1217.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1218.                                    "invalid compression level \"%V\"", &s);
  1219.                 return NGX_CONF_ERROR;
  1220.             }

  1222.             continue;

  1224. #else
  1225.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1226.                                "nginx was built without zlib support");
  1227.             return NGX_CONF_ERROR;
  1228. #endif
  1229.         }

  1231.         if (ngx_strncmp(value[i].data, "if=", 3) == 0) {
  1232.             s.len = value[i].len - 3;
  1233.             s.data = value[i].data + 3;

  1235.             ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

  1237.             ccv.cf = cf;
  1238.             ccv.value = &s;
  1239.             ccv.complex_value = ngx_palloc(cf->pool,
  1240.                                            sizeof(ngx_stream_complex_value_t));
  1241.             if (ccv.complex_value == NULL) {
  1242.                 return NGX_CONF_ERROR;
  1243.             }

  1245.             if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1246.                 return NGX_CONF_ERROR;
  1247.             }

  1249.             log->filter = ccv.complex_value;

  1251.             continue;
  1252.         }

  1254.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1255.                            "invalid parameter \"%V\"", &value[i]);
  1256.         return NGX_CONF_ERROR;
  1257.     }

  1259.     if (flush && size == 0) {
  1260.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1261.                            "no buffer is defined for access_log \"%V\"",
  1262.                            &value[1]);
  1263.         return NGX_CONF_ERROR;
  1264.     }

  1266.     if (size) {

  1268.         if (log->script) {
  1269.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1270.                                "buffered logs cannot have variables in name");
  1271.             return NGX_CONF_ERROR;
  1272.         }

  1274.         if (log->syslog_peer) {
  1275.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1276.                                "logs to syslog cannot be buffered");
  1277.             return NGX_CONF_ERROR;
  1278.         }

  1280.         if (log->file->data) {
  1281.             buffer = log->file->data;

  1283.             if (buffer->last - buffer->start != size
  1284.                 || buffer->flush != flush
  1285.                 || buffer->gzip != gzip)
  1286.             {
  1287.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1288.                                    "access_log \"%V\" already defined "
  1289.                                    "with conflicting parameters",
  1290.                                    &value[1]);
  1291.                 return NGX_CONF_ERROR;
  1292.             }

  1294.             return NGX_CONF_OK;
  1295.         }

  1297.         buffer = ngx_pcalloc(cf->pool, sizeof(ngx_stream_log_buf_t));
  1298.         if (buffer == NULL) {
  1299.             return NGX_CONF_ERROR;
  1300.         }

  1302.         buffer->start = ngx_pnalloc(cf->pool, size);
  1303.         if (buffer->start == NULL) {
  1304.             return NGX_CONF_ERROR;
  1305.         }

  1307.         buffer->pos = buffer->start;
  1308.         buffer->last = buffer->start + size;

  1310.         if (flush) {
  1311.             buffer->event = ngx_pcalloc(cf->pool, sizeof(ngx_event_t));
  1312.             if (buffer->event == NULL) {
  1313.                 return NGX_CONF_ERROR;
  1314.             }

  1316.             buffer->event->data = log->file;
  1317.             buffer->event->handler = ngx_stream_log_flush_handler;
  1318.             buffer->event->log = &cf->cycle->new_log;
  1319.             buffer->event->cancelable = 1;

  1321.             buffer->flush = flush;
  1322.         }

  1324.         buffer->gzip = gzip;

  1326.         log->file->flush = ngx_stream_log_flush;
  1327.         log->file->data = buffer;
  1328.     }

  1330.     return NGX_CONF_OK;
  1331. }


  1334. static char *
  1335. ‌ngx_stream_log_set_format(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1336. {
  1337.     ngx_stream_log_main_conf_t *lmcf = conf;

  1339.     ngx_str_t             *value;
  1340.     ngx_uint_t             i;
  1341.     ngx_stream_log_fmt_t  *fmt;

  1343.     value = cf->args->elts;

  1345.     fmt = lmcf->formats.elts;
  1346.     for (i = 0; i < lmcf->formats.nelts; i++) {
  1347.         if (fmt[i].name.len == value[1].len
  1348.             && ngx_strcmp(fmt[i].name.data, value[1].data) == 0)
  1349.         {
  1350.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1351.                                "duplicate \"log_format\" name \"%V\"",
  1352.                                &value[1]);
  1353.             return NGX_CONF_ERROR;
  1354.         }
  1355.     }

  1357.     fmt = ngx_array_push(&lmcf->formats);
  1358.     if (fmt == NULL) {
  1359.         return NGX_CONF_ERROR;
  1360.     }

  1362.     fmt->name = value[1];

  1364.     fmt->flushes = ngx_array_create(cf->pool, 4, sizeof(ngx_int_t));
  1365.     if (fmt->flushes == NULL) {
  1366.         return NGX_CONF_ERROR;
  1367.     }

  1369.     fmt->ops = ngx_array_create(cf->pool, 16, sizeof(ngx_stream_log_op_t));
  1370.     if (fmt->ops == NULL) {
  1371.         return NGX_CONF_ERROR;
  1372.     }

  1374.     return ngx_stream_log_compile_format(cf, fmt->flushes, fmt->ops,
  1375.                                          cf->args, 2);
  1376. }


  1379. static char *
  1380. ‌ngx_stream_log_compile_format(ngx_conf_t *cf, ngx_array_t *flushes,
  1381.     ngx_array_t *ops, ngx_array_t *args, ngx_uint_t s)
  1382. {
  1383.     u_char                *data, *p, ch;
  1384.     size_t                 i, len;
  1385.     ngx_str_t             *value, var;
  1386.     ngx_int_t             *flush;
  1387.     ngx_uint_t             bracket, escape;
  1388.     ngx_stream_log_op_t   *op;

  1390.     escape = NGX_STREAM_LOG_ESCAPE_DEFAULT;
  1391.     value = args->elts;

  1393.     if (s < args->nelts && ngx_strncmp(value[s].data, "escape=", 7) == 0) {
  1394.         data = value[s].data + 7;

  1396.         if (ngx_strcmp(data, "json") == 0) {
  1397.             escape = NGX_STREAM_LOG_ESCAPE_JSON;

  1399.         } else if (ngx_strcmp(data, "none") == 0) {
  1400.             escape = NGX_STREAM_LOG_ESCAPE_NONE;

  1402.         } else if (ngx_strcmp(data, "default") != 0) {
  1403.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1404.                                "unknown log format escaping \"%s\"", data);
  1405.             return NGX_CONF_ERROR;
  1406.         }

  1408.         s++;
  1409.     }

  1411.     for ( /* void */ ; s < args->nelts; s++) {

  1413.         i = 0;

  1415.         while (i < value[s].len) {

  1417.             op = ngx_array_push(ops);
  1418.             if (op == NULL) {
  1419.                 return NGX_CONF_ERROR;
  1420.             }

  1422.             data = &value[s].data[i];

  1424.             if (value[s].data[i] == '$') {

  1426.                 if (++i == value[s].len) {
  1427.                     goto invalid;
  1428.                 }

  1430.                 if (value[s].data[i] == '{') {
  1431.                     bracket = 1;

  1433.                     if (++i == value[s].len) {
  1434.                         goto invalid;
  1435.                     }

  1437.                     var.data = &value[s].data[i];

  1439.                 } else {
  1440.                     bracket = 0;
  1441.                     var.data = &value[s].data[i];
  1442.                 }

  1444.                 for (var.len = 0; i < value[s].len; i++, var.len++) {
  1445.                     ch = value[s].data[i];

  1447.                     if (ch == '}' && bracket) {
  1448.                         i++;
  1449.                         bracket = 0;
  1450.                         break;
  1451.                     }

  1453.                     if ((ch >= 'A' && ch <= 'Z')
  1454.                         || (ch >= 'a' && ch <= 'z')
  1455.                         || (ch >= '0' && ch <= '9')
  1456.                         || ch == '_')
  1457.                     {
  1458.                         continue;
  1459.                     }

  1461.                     break;
  1462.                 }

  1464.                 if (bracket) {
  1465.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1466.                                        "the closing bracket in \"%V\" "
  1467.                                        "variable is missing", &var);
  1468.                     return NGX_CONF_ERROR;
  1469.                 }

  1471.                 if (var.len == 0) {
  1472.                     goto invalid;
  1473.                 }

  1475.                 if (ngx_stream_log_variable_compile(cf, op, &var, escape)
  1476.                     != NGX_OK)
  1477.                 {
  1478.                     return NGX_CONF_ERROR;
  1479.                 }

  1481.                 if (flushes) {

  1483.                     flush = ngx_array_push(flushes);
  1484.                     if (flush == NULL) {
  1485.                         return NGX_CONF_ERROR;
  1486.                     }

  1488.                     *flush = op->data; /* variable index */
  1489.                 }

  1491.                 continue;
  1492.             }

  1494.             i++;

  1496.             while (i < value[s].len && value[s].data[i] != '$') {
  1497.                 i++;
  1498.             }

  1500.             len = &value[s].data[i] - data;

  1502.             if (len) {

  1504.                 op->len = len;
  1505.                 op->getlen = NULL;

  1507.                 if (len <= sizeof(uintptr_t)) {
  1508.                     op->run = ngx_stream_log_copy_short;
  1509.                     op->data = 0;

  1511.                     while (len--) {
  1512.                         op->data <<= 8;
  1513.                         op->data |= data[len];
  1514.                     }

  1516.                 } else {
  1517.                     op->run = ngx_stream_log_copy_long;

  1519.                     p = ngx_pnalloc(cf->pool, len);
  1520.                     if (p == NULL) {
  1521.                         return NGX_CONF_ERROR;
  1522.                     }

  1524.                     ngx_memcpy(p, data, len);
  1525.                     op->data = (uintptr_t) p;
  1526.                 }
  1527.             }
  1528.         }
  1529.     }

  1531.     return NGX_CONF_OK;

  1533. invalid:

  1535.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%s\"", data);

  1537.     return NGX_CONF_ERROR;
  1538. }


  1541. static char *
  1542. ‌ngx_stream_log_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1543. {
  1544.     ngx_stream_log_srv_conf_t *lscf = conf;

  1546.     time_t       inactive, valid;
  1547.     ngx_str_t   *value, s;
  1548.     ngx_int_t    max, min_uses;
  1549.     ngx_uint_t   i;

  1551.     if (lscf->open_file_cache != NGX_CONF_UNSET_PTR) {
  1552.         return "is duplicate";
  1553.     }

  1555.     value = cf->args->elts;

  1557.     max = 0;
  1558.     inactive = 10;
  1559.     valid = 60;
  1560.     min_uses = 1;

  1562.     for (i = 1; i < cf->args->nelts; i++) {

  1564.         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {

  1566.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  1567.             if (max == NGX_ERROR) {
  1568.                 goto failed;
  1569.             }

  1571.             continue;
  1572.         }

  1574.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  1576.             s.len = value[i].len - 9;
  1577.             s.data = value[i].data + 9;

  1579.             inactive = ngx_parse_time(&s, 1);
  1580.             if (inactive == (time_t) NGX_ERROR) {
  1581.                 goto failed;
  1582.             }

  1584.             continue;
  1585.         }

  1587.         if (ngx_strncmp(value[i].data, "min_uses=", 9) == 0) {

  1589.             min_uses = ngx_atoi(value[i].data + 9, value[i].len - 9);
  1590.             if (min_uses == NGX_ERROR) {
  1591.                 goto failed;
  1592.             }

  1594.             continue;
  1595.         }

  1597.         if (ngx_strncmp(value[i].data, "valid=", 6) == 0) {

  1599.             s.len = value[i].len - 6;
  1600.             s.data = value[i].data + 6;

  1602.             valid = ngx_parse_time(&s, 1);
  1603.             if (valid == (time_t) NGX_ERROR) {
  1604.                 goto failed;
  1605.             }

  1607.             continue;
  1608.         }

  1610.         if (ngx_strcmp(value[i].data, "off") == 0) {

  1612.             lscf->open_file_cache = NULL;

  1614.             continue;
  1615.         }

  1617.     failed:

  1619.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1620.                            "invalid \"open_log_file_cache\" parameter \"%V\"",
  1621.                            &value[i]);
  1622.         return NGX_CONF_ERROR;
  1623.     }

  1625.     if (lscf->open_file_cache == NULL) {
  1626.         return NGX_CONF_OK;
  1627.     }

  1629.     if (max == 0) {
  1630.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1631.                         "\"open_log_file_cache\" must have \"max\" parameter");
  1632.         return NGX_CONF_ERROR;
  1633.     }

  1635.     lscf->open_file_cache = ngx_open_file_cache_init(cf->pool, max, inactive);

  1637.     if (lscf->open_file_cache) {

  1639.         lscf->open_file_cache_valid = valid;
  1640.         lscf->open_file_cache_min_uses = min_uses;

  1642.         return NGX_CONF_OK;
  1643.     }

  1645.     return NGX_CONF_ERROR;
  1646. }


  1649. static ngx_int_t
  1650. ‌ngx_stream_log_init(ngx_conf_t *cf)
  1651. {
  1652.     ngx_stream_handler_pt        *h;
  1653.     ngx_stream_core_main_conf_t  *cmcf;

  1655.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  1657.     h = ngx_array_push(&cmcf->phases[NGX_STREAM_LOG_PHASE].handlers);
  1658.     if (h == NULL) {
  1659.         return NGX_ERROR;
  1660.     }

  1662.     *h = ngx_stream_log_handler;

  1664.     return NGX_OK;
  1665. }

One Level Up Top Level