One Level Up Top Level

src/http/ngx_http_variables.c - nginx-1.7.10

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


  14. static ngx_int_t ngx_http_variable_request(ngx_http_request_t *r,
  15.     ngx_http_variable_value_t *v, uintptr_t data);
  16. #if 0
  17. static void ngx_http_variable_request_set(ngx_http_request_t *r,
  18.     ngx_http_variable_value_t *v, uintptr_t data);
  19. #endif
  20. static ngx_int_t ngx_http_variable_request_get_size(ngx_http_request_t *r,
  21.     ngx_http_variable_value_t *v, uintptr_t data);
  22. static void ngx_http_variable_request_set_size(ngx_http_request_t *r,
  23.     ngx_http_variable_value_t *v, uintptr_t data);
  24. static ngx_int_t ngx_http_variable_header(ngx_http_request_t *r,
  25.     ngx_http_variable_value_t *v, uintptr_t data);

  27. static ngx_int_t ngx_http_variable_cookies(ngx_http_request_t *r,
  28.     ngx_http_variable_value_t *v, uintptr_t data);
  29. static ngx_int_t ngx_http_variable_headers(ngx_http_request_t *r,
  30.     ngx_http_variable_value_t *v, uintptr_t data);
  31. static ngx_int_t ngx_http_variable_headers_internal(ngx_http_request_t *r,
  32.     ngx_http_variable_value_t *v, uintptr_t data, u_char sep);

  34. static ngx_int_t ngx_http_variable_unknown_header_in(ngx_http_request_t *r,
  35.     ngx_http_variable_value_t *v, uintptr_t data);
  36. static ngx_int_t ngx_http_variable_unknown_header_out(ngx_http_request_t *r,
  37.     ngx_http_variable_value_t *v, uintptr_t data);
  38. static ngx_int_t ngx_http_variable_request_line(ngx_http_request_t *r,
  39.     ngx_http_variable_value_t *v, uintptr_t data);
  40. static ngx_int_t ngx_http_variable_cookie(ngx_http_request_t *r,
  41.     ngx_http_variable_value_t *v, uintptr_t data);
  42. static ngx_int_t ngx_http_variable_argument(ngx_http_request_t *r,
  43.     ngx_http_variable_value_t *v, uintptr_t data);
  44. #if (NGX_HAVE_TCP_INFO)
  45. static ngx_int_t ngx_http_variable_tcpinfo(ngx_http_request_t *r,
  46.     ngx_http_variable_value_t *v, uintptr_t data);
  47. #endif

  49. static ngx_int_t ngx_http_variable_content_length(ngx_http_request_t *r,
  50.     ngx_http_variable_value_t *v, uintptr_t data);
  51. static ngx_int_t ngx_http_variable_host(ngx_http_request_t *r,
  52.     ngx_http_variable_value_t *v, uintptr_t data);
  53. static ngx_int_t ngx_http_variable_binary_remote_addr(ngx_http_request_t *r,
  54.     ngx_http_variable_value_t *v, uintptr_t data);
  55. static ngx_int_t ngx_http_variable_remote_addr(ngx_http_request_t *r,
  56.     ngx_http_variable_value_t *v, uintptr_t data);
  57. static ngx_int_t ngx_http_variable_remote_port(ngx_http_request_t *r,
  58.     ngx_http_variable_value_t *v, uintptr_t data);
  59. static ngx_int_t ngx_http_variable_proxy_protocol_addr(ngx_http_request_t *r,
  60.     ngx_http_variable_value_t *v, uintptr_t data);
  61. static ngx_int_t ngx_http_variable_server_addr(ngx_http_request_t *r,
  62.     ngx_http_variable_value_t *v, uintptr_t data);
  63. static ngx_int_t ngx_http_variable_server_port(ngx_http_request_t *r,
  64.     ngx_http_variable_value_t *v, uintptr_t data);
  65. static ngx_int_t ngx_http_variable_scheme(ngx_http_request_t *r,
  66.     ngx_http_variable_value_t *v, uintptr_t data);
  67. static ngx_int_t ngx_http_variable_https(ngx_http_request_t *r,
  68.     ngx_http_variable_value_t *v, uintptr_t data);
  69. static void ngx_http_variable_set_args(ngx_http_request_t *r,
  70.     ngx_http_variable_value_t *v, uintptr_t data);
  71. static ngx_int_t ngx_http_variable_is_args(ngx_http_request_t *r,
  72.     ngx_http_variable_value_t *v, uintptr_t data);
  73. static ngx_int_t ngx_http_variable_document_root(ngx_http_request_t *r,
  74.     ngx_http_variable_value_t *v, uintptr_t data);
  75. static ngx_int_t ngx_http_variable_realpath_root(ngx_http_request_t *r,
  76.     ngx_http_variable_value_t *v, uintptr_t data);
  77. static ngx_int_t ngx_http_variable_request_filename(ngx_http_request_t *r,
  78.     ngx_http_variable_value_t *v, uintptr_t data);
  79. static ngx_int_t ngx_http_variable_server_name(ngx_http_request_t *r,
  80.     ngx_http_variable_value_t *v, uintptr_t data);
  81. static ngx_int_t ngx_http_variable_request_method(ngx_http_request_t *r,
  82.     ngx_http_variable_value_t *v, uintptr_t data);
  83. static ngx_int_t ngx_http_variable_remote_user(ngx_http_request_t *r,
  84.     ngx_http_variable_value_t *v, uintptr_t data);
  85. static ngx_int_t ngx_http_variable_bytes_sent(ngx_http_request_t *r,
  86.     ngx_http_variable_value_t *v, uintptr_t data);
  87. static ngx_int_t ngx_http_variable_body_bytes_sent(ngx_http_request_t *r,
  88.     ngx_http_variable_value_t *v, uintptr_t data);
  89. static ngx_int_t ngx_http_variable_pipe(ngx_http_request_t *r,
  90.     ngx_http_variable_value_t *v, uintptr_t data);
  91. static ngx_int_t ngx_http_variable_request_completion(ngx_http_request_t *r,
  92.     ngx_http_variable_value_t *v, uintptr_t data);
  93. static ngx_int_t ngx_http_variable_request_body(ngx_http_request_t *r,
  94.     ngx_http_variable_value_t *v, uintptr_t data);
  95. static ngx_int_t ngx_http_variable_request_body_file(ngx_http_request_t *r,
  96.     ngx_http_variable_value_t *v, uintptr_t data);
  97. static ngx_int_t ngx_http_variable_request_length(ngx_http_request_t *r,
  98.     ngx_http_variable_value_t *v, uintptr_t data);
  99. static ngx_int_t ngx_http_variable_request_time(ngx_http_request_t *r,
  100.     ngx_http_variable_value_t *v, uintptr_t data);
  101. static ngx_int_t ngx_http_variable_status(ngx_http_request_t *r,
  102.     ngx_http_variable_value_t *v, uintptr_t data);

  104. static ngx_int_t ngx_http_variable_sent_content_type(ngx_http_request_t *r,
  105.     ngx_http_variable_value_t *v, uintptr_t data);
  106. static ngx_int_t ngx_http_variable_sent_content_length(ngx_http_request_t *r,
  107.     ngx_http_variable_value_t *v, uintptr_t data);
  108. static ngx_int_t ngx_http_variable_sent_location(ngx_http_request_t *r,
  109.     ngx_http_variable_value_t *v, uintptr_t data);
  110. static ngx_int_t ngx_http_variable_sent_last_modified(ngx_http_request_t *r,
  111.     ngx_http_variable_value_t *v, uintptr_t data);
  112. static ngx_int_t ngx_http_variable_sent_connection(ngx_http_request_t *r,
  113.     ngx_http_variable_value_t *v, uintptr_t data);
  114. static ngx_int_t ngx_http_variable_sent_keep_alive(ngx_http_request_t *r,
  115.     ngx_http_variable_value_t *v, uintptr_t data);
  116. static ngx_int_t ngx_http_variable_sent_transfer_encoding(ngx_http_request_t *r,
  117.     ngx_http_variable_value_t *v, uintptr_t data);

  119. static ngx_int_t ngx_http_variable_connection(ngx_http_request_t *r,
  120.     ngx_http_variable_value_t *v, uintptr_t data);
  121. static ngx_int_t ngx_http_variable_connection_requests(ngx_http_request_t *r,
  122.     ngx_http_variable_value_t *v, uintptr_t data);

  124. static ngx_int_t ngx_http_variable_nginx_version(ngx_http_request_t *r,
  125.     ngx_http_variable_value_t *v, uintptr_t data);
  126. static ngx_int_t ngx_http_variable_hostname(ngx_http_request_t *r,
  127.     ngx_http_variable_value_t *v, uintptr_t data);
  128. static ngx_int_t ngx_http_variable_pid(ngx_http_request_t *r,
  129.     ngx_http_variable_value_t *v, uintptr_t data);
  130. static ngx_int_t ngx_http_variable_msec(ngx_http_request_t *r,
  131.     ngx_http_variable_value_t *v, uintptr_t data);
  132. static ngx_int_t ngx_http_variable_time_iso8601(ngx_http_request_t *r,
  133.     ngx_http_variable_value_t *v, uintptr_t data);
  134. static ngx_int_t ngx_http_variable_time_local(ngx_http_request_t *r,
  135.     ngx_http_variable_value_t *v, uintptr_t data);

  137. /*
  138. * TODO:
  139. *     Apache CGI: AUTH_TYPE, PATH_INFO (null), PATH_TRANSLATED
  140. *                 REMOTE_HOST (null), REMOTE_IDENT (null),
  141. *                 SERVER_SOFTWARE
  142. *
  143. *     Apache SSI: DOCUMENT_NAME, LAST_MODIFIED, USER_NAME (file owner)
  144. */

  146. /*
  147. * the $http_host, $http_user_agent, $http_referer, and $http_via
  148. * variables may be handled by generic
  149. * ngx_http_variable_unknown_header_in(), but for performance reasons
  150. * they are handled using dedicated entries
  151. */

  153. ‌static ngx_http_variable_t  ngx_http_core_variables[] = {

  155.     { ngx_string("http_host"), NULL, ngx_http_variable_header,
  156.       offsetof(ngx_http_request_t, headers_in.host), 0, 0 },

  158.     { ngx_string("http_user_agent"), NULL, ngx_http_variable_header,
  159.       offsetof(ngx_http_request_t, headers_in.user_agent), 0, 0 },

  161.     { ngx_string("http_referer"), NULL, ngx_http_variable_header,
  162.       offsetof(ngx_http_request_t, headers_in.referer), 0, 0 },

  164. #if (NGX_HTTP_GZIP)
  165.     { ngx_string("http_via"), NULL, ngx_http_variable_header,
  166.       offsetof(ngx_http_request_t, headers_in.via), 0, 0 },
  167. #endif

  169. #if (NGX_HTTP_X_FORWARDED_FOR)
  170.     { ngx_string("http_x_forwarded_for"), NULL, ngx_http_variable_headers,
  171.       offsetof(ngx_http_request_t, headers_in.x_forwarded_for), 0, 0 },
  172. #endif

  174.     { ngx_string("http_cookie"), NULL, ngx_http_variable_cookies,
  175.       offsetof(ngx_http_request_t, headers_in.cookies), 0, 0 },

  177.     { ngx_string("content_length"), NULL, ngx_http_variable_content_length,
  178.       0, 0, 0 },

  180.     { ngx_string("content_type"), NULL, ngx_http_variable_header,
  181.       offsetof(ngx_http_request_t, headers_in.content_type), 0, 0 },

  183.     { ngx_string("host"), NULL, ngx_http_variable_host, 0, 0, 0 },

  185.     { ngx_string("binary_remote_addr"), NULL,
  186.       ngx_http_variable_binary_remote_addr, 0, 0, 0 },

  188.     { ngx_string("remote_addr"), NULL, ngx_http_variable_remote_addr, 0, 0, 0 },

  190.     { ngx_string("remote_port"), NULL, ngx_http_variable_remote_port, 0, 0, 0 },

  192.     { ngx_string("proxy_protocol_addr"), NULL,
  193.       ngx_http_variable_proxy_protocol_addr, 0, 0, 0 },

  195.     { ngx_string("server_addr"), NULL, ngx_http_variable_server_addr, 0, 0, 0 },

  197.     { ngx_string("server_port"), NULL, ngx_http_variable_server_port, 0, 0, 0 },

  199.     { ngx_string("server_protocol"), NULL, ngx_http_variable_request,
  200.       offsetof(ngx_http_request_t, http_protocol), 0, 0 },

  202.     { ngx_string("scheme"), NULL, ngx_http_variable_scheme, 0, 0, 0 },

  204.     { ngx_string("https"), NULL, ngx_http_variable_https, 0, 0, 0 },

  206.     { ngx_string("request_uri"), NULL, ngx_http_variable_request,
  207.       offsetof(ngx_http_request_t, unparsed_uri), 0, 0 },

  209.     { ngx_string("uri"), NULL, ngx_http_variable_request,
  210.       offsetof(ngx_http_request_t, uri),
  211.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  213.     { ngx_string("document_uri"), NULL, ngx_http_variable_request,
  214.       offsetof(ngx_http_request_t, uri),
  215.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  217.     { ngx_string("request"), NULL, ngx_http_variable_request_line, 0, 0, 0 },

  219.     { ngx_string("document_root"), NULL,
  220.       ngx_http_variable_document_root, 0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  222.     { ngx_string("realpath_root"), NULL,
  223.       ngx_http_variable_realpath_root, 0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  225.     { ngx_string("query_string"), NULL, ngx_http_variable_request,
  226.       offsetof(ngx_http_request_t, args),
  227.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  229.     { ngx_string("args"),
  230.       ngx_http_variable_set_args,
  231.       ngx_http_variable_request,
  232.       offsetof(ngx_http_request_t, args),
  233.       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },

  235.     { ngx_string("is_args"), NULL, ngx_http_variable_is_args,
  236.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  238.     { ngx_string("request_filename"), NULL,
  239.       ngx_http_variable_request_filename, 0,
  240.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  242.     { ngx_string("server_name"), NULL, ngx_http_variable_server_name, 0, 0, 0 },

  244.     { ngx_string("request_method"), NULL,
  245.       ngx_http_variable_request_method, 0,
  246.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  248.     { ngx_string("remote_user"), NULL, ngx_http_variable_remote_user, 0, 0, 0 },

  250.     { ngx_string("bytes_sent"), NULL, ngx_http_variable_bytes_sent,
  251.       0, 0, 0 },

  253.     { ngx_string("body_bytes_sent"), NULL, ngx_http_variable_body_bytes_sent,
  254.       0, 0, 0 },

  256.     { ngx_string("pipe"), NULL, ngx_http_variable_pipe,
  257.       0, 0, 0 },

  259.     { ngx_string("request_completion"), NULL,
  260.       ngx_http_variable_request_completion,
  261.       0, 0, 0 },

  263.     { ngx_string("request_body"), NULL,
  264.       ngx_http_variable_request_body,
  265.       0, 0, 0 },

  267.     { ngx_string("request_body_file"), NULL,
  268.       ngx_http_variable_request_body_file,
  269.       0, 0, 0 },

  271.     { ngx_string("request_length"), NULL, ngx_http_variable_request_length,
  272.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  274.     { ngx_string("request_time"), NULL, ngx_http_variable_request_time,
  275.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  277.     { ngx_string("status"), NULL,
  278.       ngx_http_variable_status, 0,
  279.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  281.     { ngx_string("sent_http_content_type"), NULL,
  282.       ngx_http_variable_sent_content_type, 0, 0, 0 },

  284.     { ngx_string("sent_http_content_length"), NULL,
  285.       ngx_http_variable_sent_content_length, 0, 0, 0 },

  287.     { ngx_string("sent_http_location"), NULL,
  288.       ngx_http_variable_sent_location, 0, 0, 0 },

  290.     { ngx_string("sent_http_last_modified"), NULL,
  291.       ngx_http_variable_sent_last_modified, 0, 0, 0 },

  293.     { ngx_string("sent_http_connection"), NULL,
  294.       ngx_http_variable_sent_connection, 0, 0, 0 },

  296.     { ngx_string("sent_http_keep_alive"), NULL,
  297.       ngx_http_variable_sent_keep_alive, 0, 0, 0 },

  299.     { ngx_string("sent_http_transfer_encoding"), NULL,
  300.       ngx_http_variable_sent_transfer_encoding, 0, 0, 0 },

  302.     { ngx_string("sent_http_cache_control"), NULL, ngx_http_variable_headers,
  303.       offsetof(ngx_http_request_t, headers_out.cache_control), 0, 0 },

  305.     { ngx_string("limit_rate"), ngx_http_variable_request_set_size,
  306.       ngx_http_variable_request_get_size,
  307.       offsetof(ngx_http_request_t, limit_rate),
  308.       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },

  310.     { ngx_string("connection"), NULL,
  311.       ngx_http_variable_connection, 0, 0, 0 },

  313.     { ngx_string("connection_requests"), NULL,
  314.       ngx_http_variable_connection_requests, 0, 0, 0 },

  316.     { ngx_string("nginx_version"), NULL, ngx_http_variable_nginx_version,
  317.       0, 0, 0 },

  319.     { ngx_string("hostname"), NULL, ngx_http_variable_hostname,
  320.       0, 0, 0 },

  322.     { ngx_string("pid"), NULL, ngx_http_variable_pid,
  323.       0, 0, 0 },

  325.     { ngx_string("msec"), NULL, ngx_http_variable_msec,
  326.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  328.     { ngx_string("time_iso8601"), NULL, ngx_http_variable_time_iso8601,
  329.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  331.     { ngx_string("time_local"), NULL, ngx_http_variable_time_local,
  332.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  334. #if (NGX_HAVE_TCP_INFO)
  335.     { ngx_string("tcpinfo_rtt"), NULL, ngx_http_variable_tcpinfo,
  336.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  338.     { ngx_string("tcpinfo_rttvar"), NULL, ngx_http_variable_tcpinfo,
  339.       1, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  341.     { ngx_string("tcpinfo_snd_cwnd"), NULL, ngx_http_variable_tcpinfo,
  342.       2, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  344.     { ngx_string("tcpinfo_rcv_space"), NULL, ngx_http_variable_tcpinfo,
  345.       3, NGX_HTTP_VAR_NOCACHEABLE, 0 },
  346. #endif

  348.     { ngx_null_string, NULL, NULL, 0, 0, 0 }
  349. };


  352. ‌ngx_http_variable_value_t  ngx_http_variable_null_value =
  353.     ngx_http_variable("");
  354. ‌ngx_http_variable_value_t  ngx_http_variable_true_value =
  355.     ngx_http_variable("1");


  358. ngx_http_variable_t *
  359. ‌ngx_http_add_variable(ngx_conf_t *cf, ngx_str_t *name, ngx_uint_t flags)
  360. {
  361.     ngx_int_t                   rc;
  362.     ngx_uint_t                  i;
  363.     ngx_hash_key_t             *key;
  364.     ngx_http_variable_t        *v;
  365.     ngx_http_core_main_conf_t  *cmcf;

  367.     if (name->len == 0) {
  368.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  369.                            "invalid variable name \"$\"");
  370.         return NULL;
  371.     }

  373.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  375.     key = cmcf->variables_keys->keys.elts;
  376.     for (i = 0; i < cmcf->variables_keys->keys.nelts; i++) {
  377.         if (name->len != key[i].key.len
  378.             || ngx_strncasecmp(name->data, key[i].key.data, name->len) != 0)
  379.         {
  380.             continue;
  381.         }

  383.         v = key[i].value;

  385.         if (!(v->flags & NGX_HTTP_VAR_CHANGEABLE)) {
  386.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  387.                                "the duplicate \"%V\" variable", name);
  388.             return NULL;
  389.         }

  391.         return v;
  392.     }

  394.     v = ngx_palloc(cf->pool, sizeof(ngx_http_variable_t));
  395.     if (v == NULL) {
  396.         return NULL;
  397.     }

  399.     v->name.len = name->len;
  400.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  401.     if (v->name.data == NULL) {
  402.         return NULL;
  403.     }

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

  407.     v->set_handler = NULL;
  408.     v->get_handler = NULL;
  409.     v->data = 0;
  410.     v->flags = flags;
  411.     v->index = 0;

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

  415.     if (rc == NGX_ERROR) {
  416.         return NULL;
  417.     }

  419.     if (rc == NGX_BUSY) {
  420.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  421.                            "conflicting variable name \"%V\"", name);
  422.         return NULL;
  423.     }

  425.     return v;
  426. }


  429. ngx_int_t
  430. ‌ngx_http_get_variable_index(ngx_conf_t *cf, ngx_str_t *name)
  431. {
  432.     ngx_uint_t                  i;
  433.     ngx_http_variable_t        *v;
  434.     ngx_http_core_main_conf_t  *cmcf;

  436.     if (name->len == 0) {
  437.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  438.                            "invalid variable name \"$\"");
  439.         return NGX_ERROR;
  440.     }

  442.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  444.     v = cmcf->variables.elts;

  446.     if (v == NULL) {
  447.         if (ngx_array_init(&cmcf->variables, cf->pool, 4,
  448.                            sizeof(ngx_http_variable_t))
  449.             != NGX_OK)
  450.         {
  451.             return NGX_ERROR;
  452.         }

  454.     } else {
  455.         for (i = 0; i < cmcf->variables.nelts; i++) {
  456.             if (name->len != v[i].name.len
  457.                 || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
  458.             {
  459.                 continue;
  460.             }

  462.             return i;
  463.         }
  464.     }

  466.     v = ngx_array_push(&cmcf->variables);
  467.     if (v == NULL) {
  468.         return NGX_ERROR;
  469.     }

  471.     v->name.len = name->len;
  472.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  473.     if (v->name.data == NULL) {
  474.         return NGX_ERROR;
  475.     }

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

  479.     v->set_handler = NULL;
  480.     v->get_handler = NULL;
  481.     v->data = 0;
  482.     v->flags = 0;
  483.     v->index = cmcf->variables.nelts - 1;

  485.     return v->index;
  486. }


  489. ngx_http_variable_value_t *
  490. ‌ngx_http_get_indexed_variable(ngx_http_request_t *r, ngx_uint_t index)
  491. {
  492.     ngx_http_variable_t        *v;
  493.     ngx_http_core_main_conf_t  *cmcf;

  495.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  497.     if (cmcf->variables.nelts <= index) {
  498.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  499.                       "unknown variable index: %ui", index);
  500.         return NULL;
  501.     }

  503.     if (r->variables[index].not_found || r->variables[index].valid) {
  504.         return &r->variables[index];
  505.     }

  507.     v = cmcf->variables.elts;

  509.     if (v[index].get_handler(r, &r->variables[index], v[index].data)
  510.         == NGX_OK)
  511.     {
  512.         if (v[index].flags & NGX_HTTP_VAR_NOCACHEABLE) {
  513.             r->variables[index].no_cacheable = 1;
  514.         }

  516.         return &r->variables[index];
  517.     }

  519.     r->variables[index].valid = 0;
  520.     r->variables[index].not_found = 1;

  522.     return NULL;
  523. }


  526. ngx_http_variable_value_t *
  527. ‌ngx_http_get_flushed_variable(ngx_http_request_t *r, ngx_uint_t index)
  528. {
  529.     ngx_http_variable_value_t  *v;

  531.     v = &r->variables[index];

  533.     if (v->valid || v->not_found) {
  534.         if (!v->no_cacheable) {
  535.             return v;
  536.         }

  538.         v->valid = 0;
  539.         v->not_found = 0;
  540.     }

  542.     return ngx_http_get_indexed_variable(r, index);
  543. }


  546. ngx_http_variable_value_t *
  547. ‌ngx_http_get_variable(ngx_http_request_t *r, ngx_str_t *name, ngx_uint_t key)
  548. {
  549.     ngx_http_variable_t        *v;
  550.     ngx_http_variable_value_t  *vv;
  551.     ngx_http_core_main_conf_t  *cmcf;

  553.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  557.     if (v) {
  558.         if (v->flags & NGX_HTTP_VAR_INDEXED) {
  559.             return ngx_http_get_flushed_variable(r, v->index);

  561.         } else {

  563.             vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));

  565.             if (vv && v->get_handler(r, vv, v->data) == NGX_OK) {
  566.                 return vv;
  567.             }

  569.             return NULL;
  570.         }
  571.     }

  573.     vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
  574.     if (vv == NULL) {
  575.         return NULL;
  576.     }

  578.     if (ngx_strncmp(name->data, "http_", 5) == 0) {

  580.         if (ngx_http_variable_unknown_header_in(r, vv, (uintptr_t) name)
  581.             == NGX_OK)
  582.         {
  583.             return vv;
  584.         }

  586.         return NULL;
  587.     }

  589.     if (ngx_strncmp(name->data, "sent_http_", 10) == 0) {

  591.         if (ngx_http_variable_unknown_header_out(r, vv, (uintptr_t) name)
  592.             == NGX_OK)
  593.         {
  594.             return vv;
  595.         }

  597.         return NULL;
  598.     }

  600.     if (ngx_strncmp(name->data, "upstream_http_", 14) == 0) {

  602.         if (ngx_http_upstream_header_variable(r, vv, (uintptr_t) name)
  603.             == NGX_OK)
  604.         {
  605.             return vv;
  606.         }

  608.         return NULL;
  609.     }

  611.     if (ngx_strncmp(name->data, "cookie_", 7) == 0) {

  613.         if (ngx_http_variable_cookie(r, vv, (uintptr_t) name) == NGX_OK) {
  614.             return vv;
  615.         }

  617.         return NULL;
  618.     }

  620.     if (ngx_strncmp(name->data, "upstream_cookie_", 16) == 0) {

  622.         if (ngx_http_upstream_cookie_variable(r, vv, (uintptr_t) name)
  623.             == NGX_OK)
  624.         {
  625.             return vv;
  626.         }

  628.         return NULL;
  629.     }

  631.     if (ngx_strncmp(name->data, "arg_", 4) == 0) {

  633.         if (ngx_http_variable_argument(r, vv, (uintptr_t) name) == NGX_OK) {
  634.             return vv;
  635.         }

  637.         return NULL;
  638.     }

  640.     vv->not_found = 1;

  642.     return vv;
  643. }


  646. static ngx_int_t
  647. ‌ngx_http_variable_request(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  648.     uintptr_t data)
  649. {
  650.     ngx_str_t  *s;

  652.     s = (ngx_str_t *) ((char *) r + data);

  654.     if (s->data) {
  655.         v->len = s->len;
  656.         v->valid = 1;
  657.         v->no_cacheable = 0;
  658.         v->not_found = 0;
  659.         v->data = s->data;

  661.     } else {
  662.         v->not_found = 1;
  663.     }

  665.     return NGX_OK;
  666. }


  669. #if 0

  671. static void
  672. ngx_http_variable_request_set(ngx_http_request_t *r,
  673.     ngx_http_variable_value_t *v, uintptr_t data)
  674. {
  675.     ngx_str_t  *s;

  677.     s = (ngx_str_t *) ((char *) r + data);

  679.     s->len = v->len;
  680.     s->data = v->data;
  681. }

  683. #endif


  686. static ngx_int_t
  687. ‌ngx_http_variable_request_get_size(ngx_http_request_t *r,
  688.     ngx_http_variable_value_t *v, uintptr_t data)
  689. {
  690.     size_t  *sp;

  692.     sp = (size_t *) ((char *) r + data);

  694.     v->data = ngx_pnalloc(r->pool, NGX_SIZE_T_LEN);
  695.     if (v->data == NULL) {
  696.         return NGX_ERROR;
  697.     }

  699.     v->len = ngx_sprintf(v->data, "%uz", *sp) - v->data;
  700.     v->valid = 1;
  701.     v->no_cacheable = 0;
  702.     v->not_found = 0;

  704.     return NGX_OK;
  705. }


  708. static void
  709. ‌ngx_http_variable_request_set_size(ngx_http_request_t *r,
  710.     ngx_http_variable_value_t *v, uintptr_t data)
  711. {
  712.     ssize_t    s, *sp;
  713.     ngx_str_t  val;

  715.     val.len = v->len;
  716.     val.data = v->data;

  718.     s = ngx_parse_size(&val);

  720.     if (s == NGX_ERROR) {
  721.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  722.                       "invalid size \"%V\"", &val);
  723.         return;
  724.     }

  726.     sp = (ssize_t *) ((char *) r + data);

  728.     *sp = s;

  730.     return;
  731. }


  734. static ngx_int_t
  735. ‌ngx_http_variable_header(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  736.     uintptr_t data)
  737. {
  738.     ngx_table_elt_t  *h;

  740.     h = *(ngx_table_elt_t **) ((char *) r + data);

  742.     if (h) {
  743.         v->len = h->value.len;
  744.         v->valid = 1;
  745.         v->no_cacheable = 0;
  746.         v->not_found = 0;
  747.         v->data = h->value.data;

  749.     } else {
  750.         v->not_found = 1;
  751.     }

  753.     return NGX_OK;
  754. }


  757. static ngx_int_t
  758. ‌ngx_http_variable_cookies(ngx_http_request_t *r,
  759.     ngx_http_variable_value_t *v, uintptr_t data)
  760. {
  761.     return ngx_http_variable_headers_internal(r, v, data, ';');
  762. }


  765. static ngx_int_t
  766. ‌ngx_http_variable_headers(ngx_http_request_t *r,
  767.     ngx_http_variable_value_t *v, uintptr_t data)
  768. {
  769.     return ngx_http_variable_headers_internal(r, v, data, ',');
  770. }


  773. static ngx_int_t
  774. ‌ngx_http_variable_headers_internal(ngx_http_request_t *r,
  775.     ngx_http_variable_value_t *v, uintptr_t data, u_char sep)
  776. {
  777.     size_t             len;
  778.     u_char            *p, *end;
  779.     ngx_uint_t         i, n;
  780.     ngx_array_t       *a;
  781.     ngx_table_elt_t  **h;

  783.     a = (ngx_array_t *) ((char *) r + data);

  785.     n = a->nelts;
  786.     h = a->elts;

  788.     len = 0;

  790.     for (i = 0; i < n; i++) {

  792.         if (h[i]->hash == 0) {
  793.             continue;
  794.         }

  796.         len += h[i]->value.len + 2;
  797.     }

  799.     if (len == 0) {
  800.         v->not_found = 1;
  801.         return NGX_OK;
  802.     }

  804.     len -= 2;

  806.     v->valid = 1;
  807.     v->no_cacheable = 0;
  808.     v->not_found = 0;

  810.     if (n == 1) {
  811.         v->len = (*h)->value.len;
  812.         v->data = (*h)->value.data;

  814.         return NGX_OK;
  815.     }

  817.     p = ngx_pnalloc(r->pool, len);
  818.     if (p == NULL) {
  819.         return NGX_ERROR;
  820.     }

  822.     v->len = len;
  823.     v->data = p;

  825.     end = p + len;

  827.     for (i = 0; /* void */ ; i++) {

  829.         if (h[i]->hash == 0) {
  830.             continue;
  831.         }

  833.         p = ngx_copy(p, h[i]->value.data, h[i]->value.len);

  835.         if (p == end) {
  836.             break;
  837.         }

  839.         *p++ = sep; *p++ = ' ';
  840.     }

  842.     return NGX_OK;
  843. }


  846. static ngx_int_t
  847. ‌ngx_http_variable_unknown_header_in(ngx_http_request_t *r,
  848.     ngx_http_variable_value_t *v, uintptr_t data)
  849. {
  850.     return ngx_http_variable_unknown_header(v, (ngx_str_t *) data,
  851.                                             &r->headers_in.headers.part,
  852.                                             sizeof("http_") - 1);
  853. }


  856. static ngx_int_t
  857. ‌ngx_http_variable_unknown_header_out(ngx_http_request_t *r,
  858.     ngx_http_variable_value_t *v, uintptr_t data)
  859. {
  860.     return ngx_http_variable_unknown_header(v, (ngx_str_t *) data,
  861.                                             &r->headers_out.headers.part,
  862.                                             sizeof("sent_http_") - 1);
  863. }


  866. ngx_int_t
  867. ‌ngx_http_variable_unknown_header(ngx_http_variable_value_t *v, ngx_str_t *var,
  868.     ngx_list_part_t *part, size_t prefix)
  869. {
  870.     u_char            ch;
  871.     ngx_uint_t        i, n;
  872.     ngx_table_elt_t  *header;

  874.     header = part->elts;

  876.     for (i = 0; /* void */ ; i++) {

  878.         if (i >= part->nelts) {
  879.             if (part->next == NULL) {
  880.                 break;
  881.             }

  883.             part = part->next;
  884.             header = part->elts;
  885.             i = 0;
  886.         }

  888.         if (header[i].hash == 0) {
  889.             continue;
  890.         }

  892.         for (n = 0; n + prefix < var->len && n < header[i].key.len; n++) {
  893.             ch = header[i].key.data[n];

  895.             if (ch >= 'A' && ch <= 'Z') {
  896.                 ch |= 0x20;

  898.             } else if (ch == '-') {
  899.                 ch = '_';
  900.             }

  902.             if (var->data[n + prefix] != ch) {
  903.                 break;
  904.             }
  905.         }

  907.         if (n + prefix == var->len && n == header[i].key.len) {
  908.             v->len = header[i].value.len;
  909.             v->valid = 1;
  910.             v->no_cacheable = 0;
  911.             v->not_found = 0;
  912.             v->data = header[i].value.data;

  914.             return NGX_OK;
  915.         }
  916.     }

  918.     v->not_found = 1;

  920.     return NGX_OK;
  921. }


  924. static ngx_int_t
  925. ‌ngx_http_variable_request_line(ngx_http_request_t *r,
  926.     ngx_http_variable_value_t *v, uintptr_t data)
  927. {
  928.     u_char  *p, *s;

  930.     s = r->request_line.data;

  932.     if (s == NULL) {
  933.         s = r->request_start;

  935.         if (s == NULL) {
  936.             v->not_found = 1;
  937.             return NGX_OK;
  938.         }

  940.         for (p = s; p < r->header_in->last; p++) {
  941.             if (*p == CR || *p == LF) {
  942.                 break;
  943.             }
  944.         }

  946.         r->request_line.len = p - s;
  947.         r->request_line.data = s;
  948.     }

  950.     v->len = r->request_line.len;
  951.     v->valid = 1;
  952.     v->no_cacheable = 0;
  953.     v->not_found = 0;
  954.     v->data = s;

  956.     return NGX_OK;
  957. }


  960. static ngx_int_t
  961. ‌ngx_http_variable_cookie(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  962.     uintptr_t data)
  963. {
  964.     ngx_str_t *name = (ngx_str_t *) data;

  966.     ngx_str_t  cookie, s;

  968.     s.len = name->len - (sizeof("cookie_") - 1);
  969.     s.data = name->data + sizeof("cookie_") - 1;

  971.     if (ngx_http_parse_multi_header_lines(&r->headers_in.cookies, &s, &cookie)
  972.         == NGX_DECLINED)
  973.     {
  974.         v->not_found = 1;
  975.         return NGX_OK;
  976.     }

  978.     v->len = cookie.len;
  979.     v->valid = 1;
  980.     v->no_cacheable = 0;
  981.     v->not_found = 0;
  982.     v->data = cookie.data;

  984.     return NGX_OK;
  985. }


  988. static ngx_int_t
  989. ‌ngx_http_variable_argument(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  990.     uintptr_t data)
  991. {
  992.     ngx_str_t *name = (ngx_str_t *) data;

  994.     u_char     *arg;
  995.     size_t      len;
  996.     ngx_str_t   value;

  998.     len = name->len - (sizeof("arg_") - 1);
  999.     arg = name->data + sizeof("arg_") - 1;

  1001.     if (ngx_http_arg(r, arg, len, &value) != NGX_OK) {
  1002.         v->not_found = 1;
  1003.         return NGX_OK;
  1004.     }

  1006.     v->data = value.data;
  1007.     v->len = value.len;
  1008.     v->valid = 1;
  1009.     v->no_cacheable = 0;
  1010.     v->not_found = 0;

  1012.     return NGX_OK;
  1013. }


  1016. #if (NGX_HAVE_TCP_INFO)

  1018. static ngx_int_t
  1019. ‌ngx_http_variable_tcpinfo(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1020.     uintptr_t data)
  1021. {
  1022.     struct tcp_info  ti;
  1023.     socklen_t        len;
  1024.     uint32_t         value;

  1026.     len = sizeof(struct tcp_info);
  1027.     if (getsockopt(r->connection->fd, IPPROTO_TCP, TCP_INFO, &ti, &len) == -1) {
  1028.         v->not_found = 1;
  1029.         return NGX_OK;
  1030.     }

  1032.     v->data = ngx_pnalloc(r->pool, NGX_INT32_LEN);
  1033.     if (v->data == NULL) {
  1034.         return NGX_ERROR;
  1035.     }

  1037.     switch (data) {
  1038.     case 0:
  1039.         value = ti.tcpi_rtt;
  1040.         break;

  1042.     case 1:
  1043.         value = ti.tcpi_rttvar;
  1044.         break;

  1046.     case 2:
  1047.         value = ti.tcpi_snd_cwnd;
  1048.         break;

  1050.     case 3:
  1051.         value = ti.tcpi_rcv_space;
  1052.         break;

  1054.     /* suppress warning */
  1055.     default:
  1056.         value = 0;
  1057.         break;
  1058.     }

  1060.     v->len = ngx_sprintf(v->data, "%uD", value) - v->data;
  1061.     v->valid = 1;
  1062.     v->no_cacheable = 0;
  1063.     v->not_found = 0;

  1065.     return NGX_OK;
  1066. }

  1068. #endif


  1071. static ngx_int_t
  1072. ‌ngx_http_variable_content_length(ngx_http_request_t *r,
  1073.     ngx_http_variable_value_t *v, uintptr_t data)
  1074. {
  1075.     u_char  *p;

  1077.     if (r->headers_in.content_length) {
  1078.         v->len = r->headers_in.content_length->value.len;
  1079.         v->data = r->headers_in.content_length->value.data;
  1080.         v->valid = 1;
  1081.         v->no_cacheable = 0;
  1082.         v->not_found = 0;

  1084.     } else if (r->headers_in.content_length_n >= 0) {
  1085.         p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1086.         if (p == NULL) {
  1087.             return NGX_ERROR;
  1088.         }

  1090.         v->len = ngx_sprintf(p, "%O", r->headers_in.content_length_n) - p;
  1091.         v->data = p;
  1092.         v->valid = 1;
  1093.         v->no_cacheable = 0;
  1094.         v->not_found = 0;

  1096.     } else {
  1097.         v->not_found = 1;
  1098.     }

  1100.     return NGX_OK;
  1101. }


  1104. static ngx_int_t
  1105. ‌ngx_http_variable_host(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1106.     uintptr_t data)
  1107. {
  1108.     ngx_http_core_srv_conf_t  *cscf;

  1110.     if (r->headers_in.server.len) {
  1111.         v->len = r->headers_in.server.len;
  1112.         v->data = r->headers_in.server.data;

  1114.     } else {
  1115.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1117.         v->len = cscf->server_name.len;
  1118.         v->data = cscf->server_name.data;
  1119.     }

  1121.     v->valid = 1;
  1122.     v->no_cacheable = 0;
  1123.     v->not_found = 0;

  1125.     return NGX_OK;
  1126. }


  1129. static ngx_int_t
  1130. ‌ngx_http_variable_binary_remote_addr(ngx_http_request_t *r,
  1131.     ngx_http_variable_value_t *v, uintptr_t data)
  1132. {
  1133.     struct sockaddr_in   *sin;
  1134. #if (NGX_HAVE_INET6)
  1135.     struct sockaddr_in6  *sin6;
  1136. #endif

  1138.     switch (r->connection->sockaddr->sa_family) {

  1140. #if (NGX_HAVE_INET6)
  1141.     case AF_INET6:
  1142.         sin6 = (struct sockaddr_in6 *) r->connection->sockaddr;

  1144.         v->len = sizeof(struct in6_addr);
  1145.         v->valid = 1;
  1146.         v->no_cacheable = 0;
  1147.         v->not_found = 0;
  1148.         v->data = sin6->sin6_addr.s6_addr;

  1150.         break;
  1151. #endif

  1153.     default: /* AF_INET */
  1154.         sin = (struct sockaddr_in *) r->connection->sockaddr;

  1156.         v->len = sizeof(in_addr_t);
  1157.         v->valid = 1;
  1158.         v->no_cacheable = 0;
  1159.         v->not_found = 0;
  1160.         v->data = (u_char *) &sin->sin_addr;

  1162.         break;
  1163.     }

  1165.     return NGX_OK;
  1166. }


  1169. static ngx_int_t
  1170. ‌ngx_http_variable_remote_addr(ngx_http_request_t *r,
  1171.     ngx_http_variable_value_t *v, uintptr_t data)
  1172. {
  1173.     v->len = r->connection->addr_text.len;
  1174.     v->valid = 1;
  1175.     v->no_cacheable = 0;
  1176.     v->not_found = 0;
  1177.     v->data = r->connection->addr_text.data;

  1179.     return NGX_OK;
  1180. }


  1183. static ngx_int_t
  1184. ‌ngx_http_variable_remote_port(ngx_http_request_t *r,
  1185.     ngx_http_variable_value_t *v, uintptr_t data)
  1186. {
  1187.     ngx_uint_t            port;
  1188.     struct sockaddr_in   *sin;
  1189. #if (NGX_HAVE_INET6)
  1190.     struct sockaddr_in6  *sin6;
  1191. #endif

  1193.     v->len = 0;
  1194.     v->valid = 1;
  1195.     v->no_cacheable = 0;
  1196.     v->not_found = 0;

  1198.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1199.     if (v->data == NULL) {
  1200.         return NGX_ERROR;
  1201.     }

  1203.     switch (r->connection->sockaddr->sa_family) {

  1205. #if (NGX_HAVE_INET6)
  1206.     case AF_INET6:
  1207.         sin6 = (struct sockaddr_in6 *) r->connection->sockaddr;
  1208.         port = ntohs(sin6->sin6_port);
  1209.         break;
  1210. #endif

  1212. #if (NGX_HAVE_UNIX_DOMAIN)
  1213.     case AF_UNIX:
  1214.         port = 0;
  1215.         break;
  1216. #endif

  1218.     default: /* AF_INET */
  1219.         sin = (struct sockaddr_in *) r->connection->sockaddr;
  1220.         port = ntohs(sin->sin_port);
  1221.         break;
  1222.     }

  1224.     if (port > 0 && port < 65536) {
  1225.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1226.     }

  1228.     return NGX_OK;
  1229. }


  1232. static ngx_int_t
  1233. ‌ngx_http_variable_proxy_protocol_addr(ngx_http_request_t *r,
  1234.     ngx_http_variable_value_t *v, uintptr_t data)
  1235. {
  1236.     v->len = r->connection->proxy_protocol_addr.len;
  1237.     v->valid = 1;
  1238.     v->no_cacheable = 0;
  1239.     v->not_found = 0;
  1240.     v->data = r->connection->proxy_protocol_addr.data;

  1242.     return NGX_OK;
  1243. }


  1246. static ngx_int_t
  1247. ‌ngx_http_variable_server_addr(ngx_http_request_t *r,
  1248.     ngx_http_variable_value_t *v, uintptr_t data)
  1249. {
  1250.     ngx_str_t  s;
  1251.     u_char     addr[NGX_SOCKADDR_STRLEN];

  1253.     s.len = NGX_SOCKADDR_STRLEN;
  1254.     s.data = addr;

  1256.     if (ngx_connection_local_sockaddr(r->connection, &s, 0) != NGX_OK) {
  1257.         return NGX_ERROR;
  1258.     }

  1260.     s.data = ngx_pnalloc(r->pool, s.len);
  1261.     if (s.data == NULL) {
  1262.         return NGX_ERROR;
  1263.     }

  1265.     ngx_memcpy(s.data, addr, s.len);

  1267.     v->len = s.len;
  1268.     v->valid = 1;
  1269.     v->no_cacheable = 0;
  1270.     v->not_found = 0;
  1271.     v->data = s.data;

  1273.     return NGX_OK;
  1274. }


  1277. static ngx_int_t
  1278. ‌ngx_http_variable_server_port(ngx_http_request_t *r,
  1279.     ngx_http_variable_value_t *v, uintptr_t data)
  1280. {
  1281.     ngx_uint_t            port;
  1282.     struct sockaddr_in   *sin;
  1283. #if (NGX_HAVE_INET6)
  1284.     struct sockaddr_in6  *sin6;
  1285. #endif

  1287.     v->len = 0;
  1288.     v->valid = 1;
  1289.     v->no_cacheable = 0;
  1290.     v->not_found = 0;

  1292.     if (ngx_connection_local_sockaddr(r->connection, NULL, 0) != NGX_OK) {
  1293.         return NGX_ERROR;
  1294.     }

  1296.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1297.     if (v->data == NULL) {
  1298.         return NGX_ERROR;
  1299.     }

  1301.     switch (r->connection->local_sockaddr->sa_family) {

  1303. #if (NGX_HAVE_INET6)
  1304.     case AF_INET6:
  1305.         sin6 = (struct sockaddr_in6 *) r->connection->local_sockaddr;
  1306.         port = ntohs(sin6->sin6_port);
  1307.         break;
  1308. #endif

  1310. #if (NGX_HAVE_UNIX_DOMAIN)
  1311.     case AF_UNIX:
  1312.         port = 0;
  1313.         break;
  1314. #endif

  1316.     default: /* AF_INET */
  1317.         sin = (struct sockaddr_in *) r->connection->local_sockaddr;
  1318.         port = ntohs(sin->sin_port);
  1319.         break;
  1320.     }

  1322.     if (port > 0 && port < 65536) {
  1323.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1324.     }

  1326.     return NGX_OK;
  1327. }


  1330. static ngx_int_t
  1331. ‌ngx_http_variable_scheme(ngx_http_request_t *r,
  1332.     ngx_http_variable_value_t *v, uintptr_t data)
  1333. {
  1334. #if (NGX_HTTP_SSL)

  1336.     if (r->connection->ssl) {
  1337.         v->len = sizeof("https") - 1;
  1338.         v->valid = 1;
  1339.         v->no_cacheable = 0;
  1340.         v->not_found = 0;
  1341.         v->data = (u_char *) "https";

  1343.         return NGX_OK;
  1344.     }

  1346. #endif

  1348.     v->len = sizeof("http") - 1;
  1349.     v->valid = 1;
  1350.     v->no_cacheable = 0;
  1351.     v->not_found = 0;
  1352.     v->data = (u_char *) "http";

  1354.     return NGX_OK;
  1355. }


  1358. static ngx_int_t
  1359. ‌ngx_http_variable_https(ngx_http_request_t *r,
  1360.     ngx_http_variable_value_t *v, uintptr_t data)
  1361. {
  1362. #if (NGX_HTTP_SSL)

  1364.     if (r->connection->ssl) {
  1365.         v->len = sizeof("on") - 1;
  1366.         v->valid = 1;
  1367.         v->no_cacheable = 0;
  1368.         v->not_found = 0;
  1369.         v->data = (u_char *) "on";

  1371.         return NGX_OK;
  1372.     }

  1374. #endif

  1376.     *v = ngx_http_variable_null_value;

  1378.     return NGX_OK;
  1379. }


  1382. static void
  1383. ‌ngx_http_variable_set_args(ngx_http_request_t *r,
  1384.     ngx_http_variable_value_t *v, uintptr_t data)
  1385. {
  1386.     r->args.len = v->len;
  1387.     r->args.data = v->data;
  1388.     r->valid_unparsed_uri = 0;
  1389. }


  1392. static ngx_int_t
  1393. ‌ngx_http_variable_is_args(ngx_http_request_t *r,
  1394.     ngx_http_variable_value_t *v, uintptr_t data)
  1395. {
  1396.     v->valid = 1;
  1397.     v->no_cacheable = 0;
  1398.     v->not_found = 0;

  1400.     if (r->args.len == 0) {
  1401.         v->len = 0;
  1402.         v->data = NULL;
  1403.         return NGX_OK;
  1404.     }

  1406.     v->len = 1;
  1407.     v->data = (u_char *) "?";

  1409.     return NGX_OK;
  1410. }


  1413. static ngx_int_t
  1414. ‌ngx_http_variable_document_root(ngx_http_request_t *r,
  1415.     ngx_http_variable_value_t *v, uintptr_t data)
  1416. {
  1417.     ngx_str_t                  path;
  1418.     ngx_http_core_loc_conf_t  *clcf;

  1420.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1422.     if (clcf->root_lengths == NULL) {
  1423.         v->len = clcf->root.len;
  1424.         v->valid = 1;
  1425.         v->no_cacheable = 0;
  1426.         v->not_found = 0;
  1427.         v->data = clcf->root.data;

  1429.     } else {
  1430.         if (ngx_http_script_run(r, &path, clcf->root_lengths->elts, 0,
  1431.                                 clcf->root_values->elts)
  1432.             == NULL)
  1433.         {
  1434.             return NGX_ERROR;
  1435.         }

  1437.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, &path)
  1438.             != NGX_OK)
  1439.         {
  1440.             return NGX_ERROR;
  1441.         }

  1443.         v->len = path.len;
  1444.         v->valid = 1;
  1445.         v->no_cacheable = 0;
  1446.         v->not_found = 0;
  1447.         v->data = path.data;
  1448.     }

  1450.     return NGX_OK;
  1451. }


  1454. static ngx_int_t
  1455. ‌ngx_http_variable_realpath_root(ngx_http_request_t *r,
  1456.     ngx_http_variable_value_t *v, uintptr_t data)
  1457. {
  1458.     u_char                    *real;
  1459.     size_t                     len;
  1460.     ngx_str_t                  path;
  1461.     ngx_http_core_loc_conf_t  *clcf;
  1462. #if (NGX_HAVE_MAX_PATH)
  1463.     u_char                     buffer[NGX_MAX_PATH];
  1464. #endif

  1466.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1468.     if (clcf->root_lengths == NULL) {
  1469.         path = clcf->root;

  1471.     } else {
  1472.         if (ngx_http_script_run(r, &path, clcf->root_lengths->elts, 1,
  1473.                                 clcf->root_values->elts)
  1474.             == NULL)
  1475.         {
  1476.             return NGX_ERROR;
  1477.         }

  1479.         path.data[path.len - 1] = '\0';

  1481.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, &path)
  1482.             != NGX_OK)
  1483.         {
  1484.             return NGX_ERROR;
  1485.         }
  1486.     }

  1488. #if (NGX_HAVE_MAX_PATH)
  1489.     real = buffer;
  1490. #else
  1491.     real = NULL;
  1492. #endif

  1494.     real = ngx_realpath(path.data, real);

  1496.     if (real == NULL) {
  1497.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  1498.                       ngx_realpath_n " \"%s\" failed", path.data);
  1499.         return NGX_ERROR;
  1500.     }

  1502.     len = ngx_strlen(real);

  1504.     v->data = ngx_pnalloc(r->pool, len);
  1505.     if (v->data == NULL) {
  1506. #if !(NGX_HAVE_MAX_PATH)
  1507.         ngx_free(real);
  1508. #endif
  1509.         return NGX_ERROR;
  1510.     }

  1512.     v->len = len;
  1513.     v->valid = 1;
  1514.     v->no_cacheable = 0;
  1515.     v->not_found = 0;

  1517.     ngx_memcpy(v->data, real, len);

  1519. #if !(NGX_HAVE_MAX_PATH)
  1520.     ngx_free(real);
  1521. #endif

  1523.     return NGX_OK;
  1524. }


  1527. static ngx_int_t
  1528. ‌ngx_http_variable_request_filename(ngx_http_request_t *r,
  1529.     ngx_http_variable_value_t *v, uintptr_t data)
  1530. {
  1531.     size_t     root;
  1532.     ngx_str_t  path;

  1534.     if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
  1535.         return NGX_ERROR;
  1536.     }

  1538.     /* ngx_http_map_uri_to_path() allocates memory for terminating '\0' */

  1540.     v->len = path.len - 1;
  1541.     v->valid = 1;
  1542.     v->no_cacheable = 0;
  1543.     v->not_found = 0;
  1544.     v->data = path.data;

  1546.     return NGX_OK;
  1547. }


  1550. static ngx_int_t
  1551. ‌ngx_http_variable_server_name(ngx_http_request_t *r,
  1552.     ngx_http_variable_value_t *v, uintptr_t data)
  1553. {
  1554.     ngx_http_core_srv_conf_t  *cscf;

  1556.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1558.     v->len = cscf->server_name.len;
  1559.     v->valid = 1;
  1560.     v->no_cacheable = 0;
  1561.     v->not_found = 0;
  1562.     v->data = cscf->server_name.data;

  1564.     return NGX_OK;
  1565. }


  1568. static ngx_int_t
  1569. ‌ngx_http_variable_request_method(ngx_http_request_t *r,
  1570.     ngx_http_variable_value_t *v, uintptr_t data)
  1571. {
  1572.     if (r->main->method_name.data) {
  1573.         v->len = r->main->method_name.len;
  1574.         v->valid = 1;
  1575.         v->no_cacheable = 0;
  1576.         v->not_found = 0;
  1577.         v->data = r->main->method_name.data;

  1579.     } else {
  1580.         v->not_found = 1;
  1581.     }

  1583.     return NGX_OK;
  1584. }


  1587. static ngx_int_t
  1588. ‌ngx_http_variable_remote_user(ngx_http_request_t *r,
  1589.     ngx_http_variable_value_t *v, uintptr_t data)
  1590. {
  1591.     ngx_int_t  rc;

  1593.     rc = ngx_http_auth_basic_user(r);

  1595.     if (rc == NGX_DECLINED) {
  1596.         v->not_found = 1;
  1597.         return NGX_OK;
  1598.     }

  1600.     if (rc == NGX_ERROR) {
  1601.         return NGX_ERROR;
  1602.     }

  1604.     v->len = r->headers_in.user.len;
  1605.     v->valid = 1;
  1606.     v->no_cacheable = 0;
  1607.     v->not_found = 0;
  1608.     v->data = r->headers_in.user.data;

  1610.     return NGX_OK;
  1611. }


  1614. static ngx_int_t
  1615. ‌ngx_http_variable_bytes_sent(ngx_http_request_t *r,
  1616.     ngx_http_variable_value_t *v, uintptr_t data)
  1617. {
  1618.     u_char  *p;

  1620.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1621.     if (p == NULL) {
  1622.         return NGX_ERROR;
  1623.     }

  1625.     v->len = ngx_sprintf(p, "%O", r->connection->sent) - p;
  1626.     v->valid = 1;
  1627.     v->no_cacheable = 0;
  1628.     v->not_found = 0;
  1629.     v->data = p;

  1631.     return NGX_OK;
  1632. }


  1635. static ngx_int_t
  1636. ‌ngx_http_variable_body_bytes_sent(ngx_http_request_t *r,
  1637.     ngx_http_variable_value_t *v, uintptr_t data)
  1638. {
  1639.     off_t    sent;
  1640.     u_char  *p;

  1642.     sent = r->connection->sent - r->header_size;

  1644.     if (sent < 0) {
  1645.         sent = 0;
  1646.     }

  1648.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1649.     if (p == NULL) {
  1650.         return NGX_ERROR;
  1651.     }

  1653.     v->len = ngx_sprintf(p, "%O", sent) - p;
  1654.     v->valid = 1;
  1655.     v->no_cacheable = 0;
  1656.     v->not_found = 0;
  1657.     v->data = p;

  1659.     return NGX_OK;
  1660. }


  1663. static ngx_int_t
  1664. ‌ngx_http_variable_pipe(ngx_http_request_t *r,
  1665.     ngx_http_variable_value_t *v, uintptr_t data)
  1666. {
  1667.     v->data = (u_char *) (r->pipeline ? "p" : ".");
  1668.     v->len = 1;
  1669.     v->valid = 1;
  1670.     v->no_cacheable = 0;
  1671.     v->not_found = 0;

  1673.     return NGX_OK;
  1674. }


  1677. static ngx_int_t
  1678. ‌ngx_http_variable_status(ngx_http_request_t *r,
  1679.     ngx_http_variable_value_t *v, uintptr_t data)
  1680. {
  1681.     ngx_uint_t  status;

  1683.     v->data = ngx_pnalloc(r->pool, NGX_INT_T_LEN);
  1684.     if (v->data == NULL) {
  1685.         return NGX_ERROR;
  1686.     }

  1688.     if (r->err_status) {
  1689.         status = r->err_status;

  1691.     } else if (r->headers_out.status) {
  1692.         status = r->headers_out.status;

  1694.     } else if (r->http_version == NGX_HTTP_VERSION_9) {
  1695.         status = 9;

  1697.     } else {
  1698.         status = 0;
  1699.     }

  1701.     v->len = ngx_sprintf(v->data, "%03ui", status) - v->data;
  1702.     v->valid = 1;
  1703.     v->no_cacheable = 0;
  1704.     v->not_found = 0;

  1706.     return NGX_OK;
  1707. }


  1710. static ngx_int_t
  1711. ‌ngx_http_variable_sent_content_type(ngx_http_request_t *r,
  1712.     ngx_http_variable_value_t *v, uintptr_t data)
  1713. {
  1714.     if (r->headers_out.content_type.len) {
  1715.         v->len = r->headers_out.content_type.len;
  1716.         v->valid = 1;
  1717.         v->no_cacheable = 0;
  1718.         v->not_found = 0;
  1719.         v->data = r->headers_out.content_type.data;

  1721.     } else {
  1722.         v->not_found = 1;
  1723.     }

  1725.     return NGX_OK;
  1726. }


  1729. static ngx_int_t
  1730. ‌ngx_http_variable_sent_content_length(ngx_http_request_t *r,
  1731.     ngx_http_variable_value_t *v, uintptr_t data)
  1732. {
  1733.     u_char  *p;

  1735.     if (r->headers_out.content_length) {
  1736.         v->len = r->headers_out.content_length->value.len;
  1737.         v->valid = 1;
  1738.         v->no_cacheable = 0;
  1739.         v->not_found = 0;
  1740.         v->data = r->headers_out.content_length->value.data;

  1742.         return NGX_OK;
  1743.     }

  1745.     if (r->headers_out.content_length_n >= 0) {
  1746.         p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1747.         if (p == NULL) {
  1748.             return NGX_ERROR;
  1749.         }

  1751.         v->len = ngx_sprintf(p, "%O", r->headers_out.content_length_n) - p;
  1752.         v->valid = 1;
  1753.         v->no_cacheable = 0;
  1754.         v->not_found = 0;
  1755.         v->data = p;

  1757.         return NGX_OK;
  1758.     }

  1760.     v->not_found = 1;

  1762.     return NGX_OK;
  1763. }


  1766. static ngx_int_t
  1767. ‌ngx_http_variable_sent_location(ngx_http_request_t *r,
  1768.     ngx_http_variable_value_t *v, uintptr_t data)
  1769. {
  1770.     ngx_str_t  name;

  1772.     if (r->headers_out.location) {
  1773.         v->len = r->headers_out.location->value.len;
  1774.         v->valid = 1;
  1775.         v->no_cacheable = 0;
  1776.         v->not_found = 0;
  1777.         v->data = r->headers_out.location->value.data;

  1779.         return NGX_OK;
  1780.     }

  1782.     ngx_str_set(&name, "sent_http_location");

  1784.     return ngx_http_variable_unknown_header(v, &name,
  1785.                                             &r->headers_out.headers.part,
  1786.                                             sizeof("sent_http_") - 1);
  1787. }


  1790. static ngx_int_t
  1791. ‌ngx_http_variable_sent_last_modified(ngx_http_request_t *r,
  1792.     ngx_http_variable_value_t *v, uintptr_t data)
  1793. {
  1794.     u_char  *p;

  1796.     if (r->headers_out.last_modified) {
  1797.         v->len = r->headers_out.last_modified->value.len;
  1798.         v->valid = 1;
  1799.         v->no_cacheable = 0;
  1800.         v->not_found = 0;
  1801.         v->data = r->headers_out.last_modified->value.data;

  1803.         return NGX_OK;
  1804.     }

  1806.     if (r->headers_out.last_modified_time >= 0) {
  1807.         p = ngx_pnalloc(r->pool, sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1);
  1808.         if (p == NULL) {
  1809.             return NGX_ERROR;
  1810.         }

  1812.         v->len = ngx_http_time(p, r->headers_out.last_modified_time) - p;
  1813.         v->valid = 1;
  1814.         v->no_cacheable = 0;
  1815.         v->not_found = 0;
  1816.         v->data = p;

  1818.         return NGX_OK;
  1819.     }

  1821.     v->not_found = 1;

  1823.     return NGX_OK;
  1824. }


  1827. static ngx_int_t
  1828. ‌ngx_http_variable_sent_connection(ngx_http_request_t *r,
  1829.     ngx_http_variable_value_t *v, uintptr_t data)
  1830. {
  1831.     size_t   len;
  1832.     char    *p;

  1834.     if (r->headers_out.status == NGX_HTTP_SWITCHING_PROTOCOLS) {
  1835.         len = sizeof("upgrade") - 1;
  1836.         p = "upgrade";

  1838.     } else if (r->keepalive) {
  1839.         len = sizeof("keep-alive") - 1;
  1840.         p = "keep-alive";

  1842.     } else {
  1843.         len = sizeof("close") - 1;
  1844.         p = "close";
  1845.     }

  1847.     v->len = len;
  1848.     v->valid = 1;
  1849.     v->no_cacheable = 0;
  1850.     v->not_found = 0;
  1851.     v->data = (u_char *) p;

  1853.     return NGX_OK;
  1854. }


  1857. static ngx_int_t
  1858. ‌ngx_http_variable_sent_keep_alive(ngx_http_request_t *r,
  1859.     ngx_http_variable_value_t *v, uintptr_t data)
  1860. {
  1861.     u_char                    *p;
  1862.     ngx_http_core_loc_conf_t  *clcf;

  1864.     if (r->keepalive) {
  1865.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1867.         if (clcf->keepalive_header) {

  1869.             p = ngx_pnalloc(r->pool, sizeof("timeout=") - 1 + NGX_TIME_T_LEN);
  1870.             if (p == NULL) {
  1871.                 return NGX_ERROR;
  1872.             }

  1874.             v->len = ngx_sprintf(p, "timeout=%T", clcf->keepalive_header) - p;
  1875.             v->valid = 1;
  1876.             v->no_cacheable = 0;
  1877.             v->not_found = 0;
  1878.             v->data = p;

  1880.             return NGX_OK;
  1881.         }
  1882.     }

  1884.     v->not_found = 1;

  1886.     return NGX_OK;
  1887. }


  1890. static ngx_int_t
  1891. ‌ngx_http_variable_sent_transfer_encoding(ngx_http_request_t *r,
  1892.     ngx_http_variable_value_t *v, uintptr_t data)
  1893. {
  1894.     if (r->chunked) {
  1895.         v->len = sizeof("chunked") - 1;
  1896.         v->valid = 1;
  1897.         v->no_cacheable = 0;
  1898.         v->not_found = 0;
  1899.         v->data = (u_char *) "chunked";

  1901.     } else {
  1902.         v->not_found = 1;
  1903.     }

  1905.     return NGX_OK;
  1906. }


  1909. static ngx_int_t
  1910. ‌ngx_http_variable_request_completion(ngx_http_request_t *r,
  1911.     ngx_http_variable_value_t *v, uintptr_t data)
  1912. {
  1913.     if (r->request_complete) {
  1914.         v->len = 2;
  1915.         v->valid = 1;
  1916.         v->no_cacheable = 0;
  1917.         v->not_found = 0;
  1918.         v->data = (u_char *) "OK";

  1920.         return NGX_OK;
  1921.     }

  1923.     v->len = 0;
  1924.     v->valid = 1;
  1925.     v->no_cacheable = 0;
  1926.     v->not_found = 0;
  1927.     v->data = (u_char *) "";

  1929.     return NGX_OK;
  1930. }


  1933. static ngx_int_t
  1934. ‌ngx_http_variable_request_body(ngx_http_request_t *r,
  1935.     ngx_http_variable_value_t *v, uintptr_t data)
  1936. {
  1937.     u_char       *p;
  1938.     size_t        len;
  1939.     ngx_buf_t    *buf;
  1940.     ngx_chain_t  *cl;

  1942.     if (r->request_body == NULL
  1943.         || r->request_body->bufs == NULL
  1944.         || r->request_body->temp_file)
  1945.     {
  1946.         v->not_found = 1;

  1948.         return NGX_OK;
  1949.     }

  1951.     cl = r->request_body->bufs;
  1952.     buf = cl->buf;

  1954.     if (cl->next == NULL) {
  1955.         v->len = buf->last - buf->pos;
  1956.         v->valid = 1;
  1957.         v->no_cacheable = 0;
  1958.         v->not_found = 0;
  1959.         v->data = buf->pos;

  1961.         return NGX_OK;
  1962.     }

  1964.     len = buf->last - buf->pos;
  1965.     cl = cl->next;

  1967.     for ( /* void */ ; cl; cl = cl->next) {
  1968.         buf = cl->buf;
  1969.         len += buf->last - buf->pos;
  1970.     }

  1972.     p = ngx_pnalloc(r->pool, len);
  1973.     if (p == NULL) {
  1974.         return NGX_ERROR;
  1975.     }

  1977.     v->data = p;
  1978.     cl = r->request_body->bufs;

  1980.     for ( /* void */ ; cl; cl = cl->next) {
  1981.         buf = cl->buf;
  1982.         p = ngx_cpymem(p, buf->pos, buf->last - buf->pos);
  1983.     }

  1985.     v->len = len;
  1986.     v->valid = 1;
  1987.     v->no_cacheable = 0;
  1988.     v->not_found = 0;

  1990.     return NGX_OK;
  1991. }


  1994. static ngx_int_t
  1995. ‌ngx_http_variable_request_body_file(ngx_http_request_t *r,
  1996.     ngx_http_variable_value_t *v, uintptr_t data)
  1997. {
  1998.     if (r->request_body == NULL || r->request_body->temp_file == NULL) {
  1999.         v->not_found = 1;

  2001.         return NGX_OK;
  2002.     }

  2004.     v->len = r->request_body->temp_file->file.name.len;
  2005.     v->valid = 1;
  2006.     v->no_cacheable = 0;
  2007.     v->not_found = 0;
  2008.     v->data = r->request_body->temp_file->file.name.data;

  2010.     return NGX_OK;
  2011. }


  2014. static ngx_int_t
  2015. ‌ngx_http_variable_request_length(ngx_http_request_t *r,
  2016.     ngx_http_variable_value_t *v, uintptr_t data)
  2017. {
  2018.     u_char  *p;

  2020.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  2021.     if (p == NULL) {
  2022.         return NGX_ERROR;
  2023.     }

  2025.     v->len = ngx_sprintf(p, "%O", r->request_length) - p;
  2026.     v->valid = 1;
  2027.     v->no_cacheable = 0;
  2028.     v->not_found = 0;
  2029.     v->data = p;

  2031.     return NGX_OK;
  2032. }


  2035. static ngx_int_t
  2036. ‌ngx_http_variable_request_time(ngx_http_request_t *r,
  2037.     ngx_http_variable_value_t *v, uintptr_t data)
  2038. {
  2039.     u_char          *p;
  2040.     ngx_time_t      *tp;
  2041.     ngx_msec_int_t   ms;

  2043.     p = ngx_pnalloc(r->pool, NGX_TIME_T_LEN + 4);
  2044.     if (p == NULL) {
  2045.         return NGX_ERROR;
  2046.     }

  2048.     tp = ngx_timeofday();

  2050.     ms = (ngx_msec_int_t)
  2051.              ((tp->sec - r->start_sec) * 1000 + (tp->msec - r->start_msec));
  2052.     ms = ngx_max(ms, 0);

  2054.     v->len = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000) - p;
  2055.     v->valid = 1;
  2056.     v->no_cacheable = 0;
  2057.     v->not_found = 0;
  2058.     v->data = p;

  2060.     return NGX_OK;
  2061. }


  2064. static ngx_int_t
  2065. ‌ngx_http_variable_connection(ngx_http_request_t *r,
  2066.     ngx_http_variable_value_t *v, uintptr_t data)
  2067. {
  2068.     u_char  *p;

  2070.     p = ngx_pnalloc(r->pool, NGX_ATOMIC_T_LEN);
  2071.     if (p == NULL) {
  2072.         return NGX_ERROR;
  2073.     }

  2075.     v->len = ngx_sprintf(p, "%uA", r->connection->number) - p;
  2076.     v->valid = 1;
  2077.     v->no_cacheable = 0;
  2078.     v->not_found = 0;
  2079.     v->data = p;

  2081.     return NGX_OK;
  2082. }


  2085. static ngx_int_t
  2086. ‌ngx_http_variable_connection_requests(ngx_http_request_t *r,
  2087.     ngx_http_variable_value_t *v, uintptr_t data)
  2088. {
  2089.     u_char  *p;

  2091.     p = ngx_pnalloc(r->pool, NGX_INT_T_LEN);
  2092.     if (p == NULL) {
  2093.         return NGX_ERROR;
  2094.     }

  2096.     v->len = ngx_sprintf(p, "%ui", r->connection->requests) - p;
  2097.     v->valid = 1;
  2098.     v->no_cacheable = 0;
  2099.     v->not_found = 0;
  2100.     v->data = p;

  2102.     return NGX_OK;
  2103. }


  2106. static ngx_int_t
  2107. ‌ngx_http_variable_nginx_version(ngx_http_request_t *r,
  2108.     ngx_http_variable_value_t *v, uintptr_t data)
  2109. {
  2110.     v->len = sizeof(NGINX_VERSION) - 1;
  2111.     v->valid = 1;
  2112.     v->no_cacheable = 0;
  2113.     v->not_found = 0;
  2114.     v->data = (u_char *) NGINX_VERSION;

  2116.     return NGX_OK;
  2117. }


  2120. static ngx_int_t
  2121. ‌ngx_http_variable_hostname(ngx_http_request_t *r,
  2122.     ngx_http_variable_value_t *v, uintptr_t data)
  2123. {
  2124.     v->len = ngx_cycle->hostname.len;
  2125.     v->valid = 1;
  2126.     v->no_cacheable = 0;
  2127.     v->not_found = 0;
  2128.     v->data = ngx_cycle->hostname.data;

  2130.     return NGX_OK;
  2131. }


  2134. static ngx_int_t
  2135. ‌ngx_http_variable_pid(ngx_http_request_t *r,
  2136.     ngx_http_variable_value_t *v, uintptr_t data)
  2137. {
  2138.     u_char  *p;

  2140.     p = ngx_pnalloc(r->pool, NGX_INT64_LEN);
  2141.     if (p == NULL) {
  2142.         return NGX_ERROR;
  2143.     }

  2145.     v->len = ngx_sprintf(p, "%P", ngx_pid) - p;
  2146.     v->valid = 1;
  2147.     v->no_cacheable = 0;
  2148.     v->not_found = 0;
  2149.     v->data = p;

  2151.     return NGX_OK;
  2152. }


  2155. static ngx_int_t
  2156. ‌ngx_http_variable_msec(ngx_http_request_t *r,
  2157.     ngx_http_variable_value_t *v, uintptr_t data)
  2158. {
  2159.     u_char      *p;
  2160.     ngx_time_t  *tp;

  2162.     p = ngx_pnalloc(r->pool, NGX_TIME_T_LEN + 4);
  2163.     if (p == NULL) {
  2164.         return NGX_ERROR;
  2165.     }

  2167.     tp = ngx_timeofday();

  2169.     v->len = ngx_sprintf(p, "%T.%03M", tp->sec, tp->msec) - p;
  2170.     v->valid = 1;
  2171.     v->no_cacheable = 0;
  2172.     v->not_found = 0;
  2173.     v->data = p;

  2175.     return NGX_OK;
  2176. }


  2179. static ngx_int_t
  2180. ‌ngx_http_variable_time_iso8601(ngx_http_request_t *r,
  2181.     ngx_http_variable_value_t *v, uintptr_t data)
  2182. {
  2183.     u_char  *p;

  2185.     p = ngx_pnalloc(r->pool, ngx_cached_http_log_iso8601.len);
  2186.     if (p == NULL) {
  2187.         return NGX_ERROR;
  2188.     }

  2190.     ngx_memcpy(p, ngx_cached_http_log_iso8601.data,
  2191.                ngx_cached_http_log_iso8601.len);

  2193.     v->len = ngx_cached_http_log_iso8601.len;
  2194.     v->valid = 1;
  2195.     v->no_cacheable = 0;
  2196.     v->not_found = 0;
  2197.     v->data = p;

  2199.     return NGX_OK;
  2200. }


  2203. static ngx_int_t
  2204. ‌ngx_http_variable_time_local(ngx_http_request_t *r,
  2205.     ngx_http_variable_value_t *v, uintptr_t data)
  2206. {
  2207.     u_char  *p;

  2209.     p = ngx_pnalloc(r->pool, ngx_cached_http_log_time.len);
  2210.     if (p == NULL) {
  2211.         return NGX_ERROR;
  2212.     }

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

  2216.     v->len = ngx_cached_http_log_time.len;
  2217.     v->valid = 1;
  2218.     v->no_cacheable = 0;
  2219.     v->not_found = 0;
  2220.     v->data = p;

  2222.     return NGX_OK;
  2223. }


  2226. void *
  2227. ‌ngx_http_map_find(ngx_http_request_t *r, ngx_http_map_t *map, ngx_str_t *match)
  2228. {
  2229.     void        *value;
  2230.     u_char      *low;
  2231.     size_t       len;
  2232.     ngx_uint_t   key;

  2234.     len = match->len;

  2236.     if (len) {
  2237.         low = ngx_pnalloc(r->pool, len);
  2238.         if (low == NULL) {
  2239.             return NULL;
  2240.         }

  2242.     } else {
  2243.         low = NULL;
  2244.     }

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

  2248.     value = ngx_hash_find_combined(&map->hash, key, low, len);
  2249.     if (value) {
  2250.         return value;
  2251.     }

  2253. #if (NGX_PCRE)

  2255.     if (len && map->nregex) {
  2256.         ngx_int_t              n;
  2257.         ngx_uint_t             i;
  2258.         ngx_http_map_regex_t  *reg;

  2260.         reg = map->regex;

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

  2264.             n = ngx_http_regex_exec(r, reg[i].regex, match);

  2266.             if (n == NGX_OK) {
  2267.                 return reg[i].value;
  2268.             }

  2270.             if (n == NGX_DECLINED) {
  2271.                 continue;
  2272.             }

  2274.             /* NGX_ERROR */

  2276.             return NULL;
  2277.         }
  2278.     }

  2280. #endif

  2282.     return NULL;
  2283. }


  2286. #if (NGX_PCRE)

  2288. static ngx_int_t
  2289. ‌ngx_http_variable_not_found(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  2290.     uintptr_t data)
  2291. {
  2292.     v->not_found = 1;
  2293.     return NGX_OK;
  2294. }


  2297. ngx_http_regex_t *
  2298. ‌ngx_http_regex_compile(ngx_conf_t *cf, ngx_regex_compile_t *rc)
  2299. {
  2300.     u_char                     *p;
  2301.     size_t                      size;
  2302.     ngx_str_t                   name;
  2303.     ngx_uint_t                  i, n;
  2304.     ngx_http_variable_t        *v;
  2305.     ngx_http_regex_t           *re;
  2306.     ngx_http_regex_variable_t  *rv;
  2307.     ngx_http_core_main_conf_t  *cmcf;

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

  2311.     if (ngx_regex_compile(rc) != NGX_OK) {
  2312.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc->err);
  2313.         return NULL;
  2314.     }

  2316.     re = ngx_pcalloc(cf->pool, sizeof(ngx_http_regex_t));
  2317.     if (re == NULL) {
  2318.         return NULL;
  2319.     }

  2321.     re->regex = rc->regex;
  2322.     re->ncaptures = rc->captures;
  2323.     re->name = rc->pattern;

  2325.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
  2326.     cmcf->ncaptures = ngx_max(cmcf->ncaptures, re->ncaptures);

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

  2330.     if (n == 0) {
  2331.         return re;
  2332.     }

  2334.     rv = ngx_palloc(rc->pool, n * sizeof(ngx_http_regex_variable_t));
  2335.     if (rv == NULL) {
  2336.         return NULL;
  2337.     }

  2339.     re->variables = rv;
  2340.     re->nvariables = n;

  2342.     size = rc->name_size;
  2343.     p = rc->names;

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

  2348.         name.data = &p[2];
  2349.         name.len = ngx_strlen(name.data);

  2351.         v = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
  2352.         if (v == NULL) {
  2353.             return NULL;
  2354.         }

  2356.         rv[i].index = ngx_http_get_variable_index(cf, &name);
  2357.         if (rv[i].index == NGX_ERROR) {
  2358.             return NULL;
  2359.         }

  2361.         v->get_handler = ngx_http_variable_not_found;

  2363.         p += size;
  2364.     }

  2366.     return re;
  2367. }


  2370. ngx_int_t
  2371. ‌ngx_http_regex_exec(ngx_http_request_t *r, ngx_http_regex_t *re, ngx_str_t *s)
  2372. {
  2373.     ngx_int_t                   rc, index;
  2374.     ngx_uint_t                  i, n, len;
  2375.     ngx_http_variable_value_t  *vv;
  2376.     ngx_http_core_main_conf_t  *cmcf;

  2378.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  2380.     if (re->ncaptures) {
  2381.         len = cmcf->ncaptures;

  2383.         if (r->captures == NULL) {
  2384.             r->captures = ngx_palloc(r->pool, len * sizeof(int));
  2385.             if (r->captures == NULL) {
  2386.                 return NGX_ERROR;
  2387.             }
  2388.         }

  2390.     } else {
  2391.         len = 0;
  2392.     }

  2394.     rc = ngx_regex_exec(re->regex, s, r->captures, len);

  2396.     if (rc == NGX_REGEX_NO_MATCHED) {
  2397.         return NGX_DECLINED;
  2398.     }

  2400.     if (rc < 0) {
  2401.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  2402.                       ngx_regex_exec_n " failed: %i on \"%V\" using \"%V\"",
  2403.                       rc, s, &re->name);
  2404.         return NGX_ERROR;
  2405.     }

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

  2409.         n = re->variables[i].capture;
  2410.         index = re->variables[i].index;
  2411.         vv = &r->variables[index];

  2413.         vv->len = r->captures[n + 1] - r->captures[n];
  2414.         vv->valid = 1;
  2415.         vv->no_cacheable = 0;
  2416.         vv->not_found = 0;
  2417.         vv->data = &s->data[r->captures[n]];

  2419. #if (NGX_DEBUG)
  2420.         {
  2421.         ngx_http_variable_t  *v;

  2423.         v = cmcf->variables.elts;

  2425.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2426.                        "http regex set $%V to \"%*s\"",
  2427.                        &v[index].name, vv->len, vv->data);
  2428.         }
  2429. #endif
  2430.     }

  2432.     r->ncaptures = rc * 2;
  2433.     r->captures_data = s->data;

  2435.     return NGX_OK;
  2436. }

  2438. #endif


  2441. ngx_int_t
  2442. ‌ngx_http_variables_add_core_vars(ngx_conf_t *cf)
  2443. {
  2444.     ngx_int_t                   rc;
  2445.     ngx_http_variable_t        *cv, *v;
  2446.     ngx_http_core_main_conf_t  *cmcf;

  2448.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  2450.     cmcf->variables_keys = ngx_pcalloc(cf->temp_pool,
  2451.                                        sizeof(ngx_hash_keys_arrays_t));
  2452.     if (cmcf->variables_keys == NULL) {
  2453.         return NGX_ERROR;
  2454.     }

  2456.     cmcf->variables_keys->pool = cf->pool;
  2457.     cmcf->variables_keys->temp_pool = cf->pool;

  2459.     if (ngx_hash_keys_array_init(cmcf->variables_keys, NGX_HASH_SMALL)
  2460.         != NGX_OK)
  2461.     {
  2462.         return NGX_ERROR;
  2463.     }

  2465.     for (cv = ngx_http_core_variables; cv->name.len; cv++) {
  2466.         v = ngx_palloc(cf->pool, sizeof(ngx_http_variable_t));
  2467.         if (v == NULL) {
  2468.             return NGX_ERROR;
  2469.         }

  2471.         *v = *cv;

  2473.         rc = ngx_hash_add_key(cmcf->variables_keys, &v->name, v,
  2474.                               NGX_HASH_READONLY_KEY);

  2476.         if (rc == NGX_OK) {
  2477.             continue;
  2478.         }

  2480.         if (rc == NGX_BUSY) {
  2481.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2482.                                "conflicting variable name \"%V\"", &v->name);
  2483.         }

  2485.         return NGX_ERROR;
  2486.     }

  2488.     return NGX_OK;
  2489. }


  2492. ngx_int_t
  2493. ‌ngx_http_variables_init_vars(ngx_conf_t *cf)
  2494. {
  2495.     ngx_uint_t                  i, n;
  2496.     ngx_hash_key_t             *key;
  2497.     ngx_hash_init_t             hash;
  2498.     ngx_http_variable_t        *v, *av;
  2499.     ngx_http_core_main_conf_t  *cmcf;

  2501.     /* set the handlers for the indexed http variables */

  2503.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  2505.     v = cmcf->variables.elts;
  2506.     key = cmcf->variables_keys->keys.elts;

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

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

  2512.             av = key[n].value;

  2514.             if (v[i].name.len == key[n].key.len
  2515.                 && ngx_strncmp(v[i].name.data, key[n].key.data, v[i].name.len)
  2516.                    == 0)
  2517.             {
  2518.                 v[i].get_handler = av->get_handler;
  2519.                 v[i].data = av->data;

  2521.                 av->flags |= NGX_HTTP_VAR_INDEXED;
  2522.                 v[i].flags = av->flags;

  2524.                 av->index = i;

  2526.                 if (av->get_handler == NULL) {
  2527.                     break;
  2528.                 }

  2530.                 goto next;
  2531.             }
  2532.         }

  2534.         if (ngx_strncmp(v[i].name.data, "http_", 5) == 0) {
  2535.             v[i].get_handler = ngx_http_variable_unknown_header_in;
  2536.             v[i].data = (uintptr_t) &v[i].name;

  2538.             continue;
  2539.         }

  2541.         if (ngx_strncmp(v[i].name.data, "sent_http_", 10) == 0) {
  2542.             v[i].get_handler = ngx_http_variable_unknown_header_out;
  2543.             v[i].data = (uintptr_t) &v[i].name;

  2545.             continue;
  2546.         }

  2548.         if (ngx_strncmp(v[i].name.data, "upstream_http_", 14) == 0) {
  2549.             v[i].get_handler = ngx_http_upstream_header_variable;
  2550.             v[i].data = (uintptr_t) &v[i].name;
  2551.             v[i].flags = NGX_HTTP_VAR_NOCACHEABLE;

  2553.             continue;
  2554.         }

  2556.         if (ngx_strncmp(v[i].name.data, "cookie_", 7) == 0) {
  2557.             v[i].get_handler = ngx_http_variable_cookie;
  2558.             v[i].data = (uintptr_t) &v[i].name;

  2560.             continue;
  2561.         }

  2563.         if (ngx_strncmp(v[i].name.data, "upstream_cookie_", 16) == 0) {
  2564.             v[i].get_handler = ngx_http_upstream_cookie_variable;
  2565.             v[i].data = (uintptr_t) &v[i].name;
  2566.             v[i].flags = NGX_HTTP_VAR_NOCACHEABLE;

  2568.             continue;
  2569.         }

  2571.         if (ngx_strncmp(v[i].name.data, "arg_", 4) == 0) {
  2572.             v[i].get_handler = ngx_http_variable_argument;
  2573.             v[i].data = (uintptr_t) &v[i].name;
  2574.             v[i].flags = NGX_HTTP_VAR_NOCACHEABLE;

  2576.             continue;
  2577.         }

  2579.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2580.                       "unknown \"%V\" variable", &v[i].name);

  2582.         return NGX_ERROR;

  2584.     next:
  2585.         continue;
  2586.     }


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

  2592.         if (av->flags & NGX_HTTP_VAR_NOHASH) {
  2593.             key[n].key.data = NULL;
  2594.         }
  2595.     }


  2598.     hash.hash = &cmcf->variables_hash;
  2599.     hash.key = ngx_hash_key;
  2600.     hash.max_size = cmcf->variables_hash_max_size;
  2601.     hash.bucket_size = cmcf->variables_hash_bucket_size;
  2602.     hash.name = "variables_hash";
  2603.     hash.pool = cf->pool;
  2604.     hash.temp_pool = NULL;

  2606.     if (ngx_hash_init(&hash, cmcf->variables_keys->keys.elts,
  2607.                       cmcf->variables_keys->keys.nelts)
  2608.         != NGX_OK)
  2609.     {
  2610.         return NGX_ERROR;
  2611.     }

  2613.     cmcf->variables_keys = NULL;

  2615.     return NGX_OK;
  2616. }

One Level Up Top Level