One Level Up Top Level

src/http/ngx_http_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_http.h>
  11. #include <nginx.h>


  14. static ngx_http_variable_t *ngx_http_add_prefix_variable(ngx_conf_t *cf,
  15.     ngx_str_t *name, ngx_uint_t flags);

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

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

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

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

  111. static ngx_int_t ngx_http_variable_sent_content_type(ngx_http_request_t *r,
  112.     ngx_http_variable_value_t *v, uintptr_t data);
  113. static ngx_int_t ngx_http_variable_sent_content_length(ngx_http_request_t *r,
  114.     ngx_http_variable_value_t *v, uintptr_t data);
  115. static ngx_int_t ngx_http_variable_sent_location(ngx_http_request_t *r,
  116.     ngx_http_variable_value_t *v, uintptr_t data);
  117. static ngx_int_t ngx_http_variable_sent_last_modified(ngx_http_request_t *r,
  118.     ngx_http_variable_value_t *v, uintptr_t data);
  119. static ngx_int_t ngx_http_variable_sent_connection(ngx_http_request_t *r,
  120.     ngx_http_variable_value_t *v, uintptr_t data);
  121. static ngx_int_t ngx_http_variable_sent_keep_alive(ngx_http_request_t *r,
  122.     ngx_http_variable_value_t *v, uintptr_t data);
  123. static ngx_int_t ngx_http_variable_sent_transfer_encoding(ngx_http_request_t *r,
  124.     ngx_http_variable_value_t *v, uintptr_t data);
  125. static void ngx_http_variable_set_limit_rate(ngx_http_request_t *r,
  126.     ngx_http_variable_value_t *v, uintptr_t data);

  128. static ngx_int_t ngx_http_variable_connection(ngx_http_request_t *r,
  129.     ngx_http_variable_value_t *v, uintptr_t data);
  130. static ngx_int_t ngx_http_variable_connection_requests(ngx_http_request_t *r,
  131.     ngx_http_variable_value_t *v, uintptr_t data);
  132. static ngx_int_t ngx_http_variable_connection_time(ngx_http_request_t *r,
  133.     ngx_http_variable_value_t *v, uintptr_t data);

  135. static ngx_int_t ngx_http_variable_nginx_version(ngx_http_request_t *r,
  136.     ngx_http_variable_value_t *v, uintptr_t data);
  137. static ngx_int_t ngx_http_variable_hostname(ngx_http_request_t *r,
  138.     ngx_http_variable_value_t *v, uintptr_t data);
  139. static ngx_int_t ngx_http_variable_pid(ngx_http_request_t *r,
  140.     ngx_http_variable_value_t *v, uintptr_t data);
  141. static ngx_int_t ngx_http_variable_msec(ngx_http_request_t *r,
  142.     ngx_http_variable_value_t *v, uintptr_t data);
  143. static ngx_int_t ngx_http_variable_time_iso8601(ngx_http_request_t *r,
  144.     ngx_http_variable_value_t *v, uintptr_t data);
  145. static ngx_int_t ngx_http_variable_time_local(ngx_http_request_t *r,
  146.     ngx_http_variable_value_t *v, uintptr_t data);

  148. /*
  149. * TODO:
  150. *     Apache CGI: AUTH_TYPE, PATH_INFO (null), PATH_TRANSLATED
  151. *                 REMOTE_HOST (null), REMOTE_IDENT (null),
  152. *                 SERVER_SOFTWARE
  153. *
  154. *     Apache SSI: DOCUMENT_NAME, LAST_MODIFIED, USER_NAME (file owner)
  155. */

  157. /*
  158. * the $http_host, $http_user_agent, $http_referer, and $http_via
  159. * variables may be handled by generic
  160. * ngx_http_variable_unknown_header_in(), but for performance reasons
  161. * they are handled using dedicated entries
  162. */

  164. ‌static ngx_http_variable_t  ngx_http_core_variables[] = {

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

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

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

  175. #if (NGX_HTTP_GZIP)
  176.     { ngx_string("http_via"), NULL, ngx_http_variable_header,
  177.       offsetof(ngx_http_request_t, headers_in.via), 0, 0 },
  178. #endif

  180. #if (NGX_HTTP_X_FORWARDED_FOR)
  181.     { ngx_string("http_x_forwarded_for"), NULL, ngx_http_variable_header,
  182.       offsetof(ngx_http_request_t, headers_in.x_forwarded_for), 0, 0 },
  183. #endif

  185.     { ngx_string("http_cookie"), NULL, ngx_http_variable_cookies,
  186.       offsetof(ngx_http_request_t, headers_in.cookie), 0, 0 },

  188.     { ngx_string("content_length"), NULL, ngx_http_variable_content_length,
  189.       0, 0, 0 },

  191.     { ngx_string("content_type"), NULL, ngx_http_variable_header,
  192.       offsetof(ngx_http_request_t, headers_in.content_type), 0, 0 },

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

  196.     { ngx_string("binary_remote_addr"), NULL,
  197.       ngx_http_variable_binary_remote_addr, 0, 0, 0 },

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

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

  203.     { ngx_string("proxy_protocol_addr"), NULL,
  204.       ngx_http_variable_proxy_protocol_addr,
  205.       offsetof(ngx_proxy_protocol_t, src_addr), 0, 0 },

  207.     { ngx_string("proxy_protocol_port"), NULL,
  208.       ngx_http_variable_proxy_protocol_port,
  209.       offsetof(ngx_proxy_protocol_t, src_port), 0, 0 },

  211.     { ngx_string("proxy_protocol_server_addr"), NULL,
  212.       ngx_http_variable_proxy_protocol_addr,
  213.       offsetof(ngx_proxy_protocol_t, dst_addr), 0, 0 },

  215.     { ngx_string("proxy_protocol_server_port"), NULL,
  216.       ngx_http_variable_proxy_protocol_port,
  217.       offsetof(ngx_proxy_protocol_t, dst_port), 0, 0 },

  219.     { ngx_string("proxy_protocol_tlv_"), NULL,
  220.       ngx_http_variable_proxy_protocol_tlv,
  221.       0, NGX_HTTP_VAR_PREFIX, 0 },

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

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

  227.     { ngx_string("server_protocol"), NULL, ngx_http_variable_request,
  228.       offsetof(ngx_http_request_t, http_protocol), 0, 0 },

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

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

  234.     { ngx_string("request_uri"), NULL, ngx_http_variable_request,
  235.       offsetof(ngx_http_request_t, unparsed_uri), 0, 0 },

  237.     { ngx_string("uri"), NULL, ngx_http_variable_request,
  238.       offsetof(ngx_http_request_t, uri),
  239.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  241.     { ngx_string("document_uri"), NULL, ngx_http_variable_request,
  242.       offsetof(ngx_http_request_t, uri),
  243.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

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

  247.     { ngx_string("document_root"), NULL,
  248.       ngx_http_variable_document_root, 0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  250.     { ngx_string("realpath_root"), NULL,
  251.       ngx_http_variable_realpath_root, 0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  253.     { ngx_string("query_string"), NULL, ngx_http_variable_request,
  254.       offsetof(ngx_http_request_t, args),
  255.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  257.     { ngx_string("args"),
  258.       ngx_http_variable_set_args,
  259.       ngx_http_variable_request,
  260.       offsetof(ngx_http_request_t, args),
  261.       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },

  263.     { ngx_string("is_args"), NULL, ngx_http_variable_is_args,
  264.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  266.     { ngx_string("request_filename"), NULL,
  267.       ngx_http_variable_request_filename, 0,
  268.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

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

  272.     { ngx_string("request_method"), NULL,
  273.       ngx_http_variable_request_method, 0,
  274.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

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

  278.     { ngx_string("bytes_sent"), NULL, ngx_http_variable_bytes_sent,
  279.       0, 0, 0 },

  281.     { ngx_string("body_bytes_sent"), NULL, ngx_http_variable_body_bytes_sent,
  282.       0, 0, 0 },

  284.     { ngx_string("pipe"), NULL, ngx_http_variable_pipe,
  285.       0, 0, 0 },

  287.     { ngx_string("request_completion"), NULL,
  288.       ngx_http_variable_request_completion,
  289.       0, 0, 0 },

  291.     { ngx_string("request_body"), NULL,
  292.       ngx_http_variable_request_body,
  293.       0, 0, 0 },

  295.     { ngx_string("request_body_file"), NULL,
  296.       ngx_http_variable_request_body_file,
  297.       0, 0, 0 },

  299.     { ngx_string("request_length"), NULL, ngx_http_variable_request_length,
  300.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  302.     { ngx_string("request_time"), NULL, ngx_http_variable_request_time,
  303.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  305.     { ngx_string("request_id"), NULL,
  306.       ngx_http_variable_request_id,
  307.       0, 0, 0 },

  309.     { ngx_string("status"), NULL,
  310.       ngx_http_variable_status, 0,
  311.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  313.     { ngx_string("sent_http_content_type"), NULL,
  314.       ngx_http_variable_sent_content_type, 0, 0, 0 },

  316.     { ngx_string("sent_http_content_length"), NULL,
  317.       ngx_http_variable_sent_content_length, 0, 0, 0 },

  319.     { ngx_string("sent_http_location"), NULL,
  320.       ngx_http_variable_sent_location, 0, 0, 0 },

  322.     { ngx_string("sent_http_last_modified"), NULL,
  323.       ngx_http_variable_sent_last_modified, 0, 0, 0 },

  325.     { ngx_string("sent_http_connection"), NULL,
  326.       ngx_http_variable_sent_connection, 0, 0, 0 },

  328.     { ngx_string("sent_http_keep_alive"), NULL,
  329.       ngx_http_variable_sent_keep_alive, 0, 0, 0 },

  331.     { ngx_string("sent_http_transfer_encoding"), NULL,
  332.       ngx_http_variable_sent_transfer_encoding, 0, 0, 0 },

  334.     { ngx_string("sent_http_cache_control"), NULL, ngx_http_variable_header,
  335.       offsetof(ngx_http_request_t, headers_out.cache_control), 0, 0 },

  337.     { ngx_string("sent_http_link"), NULL, ngx_http_variable_header,
  338.       offsetof(ngx_http_request_t, headers_out.link), 0, 0 },

  340.     { ngx_string("limit_rate"), ngx_http_variable_set_limit_rate,
  341.       ngx_http_variable_request_get_size,
  342.       offsetof(ngx_http_request_t, limit_rate),
  343.       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },

  345.     { ngx_string("connection"), NULL,
  346.       ngx_http_variable_connection, 0, 0, 0 },

  348.     { ngx_string("connection_requests"), NULL,
  349.       ngx_http_variable_connection_requests, 0, 0, 0 },

  351.     { ngx_string("connection_time"), NULL, ngx_http_variable_connection_time,
  352.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  354.     { ngx_string("nginx_version"), NULL, ngx_http_variable_nginx_version,
  355.       0, 0, 0 },

  357.     { ngx_string("hostname"), NULL, ngx_http_variable_hostname,
  358.       0, 0, 0 },

  360.     { ngx_string("pid"), NULL, ngx_http_variable_pid,
  361.       0, 0, 0 },

  363.     { ngx_string("msec"), NULL, ngx_http_variable_msec,
  364.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  366.     { ngx_string("time_iso8601"), NULL, ngx_http_variable_time_iso8601,
  367.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  369.     { ngx_string("time_local"), NULL, ngx_http_variable_time_local,
  370.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  372. #if (NGX_HAVE_TCP_INFO)
  373.     { ngx_string("tcpinfo_rtt"), NULL, ngx_http_variable_tcpinfo,
  374.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  376.     { ngx_string("tcpinfo_rttvar"), NULL, ngx_http_variable_tcpinfo,
  377.       1, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  379.     { ngx_string("tcpinfo_snd_cwnd"), NULL, ngx_http_variable_tcpinfo,
  380.       2, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  382.     { ngx_string("tcpinfo_rcv_space"), NULL, ngx_http_variable_tcpinfo,
  383.       3, NGX_HTTP_VAR_NOCACHEABLE, 0 },
  384. #endif

  386.     { ngx_string("http_"), NULL, ngx_http_variable_unknown_header_in,
  387.       0, NGX_HTTP_VAR_PREFIX, 0 },

  389.     { ngx_string("sent_http_"), NULL, ngx_http_variable_unknown_header_out,
  390.       0, NGX_HTTP_VAR_PREFIX, 0 },

  392.     { ngx_string("sent_trailer_"), NULL, ngx_http_variable_unknown_trailer_out,
  393.       0, NGX_HTTP_VAR_PREFIX, 0 },

  395.     { ngx_string("cookie_"), NULL, ngx_http_variable_cookie,
  396.       0, NGX_HTTP_VAR_PREFIX, 0 },

  398.     { ngx_string("arg_"), NULL, ngx_http_variable_argument,
  399.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  401.       ngx_http_null_variable
  402. };


  405. ‌ngx_http_variable_value_t  ngx_http_variable_null_value =
  406.     ngx_http_variable("");
  407. ‌ngx_http_variable_value_t  ngx_http_variable_true_value =
  408.     ngx_http_variable("1");


  411. ‌static ngx_uint_t  ngx_http_variable_depth = 100;


  414. ngx_http_variable_t *
  415. ‌ngx_http_add_variable(ngx_conf_t *cf, ngx_str_t *name, ngx_uint_t flags)
  416. {
  417.     ngx_int_t                   rc;
  418.     ngx_uint_t                  i;
  419.     ngx_hash_key_t             *key;
  420.     ngx_http_variable_t        *v;
  421.     ngx_http_core_main_conf_t  *cmcf;

  423.     if (name->len == 0) {
  424.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  425.                            "invalid variable name \"$\"");
  426.         return NULL;
  427.     }

  429.     if (flags & NGX_HTTP_VAR_PREFIX) {
  430.         return ngx_http_add_prefix_variable(cf, name, flags);
  431.     }

  433.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  435.     key = cmcf->variables_keys->keys.elts;
  436.     for (i = 0; i < cmcf->variables_keys->keys.nelts; i++) {
  437.         if (name->len != key[i].key.len
  438.             || ngx_strncasecmp(name->data, key[i].key.data, name->len) != 0)
  439.         {
  440.             continue;
  441.         }

  443.         v = key[i].value;

  445.         if (!(v->flags & NGX_HTTP_VAR_CHANGEABLE)) {
  446.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  447.                                "the duplicate \"%V\" variable", name);
  448.             return NULL;
  449.         }

  451.         if (!(flags & NGX_HTTP_VAR_WEAK)) {
  452.             v->flags &= ~NGX_HTTP_VAR_WEAK;
  453.         }

  455.         return v;
  456.     }

  458.     v = ngx_palloc(cf->pool, sizeof(ngx_http_variable_t));
  459.     if (v == NULL) {
  460.         return NULL;
  461.     }

  463.     v->name.len = name->len;
  464.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  465.     if (v->name.data == NULL) {
  466.         return NULL;
  467.     }

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

  471.     v->set_handler = NULL;
  472.     v->get_handler = NULL;
  473.     v->data = 0;
  474.     v->flags = flags;
  475.     v->index = 0;

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

  479.     if (rc == NGX_ERROR) {
  480.         return NULL;
  481.     }

  483.     if (rc == NGX_BUSY) {
  484.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  485.                            "conflicting variable name \"%V\"", name);
  486.         return NULL;
  487.     }

  489.     return v;
  490. }


  493. static ngx_http_variable_t *
  494. ‌ngx_http_add_prefix_variable(ngx_conf_t *cf, ngx_str_t *name, ngx_uint_t flags)
  495. {
  496.     ngx_uint_t                  i;
  497.     ngx_http_variable_t        *v;
  498.     ngx_http_core_main_conf_t  *cmcf;

  500.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  502.     v = cmcf->prefix_variables.elts;
  503.     for (i = 0; i < cmcf->prefix_variables.nelts; i++) {
  504.         if (name->len != v[i].name.len
  505.             || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
  506.         {
  507.             continue;
  508.         }

  510.         v = &v[i];

  512.         if (!(v->flags & NGX_HTTP_VAR_CHANGEABLE)) {
  513.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  514.                                "the duplicate \"%V\" variable", name);
  515.             return NULL;
  516.         }

  518.         if (!(flags & NGX_HTTP_VAR_WEAK)) {
  519.             v->flags &= ~NGX_HTTP_VAR_WEAK;
  520.         }

  522.         return v;
  523.     }

  525.     v = ngx_array_push(&cmcf->prefix_variables);
  526.     if (v == NULL) {
  527.         return NULL;
  528.     }

  530.     v->name.len = name->len;
  531.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  532.     if (v->name.data == NULL) {
  533.         return NULL;
  534.     }

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

  538.     v->set_handler = NULL;
  539.     v->get_handler = NULL;
  540.     v->data = 0;
  541.     v->flags = flags;
  542.     v->index = 0;

  544.     return v;
  545. }


  548. ngx_int_t
  549. ‌ngx_http_get_variable_index(ngx_conf_t *cf, ngx_str_t *name)
  550. {
  551.     ngx_uint_t                  i;
  552.     ngx_http_variable_t        *v;
  553.     ngx_http_core_main_conf_t  *cmcf;

  555.     if (name->len == 0) {
  556.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  557.                            "invalid variable name \"$\"");
  558.         return NGX_ERROR;
  559.     }

  561.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  563.     v = cmcf->variables.elts;

  565.     if (v == NULL) {
  566.         if (ngx_array_init(&cmcf->variables, cf->pool, 4,
  567.                            sizeof(ngx_http_variable_t))
  568.             != NGX_OK)
  569.         {
  570.             return NGX_ERROR;
  571.         }

  573.     } else {
  574.         for (i = 0; i < cmcf->variables.nelts; i++) {
  575.             if (name->len != v[i].name.len
  576.                 || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
  577.             {
  578.                 continue;
  579.             }

  581.             return i;
  582.         }
  583.     }

  585.     v = ngx_array_push(&cmcf->variables);
  586.     if (v == NULL) {
  587.         return NGX_ERROR;
  588.     }

  590.     v->name.len = name->len;
  591.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  592.     if (v->name.data == NULL) {
  593.         return NGX_ERROR;
  594.     }

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

  598.     v->set_handler = NULL;
  599.     v->get_handler = NULL;
  600.     v->data = 0;
  601.     v->flags = 0;
  602.     v->index = cmcf->variables.nelts - 1;

  604.     return v->index;
  605. }


  608. ngx_http_variable_value_t *
  609. ‌ngx_http_get_indexed_variable(ngx_http_request_t *r, ngx_uint_t index)
  610. {
  611.     ngx_http_variable_t        *v;
  612.     ngx_http_core_main_conf_t  *cmcf;

  614.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  616.     if (cmcf->variables.nelts <= index) {
  617.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  618.                       "unknown variable index: %ui", index);
  619.         return NULL;
  620.     }

  622.     if (r->variables[index].not_found || r->variables[index].valid) {
  623.         return &r->variables[index];
  624.     }

  626.     v = cmcf->variables.elts;

  628.     if (ngx_http_variable_depth == 0) {
  629.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  630.                       "cycle while evaluating variable \"%V\"",
  631.                       &v[index].name);
  632.         return NULL;
  633.     }

  635.     ngx_http_variable_depth--;

  637.     if (v[index].get_handler(r, &r->variables[index], v[index].data)
  638.         == NGX_OK)
  639.     {
  640.         ngx_http_variable_depth++;

  642.         if (v[index].flags & NGX_HTTP_VAR_NOCACHEABLE) {
  643.             r->variables[index].no_cacheable = 1;
  644.         }

  646.         return &r->variables[index];
  647.     }

  649.     ngx_http_variable_depth++;

  651.     r->variables[index].valid = 0;
  652.     r->variables[index].not_found = 1;

  654.     return NULL;
  655. }


  658. ngx_http_variable_value_t *
  659. ‌ngx_http_get_flushed_variable(ngx_http_request_t *r, ngx_uint_t index)
  660. {
  661.     ngx_http_variable_value_t  *v;

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

  665.     if (v->valid || v->not_found) {
  666.         if (!v->no_cacheable) {
  667.             return v;
  668.         }

  670.         v->valid = 0;
  671.         v->not_found = 0;
  672.     }

  674.     return ngx_http_get_indexed_variable(r, index);
  675. }


  678. ngx_http_variable_value_t *
  679. ‌ngx_http_get_variable(ngx_http_request_t *r, ngx_str_t *name, ngx_uint_t key)
  680. {
  681.     size_t                      len;
  682.     ngx_uint_t                  i, n;
  683.     ngx_http_variable_t        *v;
  684.     ngx_http_variable_value_t  *vv;
  685.     ngx_http_core_main_conf_t  *cmcf;

  687.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  691.     if (v) {
  692.         if (v->flags & NGX_HTTP_VAR_INDEXED) {
  693.             return ngx_http_get_flushed_variable(r, v->index);
  694.         }

  696.         if (ngx_http_variable_depth == 0) {
  697.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  698.                           "cycle while evaluating variable \"%V\"", name);
  699.             return NULL;
  700.         }

  702.         ngx_http_variable_depth--;

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

  706.         if (vv && v->get_handler(r, vv, v->data) == NGX_OK) {
  707.             ngx_http_variable_depth++;
  708.             return vv;
  709.         }

  711.         ngx_http_variable_depth++;
  712.         return NULL;
  713.     }

  715.     vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
  716.     if (vv == NULL) {
  717.         return NULL;
  718.     }

  720.     len = 0;

  722.     v = cmcf->prefix_variables.elts;
  723.     n = cmcf->prefix_variables.nelts;

  725.     for (i = 0; i < cmcf->prefix_variables.nelts; i++) {
  726.         if (name->len >= v[i].name.len && name->len > len
  727.             && ngx_strncmp(name->data, v[i].name.data, v[i].name.len) == 0)
  728.         {
  729.             len = v[i].name.len;
  730.             n = i;
  731.         }
  732.     }

  734.     if (n != cmcf->prefix_variables.nelts) {
  735.         if (v[n].get_handler(r, vv, (uintptr_t) name) == NGX_OK) {
  736.             return vv;
  737.         }

  739.         return NULL;
  740.     }

  742.     vv->not_found = 1;

  744.     return vv;
  745. }


  748. static ngx_int_t
  749. ‌ngx_http_variable_request(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  750.     uintptr_t data)
  751. {
  752.     ngx_str_t  *s;

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

  756.     if (s->data) {
  757.         v->len = s->len;
  758.         v->valid = 1;
  759.         v->no_cacheable = 0;
  760.         v->not_found = 0;
  761.         v->data = s->data;

  763.     } else {
  764.         v->not_found = 1;
  765.     }

  767.     return NGX_OK;
  768. }


  771. #if 0

  773. static void
  774. ngx_http_variable_request_set(ngx_http_request_t *r,
  775.     ngx_http_variable_value_t *v, uintptr_t data)
  776. {
  777.     ngx_str_t  *s;

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

  781.     s->len = v->len;
  782.     s->data = v->data;
  783. }

  785. #endif


  788. static ngx_int_t
  789. ‌ngx_http_variable_request_get_size(ngx_http_request_t *r,
  790.     ngx_http_variable_value_t *v, uintptr_t data)
  791. {
  792.     size_t  *sp;

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

  796.     v->data = ngx_pnalloc(r->pool, NGX_SIZE_T_LEN);
  797.     if (v->data == NULL) {
  798.         return NGX_ERROR;
  799.     }

  801.     v->len = ngx_sprintf(v->data, "%uz", *sp) - v->data;
  802.     v->valid = 1;
  803.     v->no_cacheable = 0;
  804.     v->not_found = 0;

  806.     return NGX_OK;
  807. }


  810. static ngx_int_t
  811. ‌ngx_http_variable_header(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  812.     uintptr_t data)
  813. {
  814.     return ngx_http_variable_headers_internal(r, v, data, ',');
  815. }


  818. static ngx_int_t
  819. ‌ngx_http_variable_cookies(ngx_http_request_t *r,
  820.     ngx_http_variable_value_t *v, uintptr_t data)
  821. {
  822.     return ngx_http_variable_headers_internal(r, v, data, ';');
  823. }


  826. static ngx_int_t
  827. ‌ngx_http_variable_headers_internal(ngx_http_request_t *r,
  828.     ngx_http_variable_value_t *v, uintptr_t data, u_char sep)
  829. {
  830.     size_t            len;
  831.     u_char           *p, *end;
  832.     ngx_table_elt_t  *h, *th;

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

  836.     len = 0;

  838.     for (th = h; th; th = th->next) {

  840.         if (th->hash == 0) {
  841.             continue;
  842.         }

  844.         len += th->value.len + 2;
  845.     }

  847.     if (len == 0) {
  848.         v->not_found = 1;
  849.         return NGX_OK;
  850.     }

  852.     len -= 2;

  854.     v->valid = 1;
  855.     v->no_cacheable = 0;
  856.     v->not_found = 0;

  858.     if (h->next == NULL) {
  859.         v->len = h->value.len;
  860.         v->data = h->value.data;

  862.         return NGX_OK;
  863.     }

  865.     p = ngx_pnalloc(r->pool, len);
  866.     if (p == NULL) {
  867.         return NGX_ERROR;
  868.     }

  870.     v->len = len;
  871.     v->data = p;

  873.     end = p + len;

  875.     for (th = h; th; th = th->next) {

  877.         if (th->hash == 0) {
  878.             continue;
  879.         }

  881.         p = ngx_copy(p, th->value.data, th->value.len);

  883.         if (p == end) {
  884.             break;
  885.         }

  887.         *p++ = sep; *p++ = ' ';
  888.     }

  890.     return NGX_OK;
  891. }


  894. static ngx_int_t
  895. ‌ngx_http_variable_unknown_header_in(ngx_http_request_t *r,
  896.     ngx_http_variable_value_t *v, uintptr_t data)
  897. {
  898.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  899.                                             &r->headers_in.headers.part,
  900.                                             sizeof("http_") - 1);
  901. }


  904. static ngx_int_t
  905. ‌ngx_http_variable_unknown_header_out(ngx_http_request_t *r,
  906.     ngx_http_variable_value_t *v, uintptr_t data)
  907. {
  908.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  909.                                             &r->headers_out.headers.part,
  910.                                             sizeof("sent_http_") - 1);
  911. }


  914. static ngx_int_t
  915. ‌ngx_http_variable_unknown_trailer_out(ngx_http_request_t *r,
  916.     ngx_http_variable_value_t *v, uintptr_t data)
  917. {
  918.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  919.                                             &r->headers_out.trailers.part,
  920.                                             sizeof("sent_trailer_") - 1);
  921. }


  924. ngx_int_t
  925. ‌ngx_http_variable_unknown_header(ngx_http_request_t *r,
  926.     ngx_http_variable_value_t *v, ngx_str_t *var,
  927.     ngx_list_part_t *part, size_t prefix)
  928. {
  929.     u_char           *p, ch;
  930.     size_t            len;
  931.     ngx_uint_t        i, n;
  932.     ngx_table_elt_t  *header, *h, **ph;

  934.     ph = &h;
  935. #if (NGX_SUPPRESS_WARN)
  936.     len = 0;
  937. #endif

  939.     header = part->elts;

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

  943.         if (i >= part->nelts) {
  944.             if (part->next == NULL) {
  945.                 break;
  946.             }

  948.             part = part->next;
  949.             header = part->elts;
  950.             i = 0;
  951.         }

  953.         if (header[i].hash == 0) {
  954.             continue;
  955.         }

  957.         if (header[i].key.len != var->len - prefix) {
  958.             continue;
  959.         }

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

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

  967.             } else if (ch == '-') {
  968.                 ch = '_';
  969.             }

  971.             if (var->data[n + prefix] != ch) {
  972.                 break;
  973.             }
  974.         }

  976.         if (n != var->len - prefix) {
  977.             continue;
  978.         }

  980.         len += header[i].value.len + 2;

  982.         *ph = &header[i];
  983.         ph = &header[i].next;
  984.     }

  986.     *ph = NULL;

  988.     if (h == NULL) {
  989.         v->not_found = 1;
  990.         return NGX_OK;
  991.     }

  993.     len -= 2;

  995.     if (h->next == NULL) {

  997.         v->len = h->value.len;
  998.         v->valid = 1;
  999.         v->no_cacheable = 0;
  1000.         v->not_found = 0;
  1001.         v->data = h->value.data;

  1003.         return NGX_OK;
  1004.     }

  1006.     p = ngx_pnalloc(r->pool, len);
  1007.     if (p == NULL) {
  1008.         return NGX_ERROR;
  1009.     }

  1011.     v->len = len;
  1012.     v->valid = 1;
  1013.     v->no_cacheable = 0;
  1014.     v->not_found = 0;
  1015.     v->data = p;

  1017.     for ( ;; ) {

  1019.         p = ngx_copy(p, h->value.data, h->value.len);

  1021.         if (h->next == NULL) {
  1022.             break;
  1023.         }

  1025.         *p++ = ','; *p++ = ' ';

  1027.         h = h->next;
  1028.     }

  1030.     return NGX_OK;
  1031. }


  1034. static ngx_int_t
  1035. ‌ngx_http_variable_request_line(ngx_http_request_t *r,
  1036.     ngx_http_variable_value_t *v, uintptr_t data)
  1037. {
  1038.     u_char  *p, *s;

  1040.     s = r->request_line.data;

  1042.     if (s == NULL) {
  1043.         s = r->request_start;

  1045.         if (s == NULL) {
  1046.             v->not_found = 1;
  1047.             return NGX_OK;
  1048.         }

  1050.         for (p = s; p < r->header_in->last; p++) {
  1051.             if (*p == CR || *p == LF) {
  1052.                 break;
  1053.             }
  1054.         }

  1056.         r->request_line.len = p - s;
  1057.         r->request_line.data = s;
  1058.     }

  1060.     v->len = r->request_line.len;
  1061.     v->valid = 1;
  1062.     v->no_cacheable = 0;
  1063.     v->not_found = 0;
  1064.     v->data = s;

  1066.     return NGX_OK;
  1067. }


  1070. static ngx_int_t
  1071. ‌ngx_http_variable_cookie(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1072.     uintptr_t data)
  1073. {
  1074.     ngx_str_t *name = (ngx_str_t *) data;

  1076.     ngx_str_t  cookie, s;

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

  1081.     if (ngx_http_parse_multi_header_lines(r, r->headers_in.cookie, &s, &cookie)
  1082.         == NULL)
  1083.     {
  1084.         v->not_found = 1;
  1085.         return NGX_OK;
  1086.     }

  1088.     v->len = cookie.len;
  1089.     v->valid = 1;
  1090.     v->no_cacheable = 0;
  1091.     v->not_found = 0;
  1092.     v->data = cookie.data;

  1094.     return NGX_OK;
  1095. }


  1098. static ngx_int_t
  1099. ‌ngx_http_variable_argument(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1100.     uintptr_t data)
  1101. {
  1102.     ngx_str_t *name = (ngx_str_t *) data;

  1104.     u_char     *arg;
  1105.     size_t      len;
  1106.     ngx_str_t   value;

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

  1111.     if (len == 0 || ngx_http_arg(r, arg, len, &value) != NGX_OK) {
  1112.         v->not_found = 1;
  1113.         return NGX_OK;
  1114.     }

  1116.     v->data = value.data;
  1117.     v->len = value.len;
  1118.     v->valid = 1;
  1119.     v->no_cacheable = 0;
  1120.     v->not_found = 0;

  1122.     return NGX_OK;
  1123. }


  1126. #if (NGX_HAVE_TCP_INFO)

  1128. static ngx_int_t
  1129. ‌ngx_http_variable_tcpinfo(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1130.     uintptr_t data)
  1131. {
  1132.     struct tcp_info  ti;
  1133.     socklen_t        len;
  1134.     uint32_t         value;

  1136.     len = sizeof(struct tcp_info);
  1137.     if (getsockopt(r->connection->fd, IPPROTO_TCP, TCP_INFO, &ti, &len) == -1) {
  1138.         v->not_found = 1;
  1139.         return NGX_OK;
  1140.     }

  1142.     v->data = ngx_pnalloc(r->pool, NGX_INT32_LEN);
  1143.     if (v->data == NULL) {
  1144.         return NGX_ERROR;
  1145.     }

  1147.     switch (data) {
  1148.     case 0:
  1149.         value = ti.tcpi_rtt;
  1150.         break;

  1152.     case 1:
  1153.         value = ti.tcpi_rttvar;
  1154.         break;

  1156.     case 2:
  1157.         value = ti.tcpi_snd_cwnd;
  1158.         break;

  1160.     case 3:
  1161.         value = ti.tcpi_rcv_space;
  1162.         break;

  1164.     /* suppress warning */
  1165.     default:
  1166.         value = 0;
  1167.         break;
  1168.     }

  1170.     v->len = ngx_sprintf(v->data, "%uD", value) - v->data;
  1171.     v->valid = 1;
  1172.     v->no_cacheable = 0;
  1173.     v->not_found = 0;

  1175.     return NGX_OK;
  1176. }

  1178. #endif


  1181. static ngx_int_t
  1182. ‌ngx_http_variable_content_length(ngx_http_request_t *r,
  1183.     ngx_http_variable_value_t *v, uintptr_t data)
  1184. {
  1185.     u_char  *p;

  1187.     if (r->headers_in.content_length) {
  1188.         v->len = r->headers_in.content_length->value.len;
  1189.         v->data = r->headers_in.content_length->value.data;
  1190.         v->valid = 1;
  1191.         v->no_cacheable = 0;
  1192.         v->not_found = 0;

  1194.     } else if (r->reading_body) {
  1195.         v->not_found = 1;
  1196.         v->no_cacheable = 1;

  1198.     } else if (r->headers_in.content_length_n >= 0) {
  1199.         p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1200.         if (p == NULL) {
  1201.             return NGX_ERROR;
  1202.         }

  1204.         v->len = ngx_sprintf(p, "%O", r->headers_in.content_length_n) - p;
  1205.         v->data = p;
  1206.         v->valid = 1;
  1207.         v->no_cacheable = 0;
  1208.         v->not_found = 0;

  1210.     } else if (r->headers_in.chunked) {
  1211.         v->not_found = 1;
  1212.         v->no_cacheable = 1;

  1214.     } else {
  1215.         v->not_found = 1;
  1216.     }

  1218.     return NGX_OK;
  1219. }


  1222. static ngx_int_t
  1223. ‌ngx_http_variable_host(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1224.     uintptr_t data)
  1225. {
  1226.     ngx_http_core_srv_conf_t  *cscf;

  1228.     if (r->headers_in.server.len) {
  1229.         v->len = r->headers_in.server.len;
  1230.         v->data = r->headers_in.server.data;

  1232.     } else {
  1233.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1235.         v->len = cscf->server_name.len;
  1236.         v->data = cscf->server_name.data;
  1237.     }

  1239.     v->valid = 1;
  1240.     v->no_cacheable = 0;
  1241.     v->not_found = 0;

  1243.     return NGX_OK;
  1244. }


  1247. static ngx_int_t
  1248. ‌ngx_http_variable_binary_remote_addr(ngx_http_request_t *r,
  1249.     ngx_http_variable_value_t *v, uintptr_t data)
  1250. {
  1251.     struct sockaddr_in   *sin;
  1252. #if (NGX_HAVE_INET6)
  1253.     struct sockaddr_in6  *sin6;
  1254. #endif

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

  1258. #if (NGX_HAVE_INET6)
  1259.     case AF_INET6:
  1260.         sin6 = (struct sockaddr_in6 *) r->connection->sockaddr;

  1262.         v->len = sizeof(struct in6_addr);
  1263.         v->valid = 1;
  1264.         v->no_cacheable = 0;
  1265.         v->not_found = 0;
  1266.         v->data = sin6->sin6_addr.s6_addr;

  1268.         break;
  1269. #endif

  1271. #if (NGX_HAVE_UNIX_DOMAIN)
  1272.     case AF_UNIX:

  1274.         v->len = r->connection->addr_text.len;
  1275.         v->valid = 1;
  1276.         v->no_cacheable = 0;
  1277.         v->not_found = 0;
  1278.         v->data = r->connection->addr_text.data;

  1280.         break;
  1281. #endif

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

  1286.         v->len = sizeof(in_addr_t);
  1287.         v->valid = 1;
  1288.         v->no_cacheable = 0;
  1289.         v->not_found = 0;
  1290.         v->data = (u_char *) &sin->sin_addr;

  1292.         break;
  1293.     }

  1295.     return NGX_OK;
  1296. }


  1299. static ngx_int_t
  1300. ‌ngx_http_variable_remote_addr(ngx_http_request_t *r,
  1301.     ngx_http_variable_value_t *v, uintptr_t data)
  1302. {
  1303.     v->len = r->connection->addr_text.len;
  1304.     v->valid = 1;
  1305.     v->no_cacheable = 0;
  1306.     v->not_found = 0;
  1307.     v->data = r->connection->addr_text.data;

  1309.     return NGX_OK;
  1310. }


  1313. static ngx_int_t
  1314. ‌ngx_http_variable_remote_port(ngx_http_request_t *r,
  1315.     ngx_http_variable_value_t *v, uintptr_t data)
  1316. {
  1317.     ngx_uint_t  port;

  1319.     v->len = 0;
  1320.     v->valid = 1;
  1321.     v->no_cacheable = 0;
  1322.     v->not_found = 0;

  1324.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1325.     if (v->data == NULL) {
  1326.         return NGX_ERROR;
  1327.     }

  1329.     port = ngx_inet_get_port(r->connection->sockaddr);

  1331.     if (port > 0 && port < 65536) {
  1332.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1333.     }

  1335.     return NGX_OK;
  1336. }


  1339. static ngx_int_t
  1340. ‌ngx_http_variable_proxy_protocol_addr(ngx_http_request_t *r,
  1341.     ngx_http_variable_value_t *v, uintptr_t data)
  1342. {
  1343.     ngx_str_t             *addr;
  1344.     ngx_proxy_protocol_t  *pp;

  1346.     pp = r->connection->proxy_protocol;
  1347.     if (pp == NULL) {
  1348.         v->not_found = 1;
  1349.         return NGX_OK;
  1350.     }

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

  1354.     v->len = addr->len;
  1355.     v->valid = 1;
  1356.     v->no_cacheable = 0;
  1357.     v->not_found = 0;
  1358.     v->data = addr->data;

  1360.     return NGX_OK;
  1361. }


  1364. static ngx_int_t
  1365. ‌ngx_http_variable_proxy_protocol_port(ngx_http_request_t *r,
  1366.     ngx_http_variable_value_t *v, uintptr_t data)
  1367. {
  1368.     ngx_uint_t             port;
  1369.     ngx_proxy_protocol_t  *pp;

  1371.     pp = r->connection->proxy_protocol;
  1372.     if (pp == NULL) {
  1373.         v->not_found = 1;
  1374.         return NGX_OK;
  1375.     }

  1377.     v->len = 0;
  1378.     v->valid = 1;
  1379.     v->no_cacheable = 0;
  1380.     v->not_found = 0;

  1382.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1383.     if (v->data == NULL) {
  1384.         return NGX_ERROR;
  1385.     }

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

  1389.     if (port > 0 && port < 65536) {
  1390.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1391.     }

  1393.     return NGX_OK;
  1394. }


  1397. static ngx_int_t
  1398. ‌ngx_http_variable_proxy_protocol_tlv(ngx_http_request_t *r,
  1399.     ngx_http_variable_value_t *v, uintptr_t data)
  1400. {
  1401.     ngx_str_t *name = (ngx_str_t *) data;

  1403.     ngx_int_t  rc;
  1404.     ngx_str_t  tlv, value;

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

  1409.     rc = ngx_proxy_protocol_get_tlv(r->connection, &tlv, &value);

  1411.     if (rc == NGX_ERROR) {
  1412.         return NGX_ERROR;
  1413.     }

  1415.     if (rc == NGX_DECLINED) {
  1416.         v->not_found = 1;
  1417.         return NGX_OK;
  1418.     }

  1420.     v->len = value.len;
  1421.     v->valid = 1;
  1422.     v->no_cacheable = 0;
  1423.     v->not_found = 0;
  1424.     v->data = value.data;

  1426.     return NGX_OK;
  1427. }


  1430. static ngx_int_t
  1431. ‌ngx_http_variable_server_addr(ngx_http_request_t *r,
  1432.     ngx_http_variable_value_t *v, uintptr_t data)
  1433. {
  1434.     ngx_str_t  s;
  1435.     u_char     addr[NGX_SOCKADDR_STRLEN];

  1437.     s.len = NGX_SOCKADDR_STRLEN;
  1438.     s.data = addr;

  1440.     if (ngx_connection_local_sockaddr(r->connection, &s, 0) != NGX_OK) {
  1441.         return NGX_ERROR;
  1442.     }

  1444.     s.data = ngx_pnalloc(r->pool, s.len);
  1445.     if (s.data == NULL) {
  1446.         return NGX_ERROR;
  1447.     }

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

  1451.     v->len = s.len;
  1452.     v->valid = 1;
  1453.     v->no_cacheable = 0;
  1454.     v->not_found = 0;
  1455.     v->data = s.data;

  1457.     return NGX_OK;
  1458. }


  1461. static ngx_int_t
  1462. ‌ngx_http_variable_server_port(ngx_http_request_t *r,
  1463.     ngx_http_variable_value_t *v, uintptr_t data)
  1464. {
  1465.     ngx_uint_t  port;

  1467.     v->len = 0;
  1468.     v->valid = 1;
  1469.     v->no_cacheable = 0;
  1470.     v->not_found = 0;

  1472.     if (ngx_connection_local_sockaddr(r->connection, NULL, 0) != NGX_OK) {
  1473.         return NGX_ERROR;
  1474.     }

  1476.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1477.     if (v->data == NULL) {
  1478.         return NGX_ERROR;
  1479.     }

  1481.     port = ngx_inet_get_port(r->connection->local_sockaddr);

  1483.     if (port > 0 && port < 65536) {
  1484.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1485.     }

  1487.     return NGX_OK;
  1488. }


  1491. static ngx_int_t
  1492. ‌ngx_http_variable_scheme(ngx_http_request_t *r,
  1493.     ngx_http_variable_value_t *v, uintptr_t data)
  1494. {
  1495. #if (NGX_HTTP_SSL)

  1497.     if (r->connection->ssl) {
  1498.         v->len = sizeof("https") - 1;
  1499.         v->valid = 1;
  1500.         v->no_cacheable = 0;
  1501.         v->not_found = 0;
  1502.         v->data = (u_char *) "https";

  1504.         return NGX_OK;
  1505.     }

  1507. #endif

  1509.     v->len = sizeof("http") - 1;
  1510.     v->valid = 1;
  1511.     v->no_cacheable = 0;
  1512.     v->not_found = 0;
  1513.     v->data = (u_char *) "http";

  1515.     return NGX_OK;
  1516. }


  1519. static ngx_int_t
  1520. ‌ngx_http_variable_https(ngx_http_request_t *r,
  1521.     ngx_http_variable_value_t *v, uintptr_t data)
  1522. {
  1523. #if (NGX_HTTP_SSL)

  1525.     if (r->connection->ssl) {
  1526.         v->len = sizeof("on") - 1;
  1527.         v->valid = 1;
  1528.         v->no_cacheable = 0;
  1529.         v->not_found = 0;
  1530.         v->data = (u_char *) "on";

  1532.         return NGX_OK;
  1533.     }

  1535. #endif

  1537.     *v = ngx_http_variable_null_value;

  1539.     return NGX_OK;
  1540. }


  1543. static void
  1544. ‌ngx_http_variable_set_args(ngx_http_request_t *r,
  1545.     ngx_http_variable_value_t *v, uintptr_t data)
  1546. {
  1547.     r->args.len = v->len;
  1548.     r->args.data = v->data;
  1549.     r->valid_unparsed_uri = 0;
  1550. }


  1553. static ngx_int_t
  1554. ‌ngx_http_variable_is_args(ngx_http_request_t *r,
  1555.     ngx_http_variable_value_t *v, uintptr_t data)
  1556. {
  1557.     if (r->args.len == 0) {
  1558.         *v = ngx_http_variable_null_value;
  1559.         return NGX_OK;
  1560.     }

  1562.     v->len = 1;
  1563.     v->valid = 1;
  1564.     v->no_cacheable = 0;
  1565.     v->not_found = 0;
  1566.     v->data = (u_char *) "?";

  1568.     return NGX_OK;
  1569. }


  1572. static ngx_int_t
  1573. ‌ngx_http_variable_document_root(ngx_http_request_t *r,
  1574.     ngx_http_variable_value_t *v, uintptr_t data)
  1575. {
  1576.     ngx_str_t                  path;
  1577.     ngx_http_core_loc_conf_t  *clcf;

  1579.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1581.     if (clcf->root_lengths == NULL) {
  1582.         v->len = clcf->root.len;
  1583.         v->valid = 1;
  1584.         v->no_cacheable = 0;
  1585.         v->not_found = 0;
  1586.         v->data = clcf->root.data;

  1588.     } else {
  1589.         if (ngx_http_script_run(r, &path, clcf->root_lengths->elts, 0,
  1590.                                 clcf->root_values->elts)
  1591.             == NULL)
  1592.         {
  1593.             return NGX_ERROR;
  1594.         }

  1596.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, &path)
  1597.             != NGX_OK)
  1598.         {
  1599.             return NGX_ERROR;
  1600.         }

  1602.         v->len = path.len;
  1603.         v->valid = 1;
  1604.         v->no_cacheable = 0;
  1605.         v->not_found = 0;
  1606.         v->data = path.data;
  1607.     }

  1609.     return NGX_OK;
  1610. }


  1613. static ngx_int_t
  1614. ‌ngx_http_variable_realpath_root(ngx_http_request_t *r,
  1615.     ngx_http_variable_value_t *v, uintptr_t data)
  1616. {
  1617.     u_char                    *real;
  1618.     size_t                     len;
  1619.     ngx_str_t                  path;
  1620.     ngx_http_core_loc_conf_t  *clcf;
  1621. #if (NGX_HAVE_MAX_PATH)
  1622.     u_char                     buffer[NGX_MAX_PATH];
  1623. #endif

  1625.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1627.     if (clcf->root_lengths == NULL) {
  1628.         path = clcf->root;

  1630.     } else {
  1631.         if (ngx_http_script_run(r, &path, clcf->root_lengths->elts, 1,
  1632.                                 clcf->root_values->elts)
  1633.             == NULL)
  1634.         {
  1635.             return NGX_ERROR;
  1636.         }

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

  1640.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, &path)
  1641.             != NGX_OK)
  1642.         {
  1643.             return NGX_ERROR;
  1644.         }
  1645.     }

  1647. #if (NGX_HAVE_MAX_PATH)
  1648.     real = buffer;
  1649. #else
  1650.     real = NULL;
  1651. #endif

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

  1655.     if (real == NULL) {
  1656.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  1657.                       ngx_realpath_n " \"%s\" failed", path.data);
  1658.         return NGX_ERROR;
  1659.     }

  1661.     len = ngx_strlen(real);

  1663.     v->data = ngx_pnalloc(r->pool, len);
  1664.     if (v->data == NULL) {
  1665. #if !(NGX_HAVE_MAX_PATH)
  1666.         ngx_free(real);
  1667. #endif
  1668.         return NGX_ERROR;
  1669.     }

  1671.     v->len = len;
  1672.     v->valid = 1;
  1673.     v->no_cacheable = 0;
  1674.     v->not_found = 0;

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

  1678. #if !(NGX_HAVE_MAX_PATH)
  1679.     ngx_free(real);
  1680. #endif

  1682.     return NGX_OK;
  1683. }


  1686. static ngx_int_t
  1687. ‌ngx_http_variable_request_filename(ngx_http_request_t *r,
  1688.     ngx_http_variable_value_t *v, uintptr_t data)
  1689. {
  1690.     size_t     root;
  1691.     ngx_str_t  path;

  1693.     if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
  1694.         return NGX_ERROR;
  1695.     }

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

  1699.     v->len = path.len - 1;
  1700.     v->valid = 1;
  1701.     v->no_cacheable = 0;
  1702.     v->not_found = 0;
  1703.     v->data = path.data;

  1705.     return NGX_OK;
  1706. }


  1709. static ngx_int_t
  1710. ‌ngx_http_variable_server_name(ngx_http_request_t *r,
  1711.     ngx_http_variable_value_t *v, uintptr_t data)
  1712. {
  1713.     ngx_http_core_srv_conf_t  *cscf;

  1715.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1717.     v->len = cscf->server_name.len;
  1718.     v->valid = 1;
  1719.     v->no_cacheable = 0;
  1720.     v->not_found = 0;
  1721.     v->data = cscf->server_name.data;

  1723.     return NGX_OK;
  1724. }


  1727. static ngx_int_t
  1728. ‌ngx_http_variable_request_method(ngx_http_request_t *r,
  1729.     ngx_http_variable_value_t *v, uintptr_t data)
  1730. {
  1731.     if (r->main->method_name.data) {
  1732.         v->len = r->main->method_name.len;
  1733.         v->valid = 1;
  1734.         v->no_cacheable = 0;
  1735.         v->not_found = 0;
  1736.         v->data = r->main->method_name.data;

  1738.     } else {
  1739.         v->not_found = 1;
  1740.     }

  1742.     return NGX_OK;
  1743. }


  1746. static ngx_int_t
  1747. ‌ngx_http_variable_remote_user(ngx_http_request_t *r,
  1748.     ngx_http_variable_value_t *v, uintptr_t data)
  1749. {
  1750.     ngx_int_t  rc;

  1752.     rc = ngx_http_auth_basic_user(r);

  1754.     if (rc == NGX_DECLINED) {
  1755.         v->not_found = 1;
  1756.         return NGX_OK;
  1757.     }

  1759.     if (rc == NGX_ERROR) {
  1760.         return NGX_ERROR;
  1761.     }

  1763.     v->len = r->headers_in.user.len;
  1764.     v->valid = 1;
  1765.     v->no_cacheable = 0;
  1766.     v->not_found = 0;
  1767.     v->data = r->headers_in.user.data;

  1769.     return NGX_OK;
  1770. }


  1773. static ngx_int_t
  1774. ‌ngx_http_variable_bytes_sent(ngx_http_request_t *r,
  1775.     ngx_http_variable_value_t *v, uintptr_t data)
  1776. {
  1777.     u_char  *p;

  1779.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1780.     if (p == NULL) {
  1781.         return NGX_ERROR;
  1782.     }

  1784.     v->len = ngx_sprintf(p, "%O", r->connection->sent) - p;
  1785.     v->valid = 1;
  1786.     v->no_cacheable = 0;
  1787.     v->not_found = 0;
  1788.     v->data = p;

  1790.     return NGX_OK;
  1791. }


  1794. static ngx_int_t
  1795. ‌ngx_http_variable_body_bytes_sent(ngx_http_request_t *r,
  1796.     ngx_http_variable_value_t *v, uintptr_t data)
  1797. {
  1798.     off_t    sent;
  1799.     u_char  *p;

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

  1803.     if (sent < 0) {
  1804.         sent = 0;
  1805.     }

  1807.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1808.     if (p == NULL) {
  1809.         return NGX_ERROR;
  1810.     }

  1812.     v->len = ngx_sprintf(p, "%O", sent) - p;
  1813.     v->valid = 1;
  1814.     v->no_cacheable = 0;
  1815.     v->not_found = 0;
  1816.     v->data = p;

  1818.     return NGX_OK;
  1819. }


  1822. static ngx_int_t
  1823. ‌ngx_http_variable_pipe(ngx_http_request_t *r,
  1824.     ngx_http_variable_value_t *v, uintptr_t data)
  1825. {
  1826.     v->data = (u_char *) (r->pipeline ? "p" : ".");
  1827.     v->len = 1;
  1828.     v->valid = 1;
  1829.     v->no_cacheable = 0;
  1830.     v->not_found = 0;

  1832.     return NGX_OK;
  1833. }


  1836. static ngx_int_t
  1837. ‌ngx_http_variable_status(ngx_http_request_t *r,
  1838.     ngx_http_variable_value_t *v, uintptr_t data)
  1839. {
  1840.     ngx_uint_t  status;

  1842.     v->data = ngx_pnalloc(r->pool, NGX_INT_T_LEN);
  1843.     if (v->data == NULL) {
  1844.         return NGX_ERROR;
  1845.     }

  1847.     if (r->err_status) {
  1848.         status = r->err_status;

  1850.     } else if (r->headers_out.status) {
  1851.         status = r->headers_out.status;

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

  1856.     } else {
  1857.         status = 0;
  1858.     }

  1860.     v->len = ngx_sprintf(v->data, "%03ui", status) - v->data;
  1861.     v->valid = 1;
  1862.     v->no_cacheable = 0;
  1863.     v->not_found = 0;

  1865.     return NGX_OK;
  1866. }


  1869. static ngx_int_t
  1870. ‌ngx_http_variable_sent_content_type(ngx_http_request_t *r,
  1871.     ngx_http_variable_value_t *v, uintptr_t data)
  1872. {
  1873.     if (r->headers_out.content_type.len) {
  1874.         v->len = r->headers_out.content_type.len;
  1875.         v->valid = 1;
  1876.         v->no_cacheable = 0;
  1877.         v->not_found = 0;
  1878.         v->data = r->headers_out.content_type.data;

  1880.     } else {
  1881.         v->not_found = 1;
  1882.     }

  1884.     return NGX_OK;
  1885. }


  1888. static ngx_int_t
  1889. ‌ngx_http_variable_sent_content_length(ngx_http_request_t *r,
  1890.     ngx_http_variable_value_t *v, uintptr_t data)
  1891. {
  1892.     u_char  *p;

  1894.     if (r->headers_out.content_length) {
  1895.         v->len = r->headers_out.content_length->value.len;
  1896.         v->valid = 1;
  1897.         v->no_cacheable = 0;
  1898.         v->not_found = 0;
  1899.         v->data = r->headers_out.content_length->value.data;

  1901.         return NGX_OK;
  1902.     }

  1904.     if (r->headers_out.content_length_n >= 0) {
  1905.         p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1906.         if (p == NULL) {
  1907.             return NGX_ERROR;
  1908.         }

  1910.         v->len = ngx_sprintf(p, "%O", r->headers_out.content_length_n) - p;
  1911.         v->valid = 1;
  1912.         v->no_cacheable = 0;
  1913.         v->not_found = 0;
  1914.         v->data = p;

  1916.         return NGX_OK;
  1917.     }

  1919.     v->not_found = 1;

  1921.     return NGX_OK;
  1922. }


  1925. static ngx_int_t
  1926. ‌ngx_http_variable_sent_location(ngx_http_request_t *r,
  1927.     ngx_http_variable_value_t *v, uintptr_t data)
  1928. {
  1929.     ngx_str_t  name;

  1931.     if (r->headers_out.location) {
  1932.         v->len = r->headers_out.location->value.len;
  1933.         v->valid = 1;
  1934.         v->no_cacheable = 0;
  1935.         v->not_found = 0;
  1936.         v->data = r->headers_out.location->value.data;

  1938.         return NGX_OK;
  1939.     }

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

  1943.     return ngx_http_variable_unknown_header(r, v, &name,
  1944.                                             &r->headers_out.headers.part,
  1945.                                             sizeof("sent_http_") - 1);
  1946. }


  1949. static ngx_int_t
  1950. ‌ngx_http_variable_sent_last_modified(ngx_http_request_t *r,
  1951.     ngx_http_variable_value_t *v, uintptr_t data)
  1952. {
  1953.     u_char  *p;

  1955.     if (r->headers_out.last_modified) {
  1956.         v->len = r->headers_out.last_modified->value.len;
  1957.         v->valid = 1;
  1958.         v->no_cacheable = 0;
  1959.         v->not_found = 0;
  1960.         v->data = r->headers_out.last_modified->value.data;

  1962.         return NGX_OK;
  1963.     }

  1965.     if (r->headers_out.last_modified_time >= 0) {
  1966.         p = ngx_pnalloc(r->pool, sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1);
  1967.         if (p == NULL) {
  1968.             return NGX_ERROR;
  1969.         }

  1971.         v->len = ngx_http_time(p, r->headers_out.last_modified_time) - p;
  1972.         v->valid = 1;
  1973.         v->no_cacheable = 0;
  1974.         v->not_found = 0;
  1975.         v->data = p;

  1977.         return NGX_OK;
  1978.     }

  1980.     v->not_found = 1;

  1982.     return NGX_OK;
  1983. }


  1986. static ngx_int_t
  1987. ‌ngx_http_variable_sent_connection(ngx_http_request_t *r,
  1988.     ngx_http_variable_value_t *v, uintptr_t data)
  1989. {
  1990.     size_t   len;
  1991.     char    *p;

  1993.     if (r->headers_out.status == NGX_HTTP_SWITCHING_PROTOCOLS) {
  1994.         len = sizeof("upgrade") - 1;
  1995.         p = "upgrade";

  1997.     } else if (r->keepalive) {
  1998.         len = sizeof("keep-alive") - 1;
  1999.         p = "keep-alive";

  2001.     } else {
  2002.         len = sizeof("close") - 1;
  2003.         p = "close";
  2004.     }

  2006.     v->len = len;
  2007.     v->valid = 1;
  2008.     v->no_cacheable = 0;
  2009.     v->not_found = 0;
  2010.     v->data = (u_char *) p;

  2012.     return NGX_OK;
  2013. }


  2016. static ngx_int_t
  2017. ‌ngx_http_variable_sent_keep_alive(ngx_http_request_t *r,
  2018.     ngx_http_variable_value_t *v, uintptr_t data)
  2019. {
  2020.     u_char                    *p;
  2021.     ngx_http_core_loc_conf_t  *clcf;

  2023.     if (r->keepalive) {
  2024.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2026.         if (clcf->keepalive_header) {

  2028.             p = ngx_pnalloc(r->pool, sizeof("timeout=") - 1 + NGX_TIME_T_LEN);
  2029.             if (p == NULL) {
  2030.                 return NGX_ERROR;
  2031.             }

  2033.             v->len = ngx_sprintf(p, "timeout=%T", clcf->keepalive_header) - p;
  2034.             v->valid = 1;
  2035.             v->no_cacheable = 0;
  2036.             v->not_found = 0;
  2037.             v->data = p;

  2039.             return NGX_OK;
  2040.         }
  2041.     }

  2043.     v->not_found = 1;

  2045.     return NGX_OK;
  2046. }


  2049. static ngx_int_t
  2050. ‌ngx_http_variable_sent_transfer_encoding(ngx_http_request_t *r,
  2051.     ngx_http_variable_value_t *v, uintptr_t data)
  2052. {
  2053.     if (r->chunked) {
  2054.         v->len = sizeof("chunked") - 1;
  2055.         v->valid = 1;
  2056.         v->no_cacheable = 0;
  2057.         v->not_found = 0;
  2058.         v->data = (u_char *) "chunked";

  2060.     } else {
  2061.         v->not_found = 1;
  2062.     }

  2064.     return NGX_OK;
  2065. }


  2068. static void
  2069. ‌ngx_http_variable_set_limit_rate(ngx_http_request_t *r,
  2070.     ngx_http_variable_value_t *v, uintptr_t data)
  2071. {
  2072.     ssize_t    s;
  2073.     ngx_str_t  val;

  2075.     val.len = v->len;
  2076.     val.data = v->data;

  2078.     s = ngx_parse_size(&val);

  2080.     if (s == NGX_ERROR) {
  2081.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2082.                       "invalid $limit_rate \"%V\"", &val);
  2083.         return;
  2084.     }

  2086.     r->limit_rate = s;
  2087.     r->limit_rate_set = 1;
  2088. }


  2091. static ngx_int_t
  2092. ‌ngx_http_variable_request_completion(ngx_http_request_t *r,
  2093.     ngx_http_variable_value_t *v, uintptr_t data)
  2094. {
  2095.     if (r->request_complete) {
  2096.         v->len = 2;
  2097.         v->valid = 1;
  2098.         v->no_cacheable = 0;
  2099.         v->not_found = 0;
  2100.         v->data = (u_char *) "OK";

  2102.         return NGX_OK;
  2103.     }

  2105.     *v = ngx_http_variable_null_value;

  2107.     return NGX_OK;
  2108. }


  2111. static ngx_int_t
  2112. ‌ngx_http_variable_request_body(ngx_http_request_t *r,
  2113.     ngx_http_variable_value_t *v, uintptr_t data)
  2114. {
  2115.     u_char       *p;
  2116.     size_t        len;
  2117.     ngx_buf_t    *buf;
  2118.     ngx_chain_t  *cl;

  2120.     if (r->request_body == NULL
  2121.         || r->request_body->bufs == NULL
  2122.         || r->request_body->temp_file)
  2123.     {
  2124.         v->not_found = 1;

  2126.         return NGX_OK;
  2127.     }

  2129.     cl = r->request_body->bufs;
  2130.     buf = cl->buf;

  2132.     if (cl->next == NULL) {
  2133.         v->len = buf->last - buf->pos;
  2134.         v->valid = 1;
  2135.         v->no_cacheable = 0;
  2136.         v->not_found = 0;
  2137.         v->data = buf->pos;

  2139.         return NGX_OK;
  2140.     }

  2142.     len = buf->last - buf->pos;
  2143.     cl = cl->next;

  2145.     for ( /* void */ ; cl; cl = cl->next) {
  2146.         buf = cl->buf;
  2147.         len += buf->last - buf->pos;
  2148.     }

  2150.     p = ngx_pnalloc(r->pool, len);
  2151.     if (p == NULL) {
  2152.         return NGX_ERROR;
  2153.     }

  2155.     v->data = p;
  2156.     cl = r->request_body->bufs;

  2158.     for ( /* void */ ; cl; cl = cl->next) {
  2159.         buf = cl->buf;
  2160.         p = ngx_cpymem(p, buf->pos, buf->last - buf->pos);
  2161.     }

  2163.     v->len = len;
  2164.     v->valid = 1;
  2165.     v->no_cacheable = 0;
  2166.     v->not_found = 0;

  2168.     return NGX_OK;
  2169. }


  2172. static ngx_int_t
  2173. ‌ngx_http_variable_request_body_file(ngx_http_request_t *r,
  2174.     ngx_http_variable_value_t *v, uintptr_t data)
  2175. {
  2176.     if (r->request_body == NULL || r->request_body->temp_file == NULL) {
  2177.         v->not_found = 1;

  2179.         return NGX_OK;
  2180.     }

  2182.     v->len = r->request_body->temp_file->file.name.len;
  2183.     v->valid = 1;
  2184.     v->no_cacheable = 0;
  2185.     v->not_found = 0;
  2186.     v->data = r->request_body->temp_file->file.name.data;

  2188.     return NGX_OK;
  2189. }


  2192. static ngx_int_t
  2193. ‌ngx_http_variable_request_length(ngx_http_request_t *r,
  2194.     ngx_http_variable_value_t *v, uintptr_t data)
  2195. {
  2196.     u_char  *p;

  2198.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  2199.     if (p == NULL) {
  2200.         return NGX_ERROR;
  2201.     }

  2203.     v->len = ngx_sprintf(p, "%O", r->request_length) - p;
  2204.     v->valid = 1;
  2205.     v->no_cacheable = 0;
  2206.     v->not_found = 0;
  2207.     v->data = p;

  2209.     return NGX_OK;
  2210. }


  2213. static ngx_int_t
  2214. ‌ngx_http_variable_request_time(ngx_http_request_t *r,
  2215.     ngx_http_variable_value_t *v, uintptr_t data)
  2216. {
  2217.     u_char          *p;
  2218.     ngx_time_t      *tp;
  2219.     ngx_msec_int_t   ms;

  2221.     p = ngx_pnalloc(r->pool, NGX_TIME_T_LEN + 4);
  2222.     if (p == NULL) {
  2223.         return NGX_ERROR;
  2224.     }

  2226.     tp = ngx_timeofday();

  2228.     ms = (ngx_msec_int_t)
  2229.              ((tp->sec - r->start_sec) * 1000 + (tp->msec - r->start_msec));
  2230.     ms = ngx_max(ms, 0);

  2232.     v->len = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000) - p;
  2233.     v->valid = 1;
  2234.     v->no_cacheable = 0;
  2235.     v->not_found = 0;
  2236.     v->data = p;

  2238.     return NGX_OK;
  2239. }


  2242. static ngx_int_t
  2243. ‌ngx_http_variable_request_id(ngx_http_request_t *r,
  2244.     ngx_http_variable_value_t *v, uintptr_t data)
  2245. {
  2246.     u_char  *id;

  2248. #if (NGX_OPENSSL)
  2249.     u_char   random_bytes[16];
  2250. #endif

  2252.     id = ngx_pnalloc(r->pool, 32);
  2253.     if (id == NULL) {
  2254.         return NGX_ERROR;
  2255.     }

  2257.     v->valid = 1;
  2258.     v->no_cacheable = 0;
  2259.     v->not_found = 0;

  2261.     v->len = 32;
  2262.     v->data = id;

  2264. #if (NGX_OPENSSL)

  2266.     if (RAND_bytes(random_bytes, 16) == 1) {
  2267.         ngx_hex_dump(id, random_bytes, 16);
  2268.         return NGX_OK;
  2269.     }

  2271.     ngx_ssl_error(NGX_LOG_ERR, r->connection->log, 0, "RAND_bytes() failed");

  2273. #endif

  2275.     ngx_sprintf(id, "%08xD%08xD%08xD%08xD",
  2276.                 (uint32_t) ngx_random(), (uint32_t) ngx_random(),
  2277.                 (uint32_t) ngx_random(), (uint32_t) ngx_random());

  2279.     return NGX_OK;
  2280. }


  2283. static ngx_int_t
  2284. ‌ngx_http_variable_connection(ngx_http_request_t *r,
  2285.     ngx_http_variable_value_t *v, uintptr_t data)
  2286. {
  2287.     u_char  *p;

  2289.     p = ngx_pnalloc(r->pool, NGX_ATOMIC_T_LEN);
  2290.     if (p == NULL) {
  2291.         return NGX_ERROR;
  2292.     }

  2294.     v->len = ngx_sprintf(p, "%uA", r->connection->number) - p;
  2295.     v->valid = 1;
  2296.     v->no_cacheable = 0;
  2297.     v->not_found = 0;
  2298.     v->data = p;

  2300.     return NGX_OK;
  2301. }


  2304. static ngx_int_t
  2305. ‌ngx_http_variable_connection_requests(ngx_http_request_t *r,
  2306.     ngx_http_variable_value_t *v, uintptr_t data)
  2307. {
  2308.     u_char  *p;

  2310.     p = ngx_pnalloc(r->pool, NGX_INT_T_LEN);
  2311.     if (p == NULL) {
  2312.         return NGX_ERROR;
  2313.     }

  2315.     v->len = ngx_sprintf(p, "%ui", r->connection->requests) - p;
  2316.     v->valid = 1;
  2317.     v->no_cacheable = 0;
  2318.     v->not_found = 0;
  2319.     v->data = p;

  2321.     return NGX_OK;
  2322. }


  2325. static ngx_int_t
  2326. ‌ngx_http_variable_connection_time(ngx_http_request_t *r,
  2327.     ngx_http_variable_value_t *v, uintptr_t data)
  2328. {
  2329.     u_char          *p;
  2330.     ngx_msec_int_t   ms;

  2332.     p = ngx_pnalloc(r->pool, NGX_TIME_T_LEN + 4);
  2333.     if (p == NULL) {
  2334.         return NGX_ERROR;
  2335.     }

  2337.     ms = ngx_current_msec - r->connection->start_time;
  2338.     ms = ngx_max(ms, 0);

  2340.     v->len = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000) - p;
  2341.     v->valid = 1;
  2342.     v->no_cacheable = 0;
  2343.     v->not_found = 0;
  2344.     v->data = p;

  2346.     return NGX_OK;
  2347. }


  2350. static ngx_int_t
  2351. ‌ngx_http_variable_nginx_version(ngx_http_request_t *r,
  2352.     ngx_http_variable_value_t *v, uintptr_t data)
  2353. {
  2354.     v->len = sizeof(NGINX_VERSION) - 1;
  2355.     v->valid = 1;
  2356.     v->no_cacheable = 0;
  2357.     v->not_found = 0;
  2358.     v->data = (u_char *) NGINX_VERSION;

  2360.     return NGX_OK;
  2361. }


  2364. static ngx_int_t
  2365. ‌ngx_http_variable_hostname(ngx_http_request_t *r,
  2366.     ngx_http_variable_value_t *v, uintptr_t data)
  2367. {
  2368.     v->len = ngx_cycle->hostname.len;
  2369.     v->valid = 1;
  2370.     v->no_cacheable = 0;
  2371.     v->not_found = 0;
  2372.     v->data = ngx_cycle->hostname.data;

  2374.     return NGX_OK;
  2375. }


  2378. static ngx_int_t
  2379. ‌ngx_http_variable_pid(ngx_http_request_t *r,
  2380.     ngx_http_variable_value_t *v, uintptr_t data)
  2381. {
  2382.     u_char  *p;

  2384.     p = ngx_pnalloc(r->pool, NGX_INT64_LEN);
  2385.     if (p == NULL) {
  2386.         return NGX_ERROR;
  2387.     }

  2389.     v->len = ngx_sprintf(p, "%P", ngx_pid) - p;
  2390.     v->valid = 1;
  2391.     v->no_cacheable = 0;
  2392.     v->not_found = 0;
  2393.     v->data = p;

  2395.     return NGX_OK;
  2396. }


  2399. static ngx_int_t
  2400. ‌ngx_http_variable_msec(ngx_http_request_t *r,
  2401.     ngx_http_variable_value_t *v, uintptr_t data)
  2402. {
  2403.     u_char      *p;
  2404.     ngx_time_t  *tp;

  2406.     p = ngx_pnalloc(r->pool, NGX_TIME_T_LEN + 4);
  2407.     if (p == NULL) {
  2408.         return NGX_ERROR;
  2409.     }

  2411.     tp = ngx_timeofday();

  2413.     v->len = ngx_sprintf(p, "%T.%03M", tp->sec, tp->msec) - p;
  2414.     v->valid = 1;
  2415.     v->no_cacheable = 0;
  2416.     v->not_found = 0;
  2417.     v->data = p;

  2419.     return NGX_OK;
  2420. }


  2423. static ngx_int_t
  2424. ‌ngx_http_variable_time_iso8601(ngx_http_request_t *r,
  2425.     ngx_http_variable_value_t *v, uintptr_t data)
  2426. {
  2427.     u_char  *p;

  2429.     p = ngx_pnalloc(r->pool, ngx_cached_http_log_iso8601.len);
  2430.     if (p == NULL) {
  2431.         return NGX_ERROR;
  2432.     }

  2434.     ngx_memcpy(p, ngx_cached_http_log_iso8601.data,
  2435.                ngx_cached_http_log_iso8601.len);

  2437.     v->len = ngx_cached_http_log_iso8601.len;
  2438.     v->valid = 1;
  2439.     v->no_cacheable = 0;
  2440.     v->not_found = 0;
  2441.     v->data = p;

  2443.     return NGX_OK;
  2444. }


  2447. static ngx_int_t
  2448. ‌ngx_http_variable_time_local(ngx_http_request_t *r,
  2449.     ngx_http_variable_value_t *v, uintptr_t data)
  2450. {
  2451.     u_char  *p;

  2453.     p = ngx_pnalloc(r->pool, ngx_cached_http_log_time.len);
  2454.     if (p == NULL) {
  2455.         return NGX_ERROR;
  2456.     }

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

  2460.     v->len = ngx_cached_http_log_time.len;
  2461.     v->valid = 1;
  2462.     v->no_cacheable = 0;
  2463.     v->not_found = 0;
  2464.     v->data = p;

  2466.     return NGX_OK;
  2467. }


  2470. void *
  2471. ‌ngx_http_map_find(ngx_http_request_t *r, ngx_http_map_t *map, ngx_str_t *match)
  2472. {
  2473.     void        *value;
  2474.     u_char      *low;
  2475.     size_t       len;
  2476.     ngx_uint_t   key;

  2478.     len = match->len;

  2480.     if (len) {
  2481.         low = ngx_pnalloc(r->pool, len);
  2482.         if (low == NULL) {
  2483.             return NULL;
  2484.         }

  2486.     } else {
  2487.         low = NULL;
  2488.     }

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

  2492.     value = ngx_hash_find_combined(&map->hash, key, low, len);
  2493.     if (value) {
  2494.         return value;
  2495.     }

  2497. #if (NGX_PCRE)

  2499.     if (len && map->nregex) {
  2500.         ngx_int_t              n;
  2501.         ngx_uint_t             i;
  2502.         ngx_http_map_regex_t  *reg;

  2504.         reg = map->regex;

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

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

  2510.             if (n == NGX_OK) {
  2511.                 return reg[i].value;
  2512.             }

  2514.             if (n == NGX_DECLINED) {
  2515.                 continue;
  2516.             }

  2518.             /* NGX_ERROR */

  2520.             return NULL;
  2521.         }
  2522.     }

  2524. #endif

  2526.     return NULL;
  2527. }


  2530. #if (NGX_PCRE)

  2532. static ngx_int_t
  2533. ‌ngx_http_variable_not_found(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  2534.     uintptr_t data)
  2535. {
  2536.     v->not_found = 1;
  2537.     return NGX_OK;
  2538. }


  2541. ngx_http_regex_t *
  2542. ‌ngx_http_regex_compile(ngx_conf_t *cf, ngx_regex_compile_t *rc)
  2543. {
  2544.     u_char                     *p;
  2545.     size_t                      size;
  2546.     ngx_str_t                   name;
  2547.     ngx_uint_t                  i, n;
  2548.     ngx_http_variable_t        *v;
  2549.     ngx_http_regex_t           *re;
  2550.     ngx_http_regex_variable_t  *rv;
  2551.     ngx_http_core_main_conf_t  *cmcf;

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

  2555.     if (ngx_regex_compile(rc) != NGX_OK) {
  2556.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc->err);
  2557.         return NULL;
  2558.     }

  2560.     re = ngx_pcalloc(cf->pool, sizeof(ngx_http_regex_t));
  2561.     if (re == NULL) {
  2562.         return NULL;
  2563.     }

  2565.     re->regex = rc->regex;
  2566.     re->ncaptures = rc->captures;
  2567.     re->name = rc->pattern;

  2569.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
  2570.     cmcf->ncaptures = ngx_max(cmcf->ncaptures, re->ncaptures);

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

  2574.     if (n == 0) {
  2575.         return re;
  2576.     }

  2578.     rv = ngx_palloc(rc->pool, n * sizeof(ngx_http_regex_variable_t));
  2579.     if (rv == NULL) {
  2580.         return NULL;
  2581.     }

  2583.     re->variables = rv;
  2584.     re->nvariables = n;

  2586.     size = rc->name_size;
  2587.     p = rc->names;

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

  2592.         name.data = &p[2];
  2593.         name.len = ngx_strlen(name.data);

  2595.         v = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
  2596.         if (v == NULL) {
  2597.             return NULL;
  2598.         }

  2600.         rv[i].index = ngx_http_get_variable_index(cf, &name);
  2601.         if (rv[i].index == NGX_ERROR) {
  2602.             return NULL;
  2603.         }

  2605.         v->get_handler = ngx_http_variable_not_found;

  2607.         p += size;
  2608.     }

  2610.     return re;
  2611. }


  2614. ngx_int_t
  2615. ‌ngx_http_regex_exec(ngx_http_request_t *r, ngx_http_regex_t *re, ngx_str_t *s)
  2616. {
  2617.     ngx_int_t                   rc, index;
  2618.     ngx_uint_t                  i, n, len;
  2619.     ngx_http_variable_value_t  *vv;
  2620.     ngx_http_core_main_conf_t  *cmcf;

  2622.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  2624.     if (re->ncaptures) {
  2625.         len = cmcf->ncaptures;

  2627.         if (r->captures == NULL || r->realloc_captures) {
  2628.             r->realloc_captures = 0;

  2630.             r->captures = ngx_palloc(r->pool, len * sizeof(int));
  2631.             if (r->captures == NULL) {
  2632.                 return NGX_ERROR;
  2633.             }
  2634.         }

  2636.     } else {
  2637.         len = 0;
  2638.     }

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

  2642.     if (rc == NGX_REGEX_NO_MATCHED) {
  2643.         return NGX_DECLINED;
  2644.     }

  2646.     if (rc < 0) {
  2647.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  2648.                       ngx_regex_exec_n " failed: %i on \"%V\" using \"%V\"",
  2649.                       rc, s, &re->name);
  2650.         return NGX_ERROR;
  2651.     }

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

  2655.         n = re->variables[i].capture;
  2656.         index = re->variables[i].index;
  2657.         vv = &r->variables[index];

  2659.         vv->len = r->captures[n + 1] - r->captures[n];
  2660.         vv->valid = 1;
  2661.         vv->no_cacheable = 0;
  2662.         vv->not_found = 0;
  2663.         vv->data = &s->data[r->captures[n]];

  2665. #if (NGX_DEBUG)
  2666.         {
  2667.         ngx_http_variable_t  *v;

  2669.         v = cmcf->variables.elts;

  2671.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2672.                        "http regex set $%V to \"%v\"", &v[index].name, vv);
  2673.         }
  2674. #endif
  2675.     }

  2677.     r->ncaptures = rc * 2;
  2678.     r->captures_data = s->data;

  2680.     return NGX_OK;
  2681. }

  2683. #endif


  2686. ngx_int_t
  2687. ‌ngx_http_variables_add_core_vars(ngx_conf_t *cf)
  2688. {
  2689.     ngx_http_variable_t        *cv, *v;
  2690.     ngx_http_core_main_conf_t  *cmcf;

  2692.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  2694.     cmcf->variables_keys = ngx_pcalloc(cf->temp_pool,
  2695.                                        sizeof(ngx_hash_keys_arrays_t));
  2696.     if (cmcf->variables_keys == NULL) {
  2697.         return NGX_ERROR;
  2698.     }

  2700.     cmcf->variables_keys->pool = cf->pool;
  2701.     cmcf->variables_keys->temp_pool = cf->pool;

  2703.     if (ngx_hash_keys_array_init(cmcf->variables_keys, NGX_HASH_SMALL)
  2704.         != NGX_OK)
  2705.     {
  2706.         return NGX_ERROR;
  2707.     }

  2709.     if (ngx_array_init(&cmcf->prefix_variables, cf->pool, 8,
  2710.                        sizeof(ngx_http_variable_t))
  2711.         != NGX_OK)
  2712.     {
  2713.         return NGX_ERROR;
  2714.     }

  2716.     for (cv = ngx_http_core_variables; cv->name.len; cv++) {
  2717.         v = ngx_http_add_variable(cf, &cv->name, cv->flags);
  2718.         if (v == NULL) {
  2719.             return NGX_ERROR;
  2720.         }

  2722.         *v = *cv;
  2723.     }

  2725.     return NGX_OK;
  2726. }


  2729. ngx_int_t
  2730. ‌ngx_http_variables_init_vars(ngx_conf_t *cf)
  2731. {
  2732.     size_t                      len;
  2733.     ngx_uint_t                  i, n;
  2734.     ngx_hash_key_t             *key;
  2735.     ngx_hash_init_t             hash;
  2736.     ngx_http_variable_t        *v, *av, *pv;
  2737.     ngx_http_core_main_conf_t  *cmcf;

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

  2741.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  2743.     v = cmcf->variables.elts;
  2744.     pv = cmcf->prefix_variables.elts;
  2745.     key = cmcf->variables_keys->keys.elts;

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

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

  2751.             av = key[n].value;

  2753.             if (v[i].name.len == key[n].key.len
  2754.                 && ngx_strncmp(v[i].name.data, key[n].key.data, v[i].name.len)
  2755.                    == 0)
  2756.             {
  2757.                 v[i].get_handler = av->get_handler;
  2758.                 v[i].data = av->data;

  2760.                 av->flags |= NGX_HTTP_VAR_INDEXED;
  2761.                 v[i].flags = av->flags;

  2763.                 av->index = i;

  2765.                 if (av->get_handler == NULL
  2766.                     || (av->flags & NGX_HTTP_VAR_WEAK))
  2767.                 {
  2768.                     break;
  2769.                 }

  2771.                 goto next;
  2772.             }
  2773.         }

  2775.         len = 0;
  2776.         av = NULL;

  2778.         for (n = 0; n < cmcf->prefix_variables.nelts; n++) {
  2779.             if (v[i].name.len >= pv[n].name.len && v[i].name.len > len
  2780.                 && ngx_strncmp(v[i].name.data, pv[n].name.data, pv[n].name.len)
  2781.                    == 0)
  2782.             {
  2783.                 av = &pv[n];
  2784.                 len = pv[n].name.len;
  2785.             }
  2786.         }

  2788.         if (av) {
  2789.             v[i].get_handler = av->get_handler;
  2790.             v[i].data = (uintptr_t) &v[i].name;
  2791.             v[i].flags = av->flags;

  2793.             goto next;
  2794.         }

  2796.         if (v[i].get_handler == NULL) {
  2797.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2798.                           "unknown \"%V\" variable", &v[i].name);

  2800.             return NGX_ERROR;
  2801.         }

  2803.     next:
  2804.         continue;
  2805.     }


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

  2811.         if (av->flags & NGX_HTTP_VAR_NOHASH) {
  2812.             key[n].key.data = NULL;
  2813.         }
  2814.     }


  2817.     hash.hash = &cmcf->variables_hash;
  2818.     hash.key = ngx_hash_key;
  2819.     hash.max_size = cmcf->variables_hash_max_size;
  2820.     hash.bucket_size = cmcf->variables_hash_bucket_size;
  2821.     hash.name = "variables_hash";
  2822.     hash.pool = cf->pool;
  2823.     hash.temp_pool = NULL;

  2825.     if (ngx_hash_init(&hash, cmcf->variables_keys->keys.elts,
  2826.                       cmcf->variables_keys->keys.nelts)
  2827.         != NGX_OK)
  2828.     {
  2829.         return NGX_ERROR;
  2830.     }

  2832.     cmcf->variables_keys = NULL;

  2834.     return NGX_OK;
  2835. }

One Level Up Top Level