One Level Up Top Level

src/stream/ngx_stream_variables.c - nginx source code

Global variables defined

Functions 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>
  11. #include <nginx.h>

  13. static ngx_stream_variable_t *ngx_stream_add_prefix_variable(ngx_conf_t *cf,
  14.     ngx_str_t *name, ngx_uint_t flags);

  16. static ngx_int_t ngx_stream_variable_binary_remote_addr(
  17.     ngx_stream_session_t *s, ngx_stream_variable_value_t *v, uintptr_t data);
  18. static ngx_int_t ngx_stream_variable_remote_addr(ngx_stream_session_t *s,
  19.     ngx_stream_variable_value_t *v, uintptr_t data);
  20. static ngx_int_t ngx_stream_variable_remote_port(ngx_stream_session_t *s,
  21.     ngx_stream_variable_value_t *v, uintptr_t data);
  22. static ngx_int_t ngx_stream_variable_proxy_protocol_addr(
  23.     ngx_stream_session_t *s, ngx_stream_variable_value_t *v, uintptr_t data);
  24. static ngx_int_t ngx_stream_variable_proxy_protocol_port(
  25.     ngx_stream_session_t *s, ngx_stream_variable_value_t *v, uintptr_t data);
  26. static ngx_int_t ngx_stream_variable_proxy_protocol_tlv(
  27.     ngx_stream_session_t *s, ngx_stream_variable_value_t *v, uintptr_t data);
  28. static ngx_int_t ngx_stream_variable_server_addr(ngx_stream_session_t *s,
  29.     ngx_stream_variable_value_t *v, uintptr_t data);
  30. static ngx_int_t ngx_stream_variable_server_port(ngx_stream_session_t *s,
  31.     ngx_stream_variable_value_t *v, uintptr_t data);
  32. static ngx_int_t ngx_stream_variable_server_name(ngx_stream_session_t *s,
  33.     ngx_stream_variable_value_t *v, uintptr_t data);
  34. static ngx_int_t ngx_stream_variable_bytes(ngx_stream_session_t *s,
  35.     ngx_stream_variable_value_t *v, uintptr_t data);
  36. static ngx_int_t ngx_stream_variable_session_time(ngx_stream_session_t *s,
  37.     ngx_stream_variable_value_t *v, uintptr_t data);
  38. static ngx_int_t ngx_stream_variable_status(ngx_stream_session_t *s,
  39.     ngx_stream_variable_value_t *v, uintptr_t data);
  40. static ngx_int_t ngx_stream_variable_connection(ngx_stream_session_t *s,
  41.     ngx_stream_variable_value_t *v, uintptr_t data);

  43. static ngx_int_t ngx_stream_variable_nginx_version(ngx_stream_session_t *s,
  44.     ngx_stream_variable_value_t *v, uintptr_t data);
  45. static ngx_int_t ngx_stream_variable_hostname(ngx_stream_session_t *s,
  46.     ngx_stream_variable_value_t *v, uintptr_t data);
  47. static ngx_int_t ngx_stream_variable_pid(ngx_stream_session_t *s,
  48.     ngx_stream_variable_value_t *v, uintptr_t data);
  49. static ngx_int_t ngx_stream_variable_msec(ngx_stream_session_t *s,
  50.     ngx_stream_variable_value_t *v, uintptr_t data);
  51. static ngx_int_t ngx_stream_variable_time_iso8601(ngx_stream_session_t *s,
  52.     ngx_stream_variable_value_t *v, uintptr_t data);
  53. static ngx_int_t ngx_stream_variable_time_local(ngx_stream_session_t *s,
  54.     ngx_stream_variable_value_t *v, uintptr_t data);
  55. static ngx_int_t ngx_stream_variable_protocol(ngx_stream_session_t *s,
  56.     ngx_stream_variable_value_t *v, uintptr_t data);


  59. ‌static ngx_stream_variable_t  ngx_stream_core_variables[] = {

  61.     { ngx_string("binary_remote_addr"), NULL,
  62.       ngx_stream_variable_binary_remote_addr, 0, 0, 0 },

  64.     { ngx_string("remote_addr"), NULL,
  65.       ngx_stream_variable_remote_addr, 0, 0, 0 },

  67.     { ngx_string("remote_port"), NULL,
  68.       ngx_stream_variable_remote_port, 0, 0, 0 },

  70.     { ngx_string("proxy_protocol_addr"), NULL,
  71.       ngx_stream_variable_proxy_protocol_addr,
  72.       offsetof(ngx_proxy_protocol_t, src_addr), 0, 0 },

  74.     { ngx_string("proxy_protocol_port"), NULL,
  75.       ngx_stream_variable_proxy_protocol_port,
  76.       offsetof(ngx_proxy_protocol_t, src_port), 0, 0 },

  78.     { ngx_string("proxy_protocol_server_addr"), NULL,
  79.       ngx_stream_variable_proxy_protocol_addr,
  80.       offsetof(ngx_proxy_protocol_t, dst_addr), 0, 0 },

  82.     { ngx_string("proxy_protocol_server_port"), NULL,
  83.       ngx_stream_variable_proxy_protocol_port,
  84.       offsetof(ngx_proxy_protocol_t, dst_port), 0, 0 },

  86.     { ngx_string("proxy_protocol_tlv_"), NULL,
  87.       ngx_stream_variable_proxy_protocol_tlv,
  88.       0, NGX_STREAM_VAR_PREFIX, 0 },

  90.     { ngx_string("server_addr"), NULL,
  91.       ngx_stream_variable_server_addr, 0, 0, 0 },

  93.     { ngx_string("server_port"), NULL,
  94.       ngx_stream_variable_server_port, 0, 0, 0 },

  96.     { ngx_string("server_name"), NULL, ngx_stream_variable_server_name,
  97.       0, 0, 0 },

  99.     { ngx_string("bytes_sent"), NULL, ngx_stream_variable_bytes,
  100.       0, 0, 0 },

  102.     { ngx_string("bytes_received"), NULL, ngx_stream_variable_bytes,
  103.       1, 0, 0 },

  105.     { ngx_string("session_time"), NULL, ngx_stream_variable_session_time,
  106.       0, NGX_STREAM_VAR_NOCACHEABLE, 0 },

  108.     { ngx_string("status"), NULL, ngx_stream_variable_status,
  109.       0, NGX_STREAM_VAR_NOCACHEABLE, 0 },

  111.     { ngx_string("connection"), NULL,
  112.       ngx_stream_variable_connection, 0, 0, 0 },

  114.     { ngx_string("nginx_version"), NULL, ngx_stream_variable_nginx_version,
  115.       0, 0, 0 },

  117.     { ngx_string("hostname"), NULL, ngx_stream_variable_hostname,
  118.       0, 0, 0 },

  120.     { ngx_string("pid"), NULL, ngx_stream_variable_pid,
  121.       0, 0, 0 },

  123.     { ngx_string("msec"), NULL, ngx_stream_variable_msec,
  124.       0, NGX_STREAM_VAR_NOCACHEABLE, 0 },

  126.     { ngx_string("time_iso8601"), NULL, ngx_stream_variable_time_iso8601,
  127.       0, NGX_STREAM_VAR_NOCACHEABLE, 0 },

  129.     { ngx_string("time_local"), NULL, ngx_stream_variable_time_local,
  130.       0, NGX_STREAM_VAR_NOCACHEABLE, 0 },

  132.     { ngx_string("protocol"), NULL,
  133.       ngx_stream_variable_protocol, 0, 0, 0 },

  135.       ngx_stream_null_variable
  136. };


  139. ‌ngx_stream_variable_value_t  ngx_stream_variable_null_value =
  140.     ngx_stream_variable("");
  141. ‌ngx_stream_variable_value_t  ngx_stream_variable_true_value =
  142.     ngx_stream_variable("1");


  145. ‌static ngx_uint_t  ngx_stream_variable_depth = 100;


  148. ngx_stream_variable_t *
  149. ‌ngx_stream_add_variable(ngx_conf_t *cf, ngx_str_t *name, ngx_uint_t flags)
  150. {
  151.     ngx_int_t                     rc;
  152.     ngx_uint_t                    i;
  153.     ngx_hash_key_t               *key;
  154.     ngx_stream_variable_t        *v;
  155.     ngx_stream_core_main_conf_t  *cmcf;

  157.     if (name->len == 0) {
  158.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  159.                            "invalid variable name \"$\"");
  160.         return NULL;
  161.     }

  163.     if (flags & NGX_STREAM_VAR_PREFIX) {
  164.         return ngx_stream_add_prefix_variable(cf, name, flags);
  165.     }

  167.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  169.     key = cmcf->variables_keys->keys.elts;
  170.     for (i = 0; i < cmcf->variables_keys->keys.nelts; i++) {
  171.         if (name->len != key[i].key.len
  172.             || ngx_strncasecmp(name->data, key[i].key.data, name->len) != 0)
  173.         {
  174.             continue;
  175.         }

  177.         v = key[i].value;

  179.         if (!(v->flags & NGX_STREAM_VAR_CHANGEABLE)) {
  180.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  181.                                "the duplicate \"%V\" variable", name);
  182.             return NULL;
  183.         }

  185.         if (!(flags & NGX_STREAM_VAR_WEAK)) {
  186.             v->flags &= ~NGX_STREAM_VAR_WEAK;
  187.         }

  189.         return v;
  190.     }

  192.     v = ngx_palloc(cf->pool, sizeof(ngx_stream_variable_t));
  193.     if (v == NULL) {
  194.         return NULL;
  195.     }

  197.     v->name.len = name->len;
  198.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  199.     if (v->name.data == NULL) {
  200.         return NULL;
  201.     }

  203.     ngx_strlow(v->name.data, name->data, name->len);

  205.     v->set_handler = NULL;
  206.     v->get_handler = NULL;
  207.     v->data = 0;
  208.     v->flags = flags;
  209.     v->index = 0;

  211.     rc = ngx_hash_add_key(cmcf->variables_keys, &v->name, v, 0);

  213.     if (rc == NGX_ERROR) {
  214.         return NULL;
  215.     }

  217.     if (rc == NGX_BUSY) {
  218.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  219.                            "conflicting variable name \"%V\"", name);
  220.         return NULL;
  221.     }

  223.     return v;
  224. }


  227. static ngx_stream_variable_t *
  228. ‌ngx_stream_add_prefix_variable(ngx_conf_t *cf, ngx_str_t *name,
  229.     ngx_uint_t flags)
  230. {
  231.     ngx_uint_t                    i;
  232.     ngx_stream_variable_t        *v;
  233.     ngx_stream_core_main_conf_t  *cmcf;

  235.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  237.     v = cmcf->prefix_variables.elts;
  238.     for (i = 0; i < cmcf->prefix_variables.nelts; i++) {
  239.         if (name->len != v[i].name.len
  240.             || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
  241.         {
  242.             continue;
  243.         }

  245.         v = &v[i];

  247.         if (!(v->flags & NGX_STREAM_VAR_CHANGEABLE)) {
  248.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  249.                                "the duplicate \"%V\" variable", name);
  250.             return NULL;
  251.         }

  253.         if (!(flags & NGX_STREAM_VAR_WEAK)) {
  254.             v->flags &= ~NGX_STREAM_VAR_WEAK;
  255.         }

  257.         return v;
  258.     }

  260.     v = ngx_array_push(&cmcf->prefix_variables);
  261.     if (v == NULL) {
  262.         return NULL;
  263.     }

  265.     v->name.len = name->len;
  266.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  267.     if (v->name.data == NULL) {
  268.         return NULL;
  269.     }

  271.     ngx_strlow(v->name.data, name->data, name->len);

  273.     v->set_handler = NULL;
  274.     v->get_handler = NULL;
  275.     v->data = 0;
  276.     v->flags = flags;
  277.     v->index = 0;

  279.     return v;
  280. }


  283. ngx_int_t
  284. ‌ngx_stream_get_variable_index(ngx_conf_t *cf, ngx_str_t *name)
  285. {
  286.     ngx_uint_t                    i;
  287.     ngx_stream_variable_t        *v;
  288.     ngx_stream_core_main_conf_t  *cmcf;

  290.     if (name->len == 0) {
  291.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  292.                            "invalid variable name \"$\"");
  293.         return NGX_ERROR;
  294.     }

  296.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  298.     v = cmcf->variables.elts;

  300.     if (v == NULL) {
  301.         if (ngx_array_init(&cmcf->variables, cf->pool, 4,
  302.                            sizeof(ngx_stream_variable_t))
  303.             != NGX_OK)
  304.         {
  305.             return NGX_ERROR;
  306.         }

  308.     } else {
  309.         for (i = 0; i < cmcf->variables.nelts; i++) {
  310.             if (name->len != v[i].name.len
  311.                 || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
  312.             {
  313.                 continue;
  314.             }

  316.             return i;
  317.         }
  318.     }

  320.     v = ngx_array_push(&cmcf->variables);
  321.     if (v == NULL) {
  322.         return NGX_ERROR;
  323.     }

  325.     v->name.len = name->len;
  326.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  327.     if (v->name.data == NULL) {
  328.         return NGX_ERROR;
  329.     }

  331.     ngx_strlow(v->name.data, name->data, name->len);

  333.     v->set_handler = NULL;
  334.     v->get_handler = NULL;
  335.     v->data = 0;
  336.     v->flags = 0;
  337.     v->index = cmcf->variables.nelts - 1;

  339.     return v->index;
  340. }


  343. ngx_stream_variable_value_t *
  344. ‌ngx_stream_get_indexed_variable(ngx_stream_session_t *s, ngx_uint_t index)
  345. {
  346.     ngx_stream_variable_t        *v;
  347.     ngx_stream_core_main_conf_t  *cmcf;

  349.     cmcf = ngx_stream_get_module_main_conf(s, ngx_stream_core_module);

  351.     if (cmcf->variables.nelts <= index) {
  352.         ngx_log_error(NGX_LOG_ALERT, s->connection->log, 0,
  353.                       "unknown variable index: %ui", index);
  354.         return NULL;
  355.     }

  357.     if (s->variables[index].not_found || s->variables[index].valid) {
  358.         return &s->variables[index];
  359.     }

  361.     v = cmcf->variables.elts;

  363.     if (ngx_stream_variable_depth == 0) {
  364.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  365.                       "cycle while evaluating variable \"%V\"",
  366.                       &v[index].name);
  367.         return NULL;
  368.     }

  370.     ngx_stream_variable_depth--;

  372.     if (v[index].get_handler(s, &s->variables[index], v[index].data)
  373.         == NGX_OK)
  374.     {
  375.         ngx_stream_variable_depth++;

  377.         if (v[index].flags & NGX_STREAM_VAR_NOCACHEABLE) {
  378.             s->variables[index].no_cacheable = 1;
  379.         }

  381.         return &s->variables[index];
  382.     }

  384.     ngx_stream_variable_depth++;

  386.     s->variables[index].valid = 0;
  387.     s->variables[index].not_found = 1;

  389.     return NULL;
  390. }


  393. ngx_stream_variable_value_t *
  394. ‌ngx_stream_get_flushed_variable(ngx_stream_session_t *s, ngx_uint_t index)
  395. {
  396.     ngx_stream_variable_value_t  *v;

  398.     v = &s->variables[index];

  400.     if (v->valid || v->not_found) {
  401.         if (!v->no_cacheable) {
  402.             return v;
  403.         }

  405.         v->valid = 0;
  406.         v->not_found = 0;
  407.     }

  409.     return ngx_stream_get_indexed_variable(s, index);
  410. }


  413. ngx_stream_variable_value_t *
  414. ‌ngx_stream_get_variable(ngx_stream_session_t *s, ngx_str_t *name,
  415.     ngx_uint_t key)
  416. {
  417.     size_t                        len;
  418.     ngx_uint_t                    i, n;
  419.     ngx_stream_variable_t        *v;
  420.     ngx_stream_variable_value_t  *vv;
  421.     ngx_stream_core_main_conf_t  *cmcf;

  423.     cmcf = ngx_stream_get_module_main_conf(s, ngx_stream_core_module);

  425.     v = ngx_hash_find(&cmcf->variables_hash, key, name->data, name->len);

  427.     if (v) {
  428.         if (v->flags & NGX_STREAM_VAR_INDEXED) {
  429.             return ngx_stream_get_flushed_variable(s, v->index);
  430.         }

  432.         if (ngx_stream_variable_depth == 0) {
  433.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  434.                           "cycle while evaluating variable \"%V\"", name);
  435.             return NULL;
  436.         }

  438.         ngx_stream_variable_depth--;

  440.         vv = ngx_palloc(s->connection->pool,
  441.                         sizeof(ngx_stream_variable_value_t));

  443.         if (vv && v->get_handler(s, vv, v->data) == NGX_OK) {
  444.             ngx_stream_variable_depth++;
  445.             return vv;
  446.         }

  448.         ngx_stream_variable_depth++;
  449.         return NULL;
  450.     }

  452.     vv = ngx_palloc(s->connection->pool, sizeof(ngx_stream_variable_value_t));
  453.     if (vv == NULL) {
  454.         return NULL;
  455.     }

  457.     len = 0;

  459.     v = cmcf->prefix_variables.elts;
  460.     n = cmcf->prefix_variables.nelts;

  462.     for (i = 0; i < cmcf->prefix_variables.nelts; i++) {
  463.         if (name->len >= v[i].name.len && name->len > len
  464.             && ngx_strncmp(name->data, v[i].name.data, v[i].name.len) == 0)
  465.         {
  466.             len = v[i].name.len;
  467.             n = i;
  468.         }
  469.     }

  471.     if (n != cmcf->prefix_variables.nelts) {
  472.         if (v[n].get_handler(s, vv, (uintptr_t) name) == NGX_OK) {
  473.             return vv;
  474.         }

  476.         return NULL;
  477.     }

  479.     vv->not_found = 1;

  481.     return vv;
  482. }


  485. static ngx_int_t
  486. ‌ngx_stream_variable_binary_remote_addr(ngx_stream_session_t *s,
  487.      ngx_stream_variable_value_t *v, uintptr_t data)
  488. {
  489.     struct sockaddr_in   *sin;
  490. #if (NGX_HAVE_INET6)
  491.     struct sockaddr_in6  *sin6;
  492. #endif

  494.     switch (s->connection->sockaddr->sa_family) {

  496. #if (NGX_HAVE_INET6)
  497.     case AF_INET6:
  498.         sin6 = (struct sockaddr_in6 *) s->connection->sockaddr;

  500.         v->len = sizeof(struct in6_addr);
  501.         v->valid = 1;
  502.         v->no_cacheable = 0;
  503.         v->not_found = 0;
  504.         v->data = sin6->sin6_addr.s6_addr;

  506.         break;
  507. #endif

  509. #if (NGX_HAVE_UNIX_DOMAIN)
  510.     case AF_UNIX:

  512.         v->len = s->connection->addr_text.len;
  513.         v->valid = 1;
  514.         v->no_cacheable = 0;
  515.         v->not_found = 0;
  516.         v->data = s->connection->addr_text.data;

  518.         break;
  519. #endif

  521.     default: /* AF_INET */
  522.         sin = (struct sockaddr_in *) s->connection->sockaddr;

  524.         v->len = sizeof(in_addr_t);
  525.         v->valid = 1;
  526.         v->no_cacheable = 0;
  527.         v->not_found = 0;
  528.         v->data = (u_char *) &sin->sin_addr;

  530.         break;
  531.     }

  533.     return NGX_OK;
  534. }


  537. static ngx_int_t
  538. ‌ngx_stream_variable_remote_addr(ngx_stream_session_t *s,
  539.     ngx_stream_variable_value_t *v, uintptr_t data)
  540. {
  541.     v->len = s->connection->addr_text.len;
  542.     v->valid = 1;
  543.     v->no_cacheable = 0;
  544.     v->not_found = 0;
  545.     v->data = s->connection->addr_text.data;

  547.     return NGX_OK;
  548. }


  551. static ngx_int_t
  552. ‌ngx_stream_variable_remote_port(ngx_stream_session_t *s,
  553.     ngx_stream_variable_value_t *v, uintptr_t data)
  554. {
  555.     ngx_uint_t  port;

  557.     v->len = 0;
  558.     v->valid = 1;
  559.     v->no_cacheable = 0;
  560.     v->not_found = 0;

  562.     v->data = ngx_pnalloc(s->connection->pool, sizeof("65535") - 1);
  563.     if (v->data == NULL) {
  564.         return NGX_ERROR;
  565.     }

  567.     port = ngx_inet_get_port(s->connection->sockaddr);

  569.     if (port > 0 && port < 65536) {
  570.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  571.     }

  573.     return NGX_OK;
  574. }


  577. static ngx_int_t
  578. ‌ngx_stream_variable_proxy_protocol_addr(ngx_stream_session_t *s,
  579.     ngx_stream_variable_value_t *v, uintptr_t data)
  580. {
  581.     ngx_str_t             *addr;
  582.     ngx_proxy_protocol_t  *pp;

  584.     pp = s->connection->proxy_protocol;
  585.     if (pp == NULL) {
  586.         v->not_found = 1;
  587.         return NGX_OK;
  588.     }

  590.     addr = (ngx_str_t *) ((char *) pp + data);

  592.     v->len = addr->len;
  593.     v->valid = 1;
  594.     v->no_cacheable = 0;
  595.     v->not_found = 0;
  596.     v->data = addr->data;

  598.     return NGX_OK;
  599. }


  602. static ngx_int_t
  603. ‌ngx_stream_variable_proxy_protocol_port(ngx_stream_session_t *s,
  604.     ngx_stream_variable_value_t *v, uintptr_t data)
  605. {
  606.     ngx_uint_t             port;
  607.     ngx_proxy_protocol_t  *pp;

  609.     pp = s->connection->proxy_protocol;
  610.     if (pp == NULL) {
  611.         v->not_found = 1;
  612.         return NGX_OK;
  613.     }

  615.     v->len = 0;
  616.     v->valid = 1;
  617.     v->no_cacheable = 0;
  618.     v->not_found = 0;

  620.     v->data = ngx_pnalloc(s->connection->pool, sizeof("65535") - 1);
  621.     if (v->data == NULL) {
  622.         return NGX_ERROR;
  623.     }

  625.     port = *(in_port_t *) ((char *) pp + data);

  627.     if (port > 0 && port < 65536) {
  628.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  629.     }

  631.     return NGX_OK;
  632. }


  635. static ngx_int_t
  636. ‌ngx_stream_variable_proxy_protocol_tlv(ngx_stream_session_t *s,
  637.     ngx_stream_variable_value_t *v, uintptr_t data)
  638. {
  639.     ngx_str_t *name = (ngx_str_t *) data;

  641.     ngx_int_t  rc;
  642.     ngx_str_t  tlv, value;

  644.     tlv.len = name->len - (sizeof("proxy_protocol_tlv_") - 1);
  645.     tlv.data = name->data + sizeof("proxy_protocol_tlv_") - 1;

  647.     rc = ngx_proxy_protocol_get_tlv(s->connection, &tlv, &value);

  649.     if (rc == NGX_ERROR) {
  650.         return NGX_ERROR;
  651.     }

  653.     if (rc == NGX_DECLINED) {
  654.         v->not_found = 1;
  655.         return NGX_OK;
  656.     }

  658.     v->len = value.len;
  659.     v->valid = 1;
  660.     v->no_cacheable = 0;
  661.     v->not_found = 0;
  662.     v->data = value.data;

  664.     return NGX_OK;
  665. }


  668. static ngx_int_t
  669. ‌ngx_stream_variable_server_addr(ngx_stream_session_t *s,
  670.     ngx_stream_variable_value_t *v, uintptr_t data)
  671. {
  672.     ngx_str_t  str;
  673.     u_char     addr[NGX_SOCKADDR_STRLEN];

  675.     str.len = NGX_SOCKADDR_STRLEN;
  676.     str.data = addr;

  678.     if (ngx_connection_local_sockaddr(s->connection, &str, 0) != NGX_OK) {
  679.         return NGX_ERROR;
  680.     }

  682.     str.data = ngx_pnalloc(s->connection->pool, str.len);
  683.     if (str.data == NULL) {
  684.         return NGX_ERROR;
  685.     }

  687.     ngx_memcpy(str.data, addr, str.len);

  689.     v->len = str.len;
  690.     v->valid = 1;
  691.     v->no_cacheable = 0;
  692.     v->not_found = 0;
  693.     v->data = str.data;

  695.     return NGX_OK;
  696. }


  699. static ngx_int_t
  700. ‌ngx_stream_variable_server_port(ngx_stream_session_t *s,
  701.     ngx_stream_variable_value_t *v, uintptr_t data)
  702. {
  703.     ngx_uint_t  port;

  705.     v->len = 0;
  706.     v->valid = 1;
  707.     v->no_cacheable = 0;
  708.     v->not_found = 0;

  710.     if (ngx_connection_local_sockaddr(s->connection, NULL, 0) != NGX_OK) {
  711.         return NGX_ERROR;
  712.     }

  714.     v->data = ngx_pnalloc(s->connection->pool, sizeof("65535") - 1);
  715.     if (v->data == NULL) {
  716.         return NGX_ERROR;
  717.     }

  719.     port = ngx_inet_get_port(s->connection->local_sockaddr);

  721.     if (port > 0 && port < 65536) {
  722.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  723.     }

  725.     return NGX_OK;
  726. }


  729. static ngx_int_t
  730. ‌ngx_stream_variable_server_name(ngx_stream_session_t *s,
  731.     ngx_stream_variable_value_t *v, uintptr_t data)
  732. {
  733.     ngx_stream_core_srv_conf_t  *cscf;

  735.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  737.     v->len = cscf->server_name.len;
  738.     v->valid = 1;
  739.     v->no_cacheable = 0;
  740.     v->not_found = 0;
  741.     v->data = cscf->server_name.data;

  743.     return NGX_OK;
  744. }


  747. static ngx_int_t
  748. ‌ngx_stream_variable_bytes(ngx_stream_session_t *s,
  749.     ngx_stream_variable_value_t *v, uintptr_t data)
  750. {
  751.     u_char  *p;

  753.     p = ngx_pnalloc(s->connection->pool, NGX_OFF_T_LEN);
  754.     if (p == NULL) {
  755.         return NGX_ERROR;
  756.     }

  758.     if (data == 1) {
  759.         v->len = ngx_sprintf(p, "%O", s->received) - p;

  761.     } else {
  762.         v->len = ngx_sprintf(p, "%O", s->connection->sent) - p;
  763.     }

  765.     v->valid = 1;
  766.     v->no_cacheable = 0;
  767.     v->not_found = 0;
  768.     v->data = p;

  770.     return NGX_OK;
  771. }


  774. static ngx_int_t
  775. ‌ngx_stream_variable_session_time(ngx_stream_session_t *s,
  776.     ngx_stream_variable_value_t *v, uintptr_t data)
  777. {
  778.     u_char          *p;
  779.     ngx_time_t      *tp;
  780.     ngx_msec_int_t   ms;

  782.     p = ngx_pnalloc(s->connection->pool, NGX_TIME_T_LEN + 4);
  783.     if (p == NULL) {
  784.         return NGX_ERROR;
  785.     }

  787.     tp = ngx_timeofday();

  789.     ms = (ngx_msec_int_t)
  790.              ((tp->sec - s->start_sec) * 1000 + (tp->msec - s->start_msec));
  791.     ms = ngx_max(ms, 0);

  793.     v->len = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000) - p;
  794.     v->valid = 1;
  795.     v->no_cacheable = 0;
  796.     v->not_found = 0;
  797.     v->data = p;

  799.     return NGX_OK;
  800. }


  803. static ngx_int_t
  804. ‌ngx_stream_variable_status(ngx_stream_session_t *s,
  805.     ngx_stream_variable_value_t *v, uintptr_t data)
  806. {
  807.     v->data = ngx_pnalloc(s->connection->pool, NGX_INT_T_LEN);
  808.     if (v->data == NULL) {
  809.         return NGX_ERROR;
  810.     }

  812.     v->len = ngx_sprintf(v->data, "%03ui", s->status) - v->data;
  813.     v->valid = 1;
  814.     v->no_cacheable = 0;
  815.     v->not_found = 0;

  817.     return NGX_OK;
  818. }


  821. static ngx_int_t
  822. ‌ngx_stream_variable_connection(ngx_stream_session_t *s,
  823.     ngx_stream_variable_value_t *v, uintptr_t data)
  824. {
  825.     u_char  *p;

  827.     p = ngx_pnalloc(s->connection->pool, NGX_ATOMIC_T_LEN);
  828.     if (p == NULL) {
  829.         return NGX_ERROR;
  830.     }

  832.     v->len = ngx_sprintf(p, "%uA", s->connection->number) - p;
  833.     v->valid = 1;
  834.     v->no_cacheable = 0;
  835.     v->not_found = 0;
  836.     v->data = p;

  838.     return NGX_OK;
  839. }


  842. static ngx_int_t
  843. ‌ngx_stream_variable_nginx_version(ngx_stream_session_t *s,
  844.     ngx_stream_variable_value_t *v, uintptr_t data)
  845. {
  846.     v->len = sizeof(NGINX_VERSION) - 1;
  847.     v->valid = 1;
  848.     v->no_cacheable = 0;
  849.     v->not_found = 0;
  850.     v->data = (u_char *) NGINX_VERSION;

  852.     return NGX_OK;
  853. }


  856. static ngx_int_t
  857. ‌ngx_stream_variable_hostname(ngx_stream_session_t *s,
  858.     ngx_stream_variable_value_t *v, uintptr_t data)
  859. {
  860.     v->len = ngx_cycle->hostname.len;
  861.     v->valid = 1;
  862.     v->no_cacheable = 0;
  863.     v->not_found = 0;
  864.     v->data = ngx_cycle->hostname.data;

  866.     return NGX_OK;
  867. }


  870. static ngx_int_t
  871. ‌ngx_stream_variable_pid(ngx_stream_session_t *s,
  872.     ngx_stream_variable_value_t *v, uintptr_t data)
  873. {
  874.     u_char  *p;

  876.     p = ngx_pnalloc(s->connection->pool, NGX_INT64_LEN);
  877.     if (p == NULL) {
  878.         return NGX_ERROR;
  879.     }

  881.     v->len = ngx_sprintf(p, "%P", ngx_pid) - p;
  882.     v->valid = 1;
  883.     v->no_cacheable = 0;
  884.     v->not_found = 0;
  885.     v->data = p;

  887.     return NGX_OK;
  888. }


  891. static ngx_int_t
  892. ‌ngx_stream_variable_msec(ngx_stream_session_t *s,
  893.     ngx_stream_variable_value_t *v, uintptr_t data)
  894. {
  895.     u_char      *p;
  896.     ngx_time_t  *tp;

  898.     p = ngx_pnalloc(s->connection->pool, NGX_TIME_T_LEN + 4);
  899.     if (p == NULL) {
  900.         return NGX_ERROR;
  901.     }

  903.     tp = ngx_timeofday();

  905.     v->len = ngx_sprintf(p, "%T.%03M", tp->sec, tp->msec) - p;
  906.     v->valid = 1;
  907.     v->no_cacheable = 0;
  908.     v->not_found = 0;
  909.     v->data = p;

  911.     return NGX_OK;
  912. }


  915. static ngx_int_t
  916. ‌ngx_stream_variable_time_iso8601(ngx_stream_session_t *s,
  917.     ngx_stream_variable_value_t *v, uintptr_t data)
  918. {
  919.     u_char  *p;

  921.     p = ngx_pnalloc(s->connection->pool, ngx_cached_http_log_iso8601.len);
  922.     if (p == NULL) {
  923.         return NGX_ERROR;
  924.     }

  926.     ngx_memcpy(p, ngx_cached_http_log_iso8601.data,
  927.                ngx_cached_http_log_iso8601.len);

  929.     v->len = ngx_cached_http_log_iso8601.len;
  930.     v->valid = 1;
  931.     v->no_cacheable = 0;
  932.     v->not_found = 0;
  933.     v->data = p;

  935.     return NGX_OK;
  936. }


  939. static ngx_int_t
  940. ‌ngx_stream_variable_time_local(ngx_stream_session_t *s,
  941.     ngx_stream_variable_value_t *v, uintptr_t data)
  942. {
  943.     u_char  *p;

  945.     p = ngx_pnalloc(s->connection->pool, ngx_cached_http_log_time.len);
  946.     if (p == NULL) {
  947.         return NGX_ERROR;
  948.     }

  950.     ngx_memcpy(p, ngx_cached_http_log_time.data, ngx_cached_http_log_time.len);

  952.     v->len = ngx_cached_http_log_time.len;
  953.     v->valid = 1;
  954.     v->no_cacheable = 0;
  955.     v->not_found = 0;
  956.     v->data = p;

  958.     return NGX_OK;
  959. }


  962. static ngx_int_t
  963. ‌ngx_stream_variable_protocol(ngx_stream_session_t *s,
  964.     ngx_stream_variable_value_t *v, uintptr_t data)
  965. {
  966.     v->len = 3;
  967.     v->valid = 1;
  968.     v->no_cacheable = 0;
  969.     v->not_found = 0;
  970.     v->data = (u_char *) (s->connection->type == SOCK_DGRAM ? "UDP" : "TCP");

  972.     return NGX_OK;
  973. }


  976. void *
  977. ‌ngx_stream_map_find(ngx_stream_session_t *s, ngx_stream_map_t *map,
  978.     ngx_str_t *match)
  979. {
  980.     void        *value;
  981.     u_char      *low;
  982.     size_t       len;
  983.     ngx_uint_t   key;

  985.     len = match->len;

  987.     if (len) {
  988.         low = ngx_pnalloc(s->connection->pool, len);
  989.         if (low == NULL) {
  990.             return NULL;
  991.         }

  993.     } else {
  994.         low = NULL;
  995.     }

  997.     key = ngx_hash_strlow(low, match->data, len);

  999.     value = ngx_hash_find_combined(&map->hash, key, low, len);
  1000.     if (value) {
  1001.         return value;
  1002.     }

  1004. #if (NGX_PCRE)

  1006.     if (len && map->nregex) {
  1007.         ngx_int_t                n;
  1008.         ngx_uint_t               i;
  1009.         ngx_stream_map_regex_t  *reg;

  1011.         reg = map->regex;

  1013.         for (i = 0; i < map->nregex; i++) {

  1015.             n = ngx_stream_regex_exec(s, reg[i].regex, match);

  1017.             if (n == NGX_OK) {
  1018.                 return reg[i].value;
  1019.             }

  1021.             if (n == NGX_DECLINED) {
  1022.                 continue;
  1023.             }

  1025.             /* NGX_ERROR */

  1027.             return NULL;
  1028.         }
  1029.     }

  1031. #endif

  1033.     return NULL;
  1034. }


  1037. #if (NGX_PCRE)

  1039. static ngx_int_t
  1040. ‌ngx_stream_variable_not_found(ngx_stream_session_t *s,
  1041.     ngx_stream_variable_value_t *v, uintptr_t data)
  1042. {
  1043.     v->not_found = 1;
  1044.     return NGX_OK;
  1045. }


  1048. ngx_stream_regex_t *
  1049. ‌ngx_stream_regex_compile(ngx_conf_t *cf, ngx_regex_compile_t *rc)
  1050. {
  1051.     u_char                       *p;
  1052.     size_t                        size;
  1053.     ngx_str_t                     name;
  1054.     ngx_uint_t                    i, n;
  1055.     ngx_stream_variable_t        *v;
  1056.     ngx_stream_regex_t           *re;
  1057.     ngx_stream_regex_variable_t  *rv;
  1058.     ngx_stream_core_main_conf_t  *cmcf;

  1060.     rc->pool = cf->pool;

  1062.     if (ngx_regex_compile(rc) != NGX_OK) {
  1063.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc->err);
  1064.         return NULL;
  1065.     }

  1067.     re = ngx_pcalloc(cf->pool, sizeof(ngx_stream_regex_t));
  1068.     if (re == NULL) {
  1069.         return NULL;
  1070.     }

  1072.     re->regex = rc->regex;
  1073.     re->ncaptures = rc->captures;
  1074.     re->name = rc->pattern;

  1076.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);
  1077.     cmcf->ncaptures = ngx_max(cmcf->ncaptures, re->ncaptures);

  1079.     n = (ngx_uint_t) rc->named_captures;

  1081.     if (n == 0) {
  1082.         return re;
  1083.     }

  1085.     rv = ngx_palloc(rc->pool, n * sizeof(ngx_stream_regex_variable_t));
  1086.     if (rv == NULL) {
  1087.         return NULL;
  1088.     }

  1090.     re->variables = rv;
  1091.     re->nvariables = n;

  1093.     size = rc->name_size;
  1094.     p = rc->names;

  1096.     for (i = 0; i < n; i++) {
  1097.         rv[i].capture = 2 * ((p[0] << 8) + p[1]);

  1099.         name.data = &p[2];
  1100.         name.len = ngx_strlen(name.data);

  1102.         v = ngx_stream_add_variable(cf, &name, NGX_STREAM_VAR_CHANGEABLE);
  1103.         if (v == NULL) {
  1104.             return NULL;
  1105.         }

  1107.         rv[i].index = ngx_stream_get_variable_index(cf, &name);
  1108.         if (rv[i].index == NGX_ERROR) {
  1109.             return NULL;
  1110.         }

  1112.         v->get_handler = ngx_stream_variable_not_found;

  1114.         p += size;
  1115.     }

  1117.     return re;
  1118. }


  1121. ngx_int_t
  1122. ‌ngx_stream_regex_exec(ngx_stream_session_t *s, ngx_stream_regex_t *re,
  1123.     ngx_str_t *str)
  1124. {
  1125.     ngx_int_t                     rc, index;
  1126.     ngx_uint_t                    i, n, len;
  1127.     ngx_stream_variable_value_t  *vv;
  1128.     ngx_stream_core_main_conf_t  *cmcf;

  1130.     cmcf = ngx_stream_get_module_main_conf(s, ngx_stream_core_module);

  1132.     if (re->ncaptures) {
  1133.         len = cmcf->ncaptures;

  1135.         if (s->captures == NULL) {
  1136.             s->captures = ngx_palloc(s->connection->pool, len * sizeof(int));
  1137.             if (s->captures == NULL) {
  1138.                 return NGX_ERROR;
  1139.             }
  1140.         }

  1142.     } else {
  1143.         len = 0;
  1144.     }

  1146.     rc = ngx_regex_exec(re->regex, str, s->captures, len);

  1148.     if (rc == NGX_REGEX_NO_MATCHED) {
  1149.         return NGX_DECLINED;
  1150.     }

  1152.     if (rc < 0) {
  1153.         ngx_log_error(NGX_LOG_ALERT, s->connection->log, 0,
  1154.                       ngx_regex_exec_n " failed: %i on \"%V\" using \"%V\"",
  1155.                       rc, str, &re->name);
  1156.         return NGX_ERROR;
  1157.     }

  1159.     for (i = 0; i < re->nvariables; i++) {

  1161.         n = re->variables[i].capture;
  1162.         index = re->variables[i].index;
  1163.         vv = &s->variables[index];

  1165.         vv->len = s->captures[n + 1] - s->captures[n];
  1166.         vv->valid = 1;
  1167.         vv->no_cacheable = 0;
  1168.         vv->not_found = 0;
  1169.         vv->data = &str->data[s->captures[n]];

  1171. #if (NGX_DEBUG)
  1172.         {
  1173.         ngx_stream_variable_t  *v;

  1175.         v = cmcf->variables.elts;

  1177.         ngx_log_debug2(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  1178.                        "stream regex set $%V to \"%v\"", &v[index].name, vv);
  1179.         }
  1180. #endif
  1181.     }

  1183.     s->ncaptures = rc * 2;
  1184.     s->captures_data = str->data;

  1186.     return NGX_OK;
  1187. }

  1189. #endif


  1192. ngx_int_t
  1193. ‌ngx_stream_variables_add_core_vars(ngx_conf_t *cf)
  1194. {
  1195.     ngx_stream_variable_t        *cv, *v;
  1196.     ngx_stream_core_main_conf_t  *cmcf;

  1198.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  1200.     cmcf->variables_keys = ngx_pcalloc(cf->temp_pool,
  1201.                                        sizeof(ngx_hash_keys_arrays_t));
  1202.     if (cmcf->variables_keys == NULL) {
  1203.         return NGX_ERROR;
  1204.     }

  1206.     cmcf->variables_keys->pool = cf->pool;
  1207.     cmcf->variables_keys->temp_pool = cf->pool;

  1209.     if (ngx_hash_keys_array_init(cmcf->variables_keys, NGX_HASH_SMALL)
  1210.         != NGX_OK)
  1211.     {
  1212.         return NGX_ERROR;
  1213.     }

  1215.     if (ngx_array_init(&cmcf->prefix_variables, cf->pool, 8,
  1216.                        sizeof(ngx_stream_variable_t))
  1217.         != NGX_OK)
  1218.     {
  1219.         return NGX_ERROR;
  1220.     }

  1222.     for (cv = ngx_stream_core_variables; cv->name.len; cv++) {
  1223.         v = ngx_stream_add_variable(cf, &cv->name, cv->flags);
  1224.         if (v == NULL) {
  1225.             return NGX_ERROR;
  1226.         }

  1228.         *v = *cv;
  1229.     }

  1231.     return NGX_OK;
  1232. }


  1235. ngx_int_t
  1236. ‌ngx_stream_variables_init_vars(ngx_conf_t *cf)
  1237. {
  1238.     size_t                        len;
  1239.     ngx_uint_t                    i, n;
  1240.     ngx_hash_key_t               *key;
  1241.     ngx_hash_init_t               hash;
  1242.     ngx_stream_variable_t        *v, *av, *pv;
  1243.     ngx_stream_core_main_conf_t  *cmcf;

  1245.     /* set the handlers for the indexed stream variables */

  1247.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  1249.     v = cmcf->variables.elts;
  1250.     pv = cmcf->prefix_variables.elts;
  1251.     key = cmcf->variables_keys->keys.elts;

  1253.     for (i = 0; i < cmcf->variables.nelts; i++) {

  1255.         for (n = 0; n < cmcf->variables_keys->keys.nelts; n++) {

  1257.             av = key[n].value;

  1259.             if (v[i].name.len == key[n].key.len
  1260.                 && ngx_strncmp(v[i].name.data, key[n].key.data, v[i].name.len)
  1261.                    == 0)
  1262.             {
  1263.                 v[i].get_handler = av->get_handler;
  1264.                 v[i].data = av->data;

  1266.                 av->flags |= NGX_STREAM_VAR_INDEXED;
  1267.                 v[i].flags = av->flags;

  1269.                 av->index = i;

  1271.                 if (av->get_handler == NULL
  1272.                     || (av->flags & NGX_STREAM_VAR_WEAK))
  1273.                 {
  1274.                     break;
  1275.                 }

  1277.                 goto next;
  1278.             }
  1279.         }

  1281.         len = 0;
  1282.         av = NULL;

  1284.         for (n = 0; n < cmcf->prefix_variables.nelts; n++) {
  1285.             if (v[i].name.len >= pv[n].name.len && v[i].name.len > len
  1286.                 && ngx_strncmp(v[i].name.data, pv[n].name.data, pv[n].name.len)
  1287.                    == 0)
  1288.             {
  1289.                 av = &pv[n];
  1290.                 len = pv[n].name.len;
  1291.             }
  1292.         }

  1294.         if (av) {
  1295.             v[i].get_handler = av->get_handler;
  1296.             v[i].data = (uintptr_t) &v[i].name;
  1297.             v[i].flags = av->flags;

  1299.             goto next;
  1300.          }

  1302.         if (v[i].get_handler == NULL) {
  1303.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1304.                           "unknown \"%V\" variable", &v[i].name);
  1305.             return NGX_ERROR;
  1306.         }

  1308.     next:
  1309.         continue;
  1310.     }


  1313.     for (n = 0; n < cmcf->variables_keys->keys.nelts; n++) {
  1314.         av = key[n].value;

  1316.         if (av->flags & NGX_STREAM_VAR_NOHASH) {
  1317.             key[n].key.data = NULL;
  1318.         }
  1319.     }


  1322.     hash.hash = &cmcf->variables_hash;
  1323.     hash.key = ngx_hash_key;
  1324.     hash.max_size = cmcf->variables_hash_max_size;
  1325.     hash.bucket_size = cmcf->variables_hash_bucket_size;
  1326.     hash.name = "variables_hash";
  1327.     hash.pool = cf->pool;
  1328.     hash.temp_pool = NULL;

  1330.     if (ngx_hash_init(&hash, cmcf->variables_keys->keys.elts,
  1331.                       cmcf->variables_keys->keys.nelts)
  1332.         != NGX_OK)
  1333.     {
  1334.         return NGX_ERROR;
  1335.     }

  1337.     cmcf->variables_keys = NULL;

  1339.     return NGX_OK;
  1340. }

One Level Up Top Level