One Level Up Top Level

src/http/ngx_http_variables.c - nginx

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 ngx_int_t ngx_http_variable_request_port(ngx_http_request_t *r,
  75.     ngx_http_variable_value_t *v, uintptr_t data);
  76. static ngx_int_t ngx_http_variable_is_request_port(ngx_http_request_t *r,
  77.     ngx_http_variable_value_t *v, uintptr_t data);
  78. static void ngx_http_variable_set_args(ngx_http_request_t *r,
  79.     ngx_http_variable_value_t *v, uintptr_t data);
  80. static ngx_int_t ngx_http_variable_is_args(ngx_http_request_t *r,
  81.     ngx_http_variable_value_t *v, uintptr_t data);
  82. static ngx_int_t ngx_http_variable_document_root(ngx_http_request_t *r,
  83.     ngx_http_variable_value_t *v, uintptr_t data);
  84. static ngx_int_t ngx_http_variable_realpath_root(ngx_http_request_t *r,
  85.     ngx_http_variable_value_t *v, uintptr_t data);
  86. static ngx_int_t ngx_http_variable_request_filename(ngx_http_request_t *r,
  87.     ngx_http_variable_value_t *v, uintptr_t data);
  88. static ngx_int_t ngx_http_variable_server_name(ngx_http_request_t *r,
  89.     ngx_http_variable_value_t *v, uintptr_t data);
  90. static ngx_int_t ngx_http_variable_request_method(ngx_http_request_t *r,
  91.     ngx_http_variable_value_t *v, uintptr_t data);
  92. static ngx_int_t ngx_http_variable_remote_user(ngx_http_request_t *r,
  93.     ngx_http_variable_value_t *v, uintptr_t data);
  94. static ngx_int_t ngx_http_variable_bytes_sent(ngx_http_request_t *r,
  95.     ngx_http_variable_value_t *v, uintptr_t data);
  96. static ngx_int_t ngx_http_variable_body_bytes_sent(ngx_http_request_t *r,
  97.     ngx_http_variable_value_t *v, uintptr_t data);
  98. static ngx_int_t ngx_http_variable_pipe(ngx_http_request_t *r,
  99.     ngx_http_variable_value_t *v, uintptr_t data);
  100. static ngx_int_t ngx_http_variable_request_completion(ngx_http_request_t *r,
  101.     ngx_http_variable_value_t *v, uintptr_t data);
  102. static ngx_int_t ngx_http_variable_request_body(ngx_http_request_t *r,
  103.     ngx_http_variable_value_t *v, uintptr_t data);
  104. static ngx_int_t ngx_http_variable_request_body_file(ngx_http_request_t *r,
  105.     ngx_http_variable_value_t *v, uintptr_t data);
  106. static ngx_int_t ngx_http_variable_request_length(ngx_http_request_t *r,
  107.     ngx_http_variable_value_t *v, uintptr_t data);
  108. static ngx_int_t ngx_http_variable_request_time(ngx_http_request_t *r,
  109.     ngx_http_variable_value_t *v, uintptr_t data);
  110. static ngx_int_t ngx_http_variable_request_id(ngx_http_request_t *r,
  111.     ngx_http_variable_value_t *v, uintptr_t data);
  112. static ngx_int_t ngx_http_variable_status(ngx_http_request_t *r,
  113.     ngx_http_variable_value_t *v, uintptr_t data);

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

  132. static ngx_int_t ngx_http_variable_connection(ngx_http_request_t *r,
  133.     ngx_http_variable_value_t *v, uintptr_t data);
  134. static ngx_int_t ngx_http_variable_connection_requests(ngx_http_request_t *r,
  135.     ngx_http_variable_value_t *v, uintptr_t data);
  136. static ngx_int_t ngx_http_variable_connection_time(ngx_http_request_t *r,
  137.     ngx_http_variable_value_t *v, uintptr_t data);

  139. static ngx_int_t ngx_http_variable_nginx_version(ngx_http_request_t *r,
  140.     ngx_http_variable_value_t *v, uintptr_t data);
  141. static ngx_int_t ngx_http_variable_hostname(ngx_http_request_t *r,
  142.     ngx_http_variable_value_t *v, uintptr_t data);
  143. static ngx_int_t ngx_http_variable_pid(ngx_http_request_t *r,
  144.     ngx_http_variable_value_t *v, uintptr_t data);
  145. static ngx_int_t ngx_http_variable_msec(ngx_http_request_t *r,
  146.     ngx_http_variable_value_t *v, uintptr_t data);
  147. static ngx_int_t ngx_http_variable_time_iso8601(ngx_http_request_t *r,
  148.     ngx_http_variable_value_t *v, uintptr_t data);
  149. static ngx_int_t ngx_http_variable_time_local(ngx_http_request_t *r,
  150.     ngx_http_variable_value_t *v, uintptr_t data);

  152. /*
  153. * TODO:
  154. *     Apache CGI: AUTH_TYPE, PATH_INFO (null), PATH_TRANSLATED
  155. *                 REMOTE_HOST (null), REMOTE_IDENT (null),
  156. *                 SERVER_SOFTWARE
  157. *
  158. *     Apache SSI: DOCUMENT_NAME, LAST_MODIFIED, USER_NAME (file owner)
  159. */

  161. /*
  162. * the $http_host, $http_user_agent, $http_referer, and $http_via
  163. * variables may be handled by generic
  164. * ngx_http_variable_unknown_header_in(), but for performance reasons
  165. * they are handled using dedicated entries
  166. */

  168. ‌static ngx_http_variable_t  ngx_http_core_variables[] = {

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

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

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

  179. #if (NGX_HTTP_GZIP)
  180.     { ngx_string("http_via"), NULL, ngx_http_variable_header,
  181.       offsetof(ngx_http_request_t, headers_in.via), 0, 0 },
  182. #endif

  184. #if (NGX_HTTP_X_FORWARDED_FOR)
  185.     { ngx_string("http_x_forwarded_for"), NULL, ngx_http_variable_header,
  186.       offsetof(ngx_http_request_t, headers_in.x_forwarded_for), 0, 0 },
  187. #endif

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

  192.     { ngx_string("content_length"), NULL, ngx_http_variable_content_length,
  193.       0, 0, 0 },

  195.     { ngx_string("content_type"), NULL, ngx_http_variable_header,
  196.       offsetof(ngx_http_request_t, headers_in.content_type), 0, 0 },

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

  200.     { ngx_string("binary_remote_addr"), NULL,
  201.       ngx_http_variable_binary_remote_addr, 0, 0, 0 },

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

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

  207.     { ngx_string("proxy_protocol_addr"), NULL,
  208.       ngx_http_variable_proxy_protocol_addr,
  209.       offsetof(ngx_proxy_protocol_t, src_addr), 0, 0 },

  211.     { ngx_string("proxy_protocol_port"), NULL,
  212.       ngx_http_variable_proxy_protocol_port,
  213.       offsetof(ngx_proxy_protocol_t, src_port), 0, 0 },

  215.     { ngx_string("proxy_protocol_server_addr"), NULL,
  216.       ngx_http_variable_proxy_protocol_addr,
  217.       offsetof(ngx_proxy_protocol_t, dst_addr), 0, 0 },

  219.     { ngx_string("proxy_protocol_server_port"), NULL,
  220.       ngx_http_variable_proxy_protocol_port,
  221.       offsetof(ngx_proxy_protocol_t, dst_port), 0, 0 },

  223.     { ngx_string("proxy_protocol_tlv_"), NULL,
  224.       ngx_http_variable_proxy_protocol_tlv,
  225.       0, NGX_HTTP_VAR_PREFIX, 0 },

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

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

  231.     { ngx_string("server_protocol"), NULL, ngx_http_variable_request,
  232.       offsetof(ngx_http_request_t, http_protocol), 0, 0 },

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

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

  238.     { ngx_string("request_port"), NULL,
  239.       ngx_http_variable_request_port, 0, 0, 0 },

  241.     { ngx_string("is_request_port"), NULL,
  242.       ngx_http_variable_is_request_port, 0, 0, 0 },

  244.     { ngx_string("request_uri"), NULL, ngx_http_variable_request,
  245.       offsetof(ngx_http_request_t, unparsed_uri), 0, 0 },

  247.     { ngx_string("uri"), NULL, ngx_http_variable_request,
  248.       offsetof(ngx_http_request_t, uri),
  249.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  251.     { ngx_string("document_uri"), NULL, ngx_http_variable_request,
  252.       offsetof(ngx_http_request_t, uri),
  253.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

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

  257.     { ngx_string("document_root"), NULL,
  258.       ngx_http_variable_document_root, 0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  260.     { ngx_string("realpath_root"), NULL,
  261.       ngx_http_variable_realpath_root, 0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  263.     { ngx_string("query_string"), NULL, ngx_http_variable_request,
  264.       offsetof(ngx_http_request_t, args),
  265.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  267.     { ngx_string("args"),
  268.       ngx_http_variable_set_args,
  269.       ngx_http_variable_request,
  270.       offsetof(ngx_http_request_t, args),
  271.       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },

  273.     { ngx_string("is_args"), NULL, ngx_http_variable_is_args,
  274.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  276.     { ngx_string("request_filename"), NULL,
  277.       ngx_http_variable_request_filename, 0,
  278.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

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

  282.     { ngx_string("request_method"), NULL,
  283.       ngx_http_variable_request_method, 0,
  284.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

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

  288.     { ngx_string("bytes_sent"), NULL, ngx_http_variable_bytes_sent,
  289.       0, 0, 0 },

  291.     { ngx_string("body_bytes_sent"), NULL, ngx_http_variable_body_bytes_sent,
  292.       0, 0, 0 },

  294.     { ngx_string("pipe"), NULL, ngx_http_variable_pipe,
  295.       0, 0, 0 },

  297.     { ngx_string("request_completion"), NULL,
  298.       ngx_http_variable_request_completion,
  299.       0, 0, 0 },

  301.     { ngx_string("request_body"), NULL,
  302.       ngx_http_variable_request_body,
  303.       0, 0, 0 },

  305.     { ngx_string("request_body_file"), NULL,
  306.       ngx_http_variable_request_body_file,
  307.       0, 0, 0 },

  309.     { ngx_string("request_length"), NULL, ngx_http_variable_request_length,
  310.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  312.     { ngx_string("request_time"), NULL, ngx_http_variable_request_time,
  313.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  315.     { ngx_string("request_id"), NULL,
  316.       ngx_http_variable_request_id,
  317.       0, 0, 0 },

  319.     { ngx_string("status"), NULL,
  320.       ngx_http_variable_status, 0,
  321.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  323.     { ngx_string("sent_http_content_type"), NULL,
  324.       ngx_http_variable_sent_content_type, 0, 0, 0 },

  326.     { ngx_string("sent_http_content_length"), NULL,
  327.       ngx_http_variable_sent_content_length, 0, 0, 0 },

  329.     { ngx_string("sent_http_location"), NULL,
  330.       ngx_http_variable_sent_location, 0, 0, 0 },

  332.     { ngx_string("sent_http_last_modified"), NULL,
  333.       ngx_http_variable_sent_last_modified, 0, 0, 0 },

  335.     { ngx_string("sent_http_connection"), NULL,
  336.       ngx_http_variable_sent_connection, 0, 0, 0 },

  338.     { ngx_string("sent_http_keep_alive"), NULL,
  339.       ngx_http_variable_sent_keep_alive, 0, 0, 0 },

  341.     { ngx_string("sent_http_transfer_encoding"), NULL,
  342.       ngx_http_variable_sent_transfer_encoding, 0, 0, 0 },

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

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

  350.     { ngx_string("limit_rate"), ngx_http_variable_set_limit_rate,
  351.       ngx_http_variable_request_get_size,
  352.       offsetof(ngx_http_request_t, limit_rate),
  353.       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },

  355.     { ngx_string("connection"), NULL,
  356.       ngx_http_variable_connection, 0, 0, 0 },

  358.     { ngx_string("connection_requests"), NULL,
  359.       ngx_http_variable_connection_requests, 0, 0, 0 },

  361.     { ngx_string("connection_time"), NULL, ngx_http_variable_connection_time,
  362.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  364.     { ngx_string("nginx_version"), NULL, ngx_http_variable_nginx_version,
  365.       0, 0, 0 },

  367.     { ngx_string("hostname"), NULL, ngx_http_variable_hostname,
  368.       0, 0, 0 },

  370.     { ngx_string("pid"), NULL, ngx_http_variable_pid,
  371.       0, 0, 0 },

  373.     { ngx_string("msec"), NULL, ngx_http_variable_msec,
  374.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  376.     { ngx_string("time_iso8601"), NULL, ngx_http_variable_time_iso8601,
  377.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  379.     { ngx_string("time_local"), NULL, ngx_http_variable_time_local,
  380.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  382. #if (NGX_HAVE_TCP_INFO)
  383.     { ngx_string("tcpinfo_rtt"), NULL, ngx_http_variable_tcpinfo,
  384.       0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  386.     { ngx_string("tcpinfo_rttvar"), NULL, ngx_http_variable_tcpinfo,
  387.       1, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  389.     { ngx_string("tcpinfo_snd_cwnd"), NULL, ngx_http_variable_tcpinfo,
  390.       2, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  392.     { ngx_string("tcpinfo_rcv_space"), NULL, ngx_http_variable_tcpinfo,
  393.       3, NGX_HTTP_VAR_NOCACHEABLE, 0 },
  394. #endif

  396.     { ngx_string("http_"), NULL, ngx_http_variable_unknown_header_in,
  397.       0, NGX_HTTP_VAR_PREFIX, 0 },

  399.     { ngx_string("sent_http_"), NULL, ngx_http_variable_unknown_header_out,
  400.       0, NGX_HTTP_VAR_PREFIX, 0 },

  402.     { ngx_string("sent_trailer_"), NULL, ngx_http_variable_unknown_trailer_out,
  403.       0, NGX_HTTP_VAR_PREFIX, 0 },

  405.     { ngx_string("cookie_"), NULL, ngx_http_variable_cookie,
  406.       0, NGX_HTTP_VAR_PREFIX, 0 },

  408.     { ngx_string("arg_"), NULL, ngx_http_variable_argument,
  409.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  411.       ngx_http_null_variable
  412. };


  415. ‌ngx_http_variable_value_t  ngx_http_variable_null_value =
  416.     ngx_http_variable("");
  417. ‌ngx_http_variable_value_t  ngx_http_variable_true_value =
  418.     ngx_http_variable("1");


  421. ‌static ngx_uint_t  ngx_http_variable_depth = 100;


  424. ngx_http_variable_t *
  425. ‌ngx_http_add_variable(ngx_conf_t *cf, ngx_str_t *name, ngx_uint_t flags)
  426. {
  427.     ngx_int_t                   rc;
  428.     ngx_uint_t                  i;
  429.     ngx_hash_key_t             *key;
  430.     ngx_http_variable_t        *v;
  431.     ngx_http_core_main_conf_t  *cmcf;

  433.     if (name->len == 0) {
  434.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  435.                            "invalid variable name \"$\"");
  436.         return NULL;
  437.     }

  439.     if (flags & NGX_HTTP_VAR_PREFIX) {
  440.         return ngx_http_add_prefix_variable(cf, name, flags);
  441.     }

  443.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  445.     key = cmcf->variables_keys->keys.elts;
  446.     for (i = 0; i < cmcf->variables_keys->keys.nelts; i++) {
  447.         if (name->len != key[i].key.len
  448.             || ngx_strncasecmp(name->data, key[i].key.data, name->len) != 0)
  449.         {
  450.             continue;
  451.         }

  453.         v = key[i].value;

  455.         if (!(v->flags & NGX_HTTP_VAR_CHANGEABLE)) {
  456.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  457.                                "the duplicate \"%V\" variable", name);
  458.             return NULL;
  459.         }

  461.         if (!(flags & NGX_HTTP_VAR_WEAK)) {
  462.             v->flags &= ~NGX_HTTP_VAR_WEAK;
  463.         }

  465.         return v;
  466.     }

  468.     v = ngx_palloc(cf->pool, sizeof(ngx_http_variable_t));
  469.     if (v == NULL) {
  470.         return NULL;
  471.     }

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

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

  481.     v->set_handler = NULL;
  482.     v->get_handler = NULL;
  483.     v->data = 0;
  484.     v->flags = flags;
  485.     v->index = 0;

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

  489.     if (rc == NGX_ERROR) {
  490.         return NULL;
  491.     }

  493.     if (rc == NGX_BUSY) {
  494.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  495.                            "conflicting variable name \"%V\"", name);
  496.         return NULL;
  497.     }

  499.     return v;
  500. }


  503. static ngx_http_variable_t *
  504. ‌ngx_http_add_prefix_variable(ngx_conf_t *cf, ngx_str_t *name, ngx_uint_t flags)
  505. {
  506.     ngx_uint_t                  i;
  507.     ngx_http_variable_t        *v;
  508.     ngx_http_core_main_conf_t  *cmcf;

  510.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  512.     v = cmcf->prefix_variables.elts;
  513.     for (i = 0; i < cmcf->prefix_variables.nelts; i++) {
  514.         if (name->len != v[i].name.len
  515.             || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
  516.         {
  517.             continue;
  518.         }

  520.         v = &v[i];

  522.         if (!(v->flags & NGX_HTTP_VAR_CHANGEABLE)) {
  523.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  524.                                "the duplicate \"%V\" variable", name);
  525.             return NULL;
  526.         }

  528.         if (!(flags & NGX_HTTP_VAR_WEAK)) {
  529.             v->flags &= ~NGX_HTTP_VAR_WEAK;
  530.         }

  532.         return v;
  533.     }

  535.     v = ngx_array_push(&cmcf->prefix_variables);
  536.     if (v == NULL) {
  537.         return NULL;
  538.     }

  540.     v->name.len = name->len;
  541.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  542.     if (v->name.data == NULL) {
  543.         return NULL;
  544.     }

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

  548.     v->set_handler = NULL;
  549.     v->get_handler = NULL;
  550.     v->data = 0;
  551.     v->flags = flags;
  552.     v->index = 0;

  554.     return v;
  555. }


  558. ngx_int_t
  559. ‌ngx_http_get_variable_index(ngx_conf_t *cf, ngx_str_t *name)
  560. {
  561.     ngx_uint_t                  i;
  562.     ngx_http_variable_t        *v;
  563.     ngx_http_core_main_conf_t  *cmcf;

  565.     if (name->len == 0) {
  566.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  567.                            "invalid variable name \"$\"");
  568.         return NGX_ERROR;
  569.     }

  571.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  573.     v = cmcf->variables.elts;

  575.     if (v == NULL) {
  576.         if (ngx_array_init(&cmcf->variables, cf->pool, 4,
  577.                            sizeof(ngx_http_variable_t))
  578.             != NGX_OK)
  579.         {
  580.             return NGX_ERROR;
  581.         }

  583.     } else {
  584.         for (i = 0; i < cmcf->variables.nelts; i++) {
  585.             if (name->len != v[i].name.len
  586.                 || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
  587.             {
  588.                 continue;
  589.             }

  591.             return i;
  592.         }
  593.     }

  595.     v = ngx_array_push(&cmcf->variables);
  596.     if (v == NULL) {
  597.         return NGX_ERROR;
  598.     }

  600.     v->name.len = name->len;
  601.     v->name.data = ngx_pnalloc(cf->pool, name->len);
  602.     if (v->name.data == NULL) {
  603.         return NGX_ERROR;
  604.     }

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

  608.     v->set_handler = NULL;
  609.     v->get_handler = NULL;
  610.     v->data = 0;
  611.     v->flags = 0;
  612.     v->index = cmcf->variables.nelts - 1;

  614.     return v->index;
  615. }


  618. ngx_http_variable_value_t *
  619. ‌ngx_http_get_indexed_variable(ngx_http_request_t *r, ngx_uint_t index)
  620. {
  621.     ngx_http_variable_t        *v;
  622.     ngx_http_core_main_conf_t  *cmcf;

  624.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  626.     if (cmcf->variables.nelts <= index) {
  627.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  628.                       "unknown variable index: %ui", index);
  629.         return NULL;
  630.     }

  632.     if (r->variables[index].not_found || r->variables[index].valid) {
  633.         return &r->variables[index];
  634.     }

  636.     v = cmcf->variables.elts;

  638.     if (ngx_http_variable_depth == 0) {
  639.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  640.                       "cycle while evaluating variable \"%V\"",
  641.                       &v[index].name);
  642.         return NULL;
  643.     }

  645.     ngx_http_variable_depth--;

  647.     if (v[index].get_handler(r, &r->variables[index], v[index].data)
  648.         == NGX_OK)
  649.     {
  650.         ngx_http_variable_depth++;

  652.         if (v[index].flags & NGX_HTTP_VAR_NOCACHEABLE) {
  653.             r->variables[index].no_cacheable = 1;
  654.         }

  656.         return &r->variables[index];
  657.     }

  659.     ngx_http_variable_depth++;

  661.     r->variables[index].valid = 0;
  662.     r->variables[index].not_found = 1;

  664.     return NULL;
  665. }


  668. ngx_http_variable_value_t *
  669. ‌ngx_http_get_flushed_variable(ngx_http_request_t *r, ngx_uint_t index)
  670. {
  671.     ngx_http_variable_value_t  *v;

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

  675.     if (v->valid || v->not_found) {
  676.         if (!v->no_cacheable) {
  677.             return v;
  678.         }

  680.         v->valid = 0;
  681.         v->not_found = 0;
  682.     }

  684.     return ngx_http_get_indexed_variable(r, index);
  685. }


  688. ngx_http_variable_value_t *
  689. ‌ngx_http_get_variable(ngx_http_request_t *r, ngx_str_t *name, ngx_uint_t key)
  690. {
  691.     size_t                      len;
  692.     ngx_uint_t                  i, n;
  693.     ngx_http_variable_t        *v;
  694.     ngx_http_variable_value_t  *vv;
  695.     ngx_http_core_main_conf_t  *cmcf;

  697.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  701.     if (v) {
  702.         if (v->flags & NGX_HTTP_VAR_INDEXED) {
  703.             return ngx_http_get_flushed_variable(r, v->index);
  704.         }

  706.         if (ngx_http_variable_depth == 0) {
  707.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  708.                           "cycle while evaluating variable \"%V\"", name);
  709.             return NULL;
  710.         }

  712.         ngx_http_variable_depth--;

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

  716.         if (vv && v->get_handler(r, vv, v->data) == NGX_OK) {
  717.             ngx_http_variable_depth++;
  718.             return vv;
  719.         }

  721.         ngx_http_variable_depth++;
  722.         return NULL;
  723.     }

  725.     vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
  726.     if (vv == NULL) {
  727.         return NULL;
  728.     }

  730.     len = 0;

  732.     v = cmcf->prefix_variables.elts;
  733.     n = cmcf->prefix_variables.nelts;

  735.     for (i = 0; i < cmcf->prefix_variables.nelts; i++) {
  736.         if (name->len >= v[i].name.len && name->len > len
  737.             && ngx_strncmp(name->data, v[i].name.data, v[i].name.len) == 0)
  738.         {
  739.             len = v[i].name.len;
  740.             n = i;
  741.         }
  742.     }

  744.     if (n != cmcf->prefix_variables.nelts) {
  745.         if (v[n].get_handler(r, vv, (uintptr_t) name) == NGX_OK) {
  746.             return vv;
  747.         }

  749.         return NULL;
  750.     }

  752.     vv->not_found = 1;

  754.     return vv;
  755. }


  758. static ngx_int_t
  759. ‌ngx_http_variable_request(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  760.     uintptr_t data)
  761. {
  762.     ngx_str_t  *s;

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

  766.     if (s->data) {
  767.         v->len = s->len;
  768.         v->valid = 1;
  769.         v->no_cacheable = 0;
  770.         v->not_found = 0;
  771.         v->data = s->data;

  773.     } else {
  774.         v->not_found = 1;
  775.     }

  777.     return NGX_OK;
  778. }


  781. #if 0

  783. static void
  784. ngx_http_variable_request_set(ngx_http_request_t *r,
  785.     ngx_http_variable_value_t *v, uintptr_t data)
  786. {
  787.     ngx_str_t  *s;

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

  791.     s->len = v->len;
  792.     s->data = v->data;
  793. }

  795. #endif


  798. static ngx_int_t
  799. ‌ngx_http_variable_request_get_size(ngx_http_request_t *r,
  800.     ngx_http_variable_value_t *v, uintptr_t data)
  801. {
  802.     size_t  *sp;

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

  806.     v->data = ngx_pnalloc(r->pool, NGX_SIZE_T_LEN);
  807.     if (v->data == NULL) {
  808.         return NGX_ERROR;
  809.     }

  811.     v->len = ngx_sprintf(v->data, "%uz", *sp) - v->data;
  812.     v->valid = 1;
  813.     v->no_cacheable = 0;
  814.     v->not_found = 0;

  816.     return NGX_OK;
  817. }


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


  828. static ngx_int_t
  829. ‌ngx_http_variable_cookies(ngx_http_request_t *r,
  830.     ngx_http_variable_value_t *v, uintptr_t data)
  831. {
  832.     return ngx_http_variable_headers_internal(r, v, data, ';');
  833. }


  836. static ngx_int_t
  837. ‌ngx_http_variable_headers_internal(ngx_http_request_t *r,
  838.     ngx_http_variable_value_t *v, uintptr_t data, u_char sep)
  839. {
  840.     size_t            len;
  841.     u_char           *p, *end;
  842.     ngx_table_elt_t  *h, *th;

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

  846.     len = 0;

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

  850.         if (th->hash == 0) {
  851.             continue;
  852.         }

  854.         len += th->value.len + 2;
  855.     }

  857.     if (len == 0) {
  858.         v->not_found = 1;
  859.         return NGX_OK;
  860.     }

  862.     len -= 2;

  864.     v->valid = 1;
  865.     v->no_cacheable = 0;
  866.     v->not_found = 0;

  868.     if (h->next == NULL) {
  869.         v->len = h->value.len;
  870.         v->data = h->value.data;

  872.         return NGX_OK;
  873.     }

  875.     p = ngx_pnalloc(r->pool, len);
  876.     if (p == NULL) {
  877.         return NGX_ERROR;
  878.     }

  880.     v->len = len;
  881.     v->data = p;

  883.     end = p + len;

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

  887.         if (th->hash == 0) {
  888.             continue;
  889.         }

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

  893.         if (p == end) {
  894.             break;
  895.         }

  897.         *p++ = sep; *p++ = ' ';
  898.     }

  900.     return NGX_OK;
  901. }


  904. static ngx_int_t
  905. ‌ngx_http_variable_unknown_header_in(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_in.headers.part,
  910.                                             sizeof("http_") - 1);
  911. }


  914. static ngx_int_t
  915. ‌ngx_http_variable_unknown_header_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.headers.part,
  920.                                             sizeof("sent_http_") - 1);
  921. }


  924. static ngx_int_t
  925. ‌ngx_http_variable_unknown_trailer_out(ngx_http_request_t *r,
  926.     ngx_http_variable_value_t *v, uintptr_t data)
  927. {
  928.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  929.                                             &r->headers_out.trailers.part,
  930.                                             sizeof("sent_trailer_") - 1);
  931. }


  934. ngx_int_t
  935. ‌ngx_http_variable_unknown_header(ngx_http_request_t *r,
  936.     ngx_http_variable_value_t *v, ngx_str_t *var,
  937.     ngx_list_part_t *part, size_t prefix)
  938. {
  939.     u_char           *p, ch;
  940.     size_t            len;
  941.     ngx_uint_t        i, n;
  942.     ngx_table_elt_t  *header, *h, **ph;

  944.     ph = &h;
  945. #if (NGX_SUPPRESS_WARN)
  946.     len = 0;
  947. #endif

  949.     header = part->elts;

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

  953.         if (i >= part->nelts) {
  954.             if (part->next == NULL) {
  955.                 break;
  956.             }

  958.             part = part->next;
  959.             header = part->elts;
  960.             i = 0;
  961.         }

  963.         if (header[i].hash == 0) {
  964.             continue;
  965.         }

  967.         if (header[i].key.len != var->len - prefix) {
  968.             continue;
  969.         }

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

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

  977.             } else if (ch == '-') {
  978.                 ch = '_';
  979.             }

  981.             if (var->data[n + prefix] != ch) {
  982.                 break;
  983.             }
  984.         }

  986.         if (n != var->len - prefix) {
  987.             continue;
  988.         }

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

  992.         *ph = &header[i];
  993.         ph = &header[i].next;
  994.     }

  996.     *ph = NULL;

  998.     if (h == NULL) {
  999.         v->not_found = 1;
  1000.         return NGX_OK;
  1001.     }

  1003.     len -= 2;

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

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

  1013.         return NGX_OK;
  1014.     }

  1016.     p = ngx_pnalloc(r->pool, len);
  1017.     if (p == NULL) {
  1018.         return NGX_ERROR;
  1019.     }

  1021.     v->len = len;
  1022.     v->valid = 1;
  1023.     v->no_cacheable = 0;
  1024.     v->not_found = 0;
  1025.     v->data = p;

  1027.     for ( ;; ) {

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

  1031.         if (h->next == NULL) {
  1032.             break;
  1033.         }

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

  1037.         h = h->next;
  1038.     }

  1040.     return NGX_OK;
  1041. }


  1044. static ngx_int_t
  1045. ‌ngx_http_variable_request_line(ngx_http_request_t *r,
  1046.     ngx_http_variable_value_t *v, uintptr_t data)
  1047. {
  1048.     u_char  *p, *s;

  1050.     s = r->request_line.data;

  1052.     if (s == NULL) {
  1053.         s = r->request_start;

  1055.         if (s == NULL) {
  1056.             v->not_found = 1;
  1057.             return NGX_OK;
  1058.         }

  1060.         for (p = s; p < r->header_in->last; p++) {
  1061.             if (*p == CR || *p == LF) {
  1062.                 break;
  1063.             }
  1064.         }

  1066.         r->request_line.len = p - s;
  1067.         r->request_line.data = s;
  1068.     }

  1070.     v->len = r->request_line.len;
  1071.     v->valid = 1;
  1072.     v->no_cacheable = 0;
  1073.     v->not_found = 0;
  1074.     v->data = s;

  1076.     return NGX_OK;
  1077. }


  1080. static ngx_int_t
  1081. ‌ngx_http_variable_cookie(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1082.     uintptr_t data)
  1083. {
  1084.     ngx_str_t *name = (ngx_str_t *) data;

  1086.     ngx_str_t  cookie, s;

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

  1091.     if (ngx_http_parse_cookie_lines(r, r->headers_in.cookie, &s, &cookie)
  1092.         == NULL)
  1093.     {
  1094.         v->not_found = 1;
  1095.         return NGX_OK;
  1096.     }

  1098.     v->len = cookie.len;
  1099.     v->valid = 1;
  1100.     v->no_cacheable = 0;
  1101.     v->not_found = 0;
  1102.     v->data = cookie.data;

  1104.     return NGX_OK;
  1105. }


  1108. static ngx_int_t
  1109. ‌ngx_http_variable_argument(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1110.     uintptr_t data)
  1111. {
  1112.     ngx_str_t *name = (ngx_str_t *) data;

  1114.     u_char     *arg;
  1115.     size_t      len;
  1116.     ngx_str_t   value;

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

  1121.     if (len == 0 || ngx_http_arg(r, arg, len, &value) != NGX_OK) {
  1122.         v->not_found = 1;
  1123.         return NGX_OK;
  1124.     }

  1126.     v->data = value.data;
  1127.     v->len = value.len;
  1128.     v->valid = 1;
  1129.     v->no_cacheable = 0;
  1130.     v->not_found = 0;

  1132.     return NGX_OK;
  1133. }


  1136. #if (NGX_HAVE_TCP_INFO)

  1138. static ngx_int_t
  1139. ‌ngx_http_variable_tcpinfo(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1140.     uintptr_t data)
  1141. {
  1142.     struct tcp_info  ti;
  1143.     socklen_t        len;
  1144.     uint32_t         value;

  1146.     len = sizeof(struct tcp_info);
  1147.     if (getsockopt(r->connection->fd, IPPROTO_TCP, TCP_INFO, &ti, &len) == -1) {
  1148.         v->not_found = 1;
  1149.         return NGX_OK;
  1150.     }

  1152.     v->data = ngx_pnalloc(r->pool, NGX_INT32_LEN);
  1153.     if (v->data == NULL) {
  1154.         return NGX_ERROR;
  1155.     }

  1157.     switch (data) {
  1158.     case 0:
  1159.         value = ti.tcpi_rtt;
  1160.         break;

  1162.     case 1:
  1163.         value = ti.tcpi_rttvar;
  1164.         break;

  1166.     case 2:
  1167.         value = ti.tcpi_snd_cwnd;
  1168.         break;

  1170.     case 3:
  1171.         value = ti.tcpi_rcv_space;
  1172.         break;

  1174.     /* suppress warning */
  1175.     default:
  1176.         value = 0;
  1177.         break;
  1178.     }

  1180.     v->len = ngx_sprintf(v->data, "%uD", value) - v->data;
  1181.     v->valid = 1;
  1182.     v->no_cacheable = 0;
  1183.     v->not_found = 0;

  1185.     return NGX_OK;
  1186. }

  1188. #endif


  1191. static ngx_int_t
  1192. ‌ngx_http_variable_content_length(ngx_http_request_t *r,
  1193.     ngx_http_variable_value_t *v, uintptr_t data)
  1194. {
  1195.     u_char  *p;

  1197.     if (r->headers_in.content_length) {
  1198.         v->len = r->headers_in.content_length->value.len;
  1199.         v->data = r->headers_in.content_length->value.data;
  1200.         v->valid = 1;
  1201.         v->no_cacheable = 0;
  1202.         v->not_found = 0;

  1204.     } else if (r->reading_body) {
  1205.         v->not_found = 1;
  1206.         v->no_cacheable = 1;

  1208.     } else if (r->headers_in.content_length_n >= 0) {
  1209.         p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1210.         if (p == NULL) {
  1211.             return NGX_ERROR;
  1212.         }

  1214.         v->len = ngx_sprintf(p, "%O", r->headers_in.content_length_n) - p;
  1215.         v->data = p;
  1216.         v->valid = 1;
  1217.         v->no_cacheable = 0;
  1218.         v->not_found = 0;

  1220.     } else if (r->headers_in.chunked) {
  1221.         v->not_found = 1;
  1222.         v->no_cacheable = 1;

  1224.     } else {
  1225.         v->not_found = 1;
  1226.     }

  1228.     return NGX_OK;
  1229. }


  1232. static ngx_int_t
  1233. ‌ngx_http_variable_host(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  1234.     uintptr_t data)
  1235. {
  1236.     ngx_http_core_srv_conf_t  *cscf;

  1238.     if (r->headers_in.server.len) {
  1239.         v->len = r->headers_in.server.len;
  1240.         v->data = r->headers_in.server.data;

  1242.     } else {
  1243.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1245.         v->len = cscf->server_name.len;
  1246.         v->data = cscf->server_name.data;
  1247.     }

  1249.     v->valid = 1;
  1250.     v->no_cacheable = 0;
  1251.     v->not_found = 0;

  1253.     return NGX_OK;
  1254. }


  1257. static ngx_int_t
  1258. ‌ngx_http_variable_binary_remote_addr(ngx_http_request_t *r,
  1259.     ngx_http_variable_value_t *v, uintptr_t data)
  1260. {
  1261.     struct sockaddr_in   *sin;
  1262. #if (NGX_HAVE_INET6)
  1263.     struct sockaddr_in6  *sin6;
  1264. #endif

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

  1268. #if (NGX_HAVE_INET6)
  1269.     case AF_INET6:
  1270.         sin6 = (struct sockaddr_in6 *) r->connection->sockaddr;

  1272.         v->len = sizeof(struct in6_addr);
  1273.         v->valid = 1;
  1274.         v->no_cacheable = 0;
  1275.         v->not_found = 0;
  1276.         v->data = sin6->sin6_addr.s6_addr;

  1278.         break;
  1279. #endif

  1281. #if (NGX_HAVE_UNIX_DOMAIN)
  1282.     case AF_UNIX:

  1284.         v->len = r->connection->addr_text.len;
  1285.         v->valid = 1;
  1286.         v->no_cacheable = 0;
  1287.         v->not_found = 0;
  1288.         v->data = r->connection->addr_text.data;

  1290.         break;
  1291. #endif

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

  1296.         v->len = sizeof(in_addr_t);
  1297.         v->valid = 1;
  1298.         v->no_cacheable = 0;
  1299.         v->not_found = 0;
  1300.         v->data = (u_char *) &sin->sin_addr;

  1302.         break;
  1303.     }

  1305.     return NGX_OK;
  1306. }


  1309. static ngx_int_t
  1310. ‌ngx_http_variable_remote_addr(ngx_http_request_t *r,
  1311.     ngx_http_variable_value_t *v, uintptr_t data)
  1312. {
  1313.     v->len = r->connection->addr_text.len;
  1314.     v->valid = 1;
  1315.     v->no_cacheable = 0;
  1316.     v->not_found = 0;
  1317.     v->data = r->connection->addr_text.data;

  1319.     return NGX_OK;
  1320. }


  1323. static ngx_int_t
  1324. ‌ngx_http_variable_remote_port(ngx_http_request_t *r,
  1325.     ngx_http_variable_value_t *v, uintptr_t data)
  1326. {
  1327.     ngx_uint_t  port;

  1329.     v->len = 0;
  1330.     v->valid = 1;
  1331.     v->no_cacheable = 0;
  1332.     v->not_found = 0;

  1334.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1335.     if (v->data == NULL) {
  1336.         return NGX_ERROR;
  1337.     }

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

  1341.     if (port > 0 && port < 65536) {
  1342.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1343.     }

  1345.     return NGX_OK;
  1346. }


  1349. static ngx_int_t
  1350. ‌ngx_http_variable_proxy_protocol_addr(ngx_http_request_t *r,
  1351.     ngx_http_variable_value_t *v, uintptr_t data)
  1352. {
  1353.     ngx_str_t             *addr;
  1354.     ngx_proxy_protocol_t  *pp;

  1356.     pp = r->connection->proxy_protocol;
  1357.     if (pp == NULL) {
  1358.         v->not_found = 1;
  1359.         return NGX_OK;
  1360.     }

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

  1364.     v->len = addr->len;
  1365.     v->valid = 1;
  1366.     v->no_cacheable = 0;
  1367.     v->not_found = 0;
  1368.     v->data = addr->data;

  1370.     return NGX_OK;
  1371. }


  1374. static ngx_int_t
  1375. ‌ngx_http_variable_proxy_protocol_port(ngx_http_request_t *r,
  1376.     ngx_http_variable_value_t *v, uintptr_t data)
  1377. {
  1378.     ngx_uint_t             port;
  1379.     ngx_proxy_protocol_t  *pp;

  1381.     pp = r->connection->proxy_protocol;
  1382.     if (pp == NULL) {
  1383.         v->not_found = 1;
  1384.         return NGX_OK;
  1385.     }

  1387.     v->len = 0;
  1388.     v->valid = 1;
  1389.     v->no_cacheable = 0;
  1390.     v->not_found = 0;

  1392.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1393.     if (v->data == NULL) {
  1394.         return NGX_ERROR;
  1395.     }

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

  1399.     if (port > 0 && port < 65536) {
  1400.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1401.     }

  1403.     return NGX_OK;
  1404. }


  1407. static ngx_int_t
  1408. ‌ngx_http_variable_proxy_protocol_tlv(ngx_http_request_t *r,
  1409.     ngx_http_variable_value_t *v, uintptr_t data)
  1410. {
  1411.     ngx_str_t *name = (ngx_str_t *) data;

  1413.     ngx_int_t  rc;
  1414.     ngx_str_t  tlv, value;

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

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

  1421.     if (rc == NGX_ERROR) {
  1422.         return NGX_ERROR;
  1423.     }

  1425.     if (rc == NGX_DECLINED) {
  1426.         v->not_found = 1;
  1427.         return NGX_OK;
  1428.     }

  1430.     v->len = value.len;
  1431.     v->valid = 1;
  1432.     v->no_cacheable = 0;
  1433.     v->not_found = 0;
  1434.     v->data = value.data;

  1436.     return NGX_OK;
  1437. }


  1440. static ngx_int_t
  1441. ‌ngx_http_variable_server_addr(ngx_http_request_t *r,
  1442.     ngx_http_variable_value_t *v, uintptr_t data)
  1443. {
  1444.     ngx_str_t  s;
  1445.     u_char     addr[NGX_SOCKADDR_STRLEN];

  1447.     s.len = NGX_SOCKADDR_STRLEN;
  1448.     s.data = addr;

  1450.     if (ngx_connection_local_sockaddr(r->connection, &s, 0) != NGX_OK) {
  1451.         return NGX_ERROR;
  1452.     }

  1454.     s.data = ngx_pnalloc(r->pool, s.len);
  1455.     if (s.data == NULL) {
  1456.         return NGX_ERROR;
  1457.     }

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

  1461.     v->len = s.len;
  1462.     v->valid = 1;
  1463.     v->no_cacheable = 0;
  1464.     v->not_found = 0;
  1465.     v->data = s.data;

  1467.     return NGX_OK;
  1468. }


  1471. static ngx_int_t
  1472. ‌ngx_http_variable_server_port(ngx_http_request_t *r,
  1473.     ngx_http_variable_value_t *v, uintptr_t data)
  1474. {
  1475.     ngx_uint_t  port;

  1477.     v->len = 0;
  1478.     v->valid = 1;
  1479.     v->no_cacheable = 0;
  1480.     v->not_found = 0;

  1482.     if (ngx_connection_local_sockaddr(r->connection, NULL, 0) != NGX_OK) {
  1483.         return NGX_ERROR;
  1484.     }

  1486.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1487.     if (v->data == NULL) {
  1488.         return NGX_ERROR;
  1489.     }

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

  1493.     if (port > 0 && port < 65536) {
  1494.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1495.     }

  1497.     return NGX_OK;
  1498. }


  1501. static ngx_int_t
  1502. ‌ngx_http_variable_scheme(ngx_http_request_t *r,
  1503.     ngx_http_variable_value_t *v, uintptr_t data)
  1504. {
  1505. #if (NGX_HTTP_SSL)

  1507.     if (r->connection->ssl) {
  1508.         v->len = sizeof("https") - 1;
  1509.         v->valid = 1;
  1510.         v->no_cacheable = 0;
  1511.         v->not_found = 0;
  1512.         v->data = (u_char *) "https";

  1514.         return NGX_OK;
  1515.     }

  1517. #endif

  1519.     v->len = sizeof("http") - 1;
  1520.     v->valid = 1;
  1521.     v->no_cacheable = 0;
  1522.     v->not_found = 0;
  1523.     v->data = (u_char *) "http";

  1525.     return NGX_OK;
  1526. }


  1529. static ngx_int_t
  1530. ‌ngx_http_variable_https(ngx_http_request_t *r,
  1531.     ngx_http_variable_value_t *v, uintptr_t data)
  1532. {
  1533. #if (NGX_HTTP_SSL)

  1535.     if (r->connection->ssl) {
  1536.         v->len = sizeof("on") - 1;
  1537.         v->valid = 1;
  1538.         v->no_cacheable = 0;
  1539.         v->not_found = 0;
  1540.         v->data = (u_char *) "on";

  1542.         return NGX_OK;
  1543.     }

  1545. #endif

  1547.     *v = ngx_http_variable_null_value;

  1549.     return NGX_OK;
  1550. }


  1553. static ngx_int_t
  1554. ‌ngx_http_variable_request_port(ngx_http_request_t *r,
  1555.     ngx_http_variable_value_t *v, uintptr_t data)
  1556. {
  1557.     ngx_uint_t  port;

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

  1564.     v->data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
  1565.     if (v->data == NULL) {
  1566.         return NGX_ERROR;
  1567.     }

  1569.     port = r->port;

  1571.     if (port > 0 && port < 65536) {
  1572.         v->len = ngx_sprintf(v->data, "%ui", port) - v->data;
  1573.     }

  1575.     return NGX_OK;
  1576. }


  1579. static ngx_int_t
  1580. ‌ngx_http_variable_is_request_port(ngx_http_request_t *r,
  1581.     ngx_http_variable_value_t *v, uintptr_t data)
  1582. {
  1583.     if (r->port == 0) {
  1584.         *v = ngx_http_variable_null_value;
  1585.         return NGX_OK;
  1586.     }

  1588.     v->len = 1;
  1589.     v->valid = 1;
  1590.     v->no_cacheable = 0;
  1591.     v->not_found = 0;
  1592.     v->data = (u_char *) ":";

  1594.     return NGX_OK;
  1595. }


  1598. static void
  1599. ‌ngx_http_variable_set_args(ngx_http_request_t *r,
  1600.     ngx_http_variable_value_t *v, uintptr_t data)
  1601. {
  1602.     r->args.len = v->len;
  1603.     r->args.data = v->data;
  1604.     r->valid_unparsed_uri = 0;
  1605. }


  1608. static ngx_int_t
  1609. ‌ngx_http_variable_is_args(ngx_http_request_t *r,
  1610.     ngx_http_variable_value_t *v, uintptr_t data)
  1611. {
  1612.     if (r->args.len == 0) {
  1613.         *v = ngx_http_variable_null_value;
  1614.         return NGX_OK;
  1615.     }

  1617.     v->len = 1;
  1618.     v->valid = 1;
  1619.     v->no_cacheable = 0;
  1620.     v->not_found = 0;
  1621.     v->data = (u_char *) "?";

  1623.     return NGX_OK;
  1624. }


  1627. static ngx_int_t
  1628. ‌ngx_http_variable_document_root(ngx_http_request_t *r,
  1629.     ngx_http_variable_value_t *v, uintptr_t data)
  1630. {
  1631.     ngx_str_t                  path;
  1632.     ngx_http_core_loc_conf_t  *clcf;

  1634.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1636.     if (clcf->root_lengths == NULL) {
  1637.         v->len = clcf->root.len;
  1638.         v->valid = 1;
  1639.         v->no_cacheable = 0;
  1640.         v->not_found = 0;
  1641.         v->data = clcf->root.data;

  1643.     } else {
  1644.         if (ngx_http_script_run(r, &path, clcf->root_lengths->elts, 0,
  1645.                                 clcf->root_values->elts)
  1646.             == NULL)
  1647.         {
  1648.             return NGX_ERROR;
  1649.         }

  1651.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, &path)
  1652.             != NGX_OK)
  1653.         {
  1654.             return NGX_ERROR;
  1655.         }

  1657.         v->len = path.len;
  1658.         v->valid = 1;
  1659.         v->no_cacheable = 0;
  1660.         v->not_found = 0;
  1661.         v->data = path.data;
  1662.     }

  1664.     return NGX_OK;
  1665. }


  1668. static ngx_int_t
  1669. ‌ngx_http_variable_realpath_root(ngx_http_request_t *r,
  1670.     ngx_http_variable_value_t *v, uintptr_t data)
  1671. {
  1672.     u_char                    *real;
  1673.     size_t                     len;
  1674.     ngx_str_t                  path;
  1675.     ngx_http_core_loc_conf_t  *clcf;
  1676. #if (NGX_HAVE_MAX_PATH)
  1677.     u_char                     buffer[NGX_MAX_PATH];
  1678. #endif

  1680.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1682.     if (clcf->root_lengths == NULL) {
  1683.         path = clcf->root;

  1685.     } else {
  1686.         if (ngx_http_script_run(r, &path, clcf->root_lengths->elts, 1,
  1687.                                 clcf->root_values->elts)
  1688.             == NULL)
  1689.         {
  1690.             return NGX_ERROR;
  1691.         }

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

  1695.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, &path)
  1696.             != NGX_OK)
  1697.         {
  1698.             return NGX_ERROR;
  1699.         }
  1700.     }

  1702. #if (NGX_HAVE_MAX_PATH)
  1703.     real = buffer;
  1704. #else
  1705.     real = NULL;
  1706. #endif

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

  1710.     if (real == NULL) {
  1711.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  1712.                       ngx_realpath_n " \"%s\" failed", path.data);
  1713.         return NGX_ERROR;
  1714.     }

  1716.     len = ngx_strlen(real);

  1718.     v->data = ngx_pnalloc(r->pool, len);
  1719.     if (v->data == NULL) {
  1720. #if !(NGX_HAVE_MAX_PATH)
  1721.         ngx_free(real);
  1722. #endif
  1723.         return NGX_ERROR;
  1724.     }

  1726.     v->len = len;
  1727.     v->valid = 1;
  1728.     v->no_cacheable = 0;
  1729.     v->not_found = 0;

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

  1733. #if !(NGX_HAVE_MAX_PATH)
  1734.     ngx_free(real);
  1735. #endif

  1737.     return NGX_OK;
  1738. }


  1741. static ngx_int_t
  1742. ‌ngx_http_variable_request_filename(ngx_http_request_t *r,
  1743.     ngx_http_variable_value_t *v, uintptr_t data)
  1744. {
  1745.     size_t     root;
  1746.     ngx_str_t  path;

  1748.     if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
  1749.         return NGX_ERROR;
  1750.     }

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

  1754.     v->len = path.len - 1;
  1755.     v->valid = 1;
  1756.     v->no_cacheable = 0;
  1757.     v->not_found = 0;
  1758.     v->data = path.data;

  1760.     return NGX_OK;
  1761. }


  1764. static ngx_int_t
  1765. ‌ngx_http_variable_server_name(ngx_http_request_t *r,
  1766.     ngx_http_variable_value_t *v, uintptr_t data)
  1767. {
  1768.     ngx_http_core_srv_conf_t  *cscf;

  1770.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1772.     v->len = cscf->server_name.len;
  1773.     v->valid = 1;
  1774.     v->no_cacheable = 0;
  1775.     v->not_found = 0;
  1776.     v->data = cscf->server_name.data;

  1778.     return NGX_OK;
  1779. }


  1782. static ngx_int_t
  1783. ‌ngx_http_variable_request_method(ngx_http_request_t *r,
  1784.     ngx_http_variable_value_t *v, uintptr_t data)
  1785. {
  1786.     if (r->main->method_name.data) {
  1787.         v->len = r->main->method_name.len;
  1788.         v->valid = 1;
  1789.         v->no_cacheable = 0;
  1790.         v->not_found = 0;
  1791.         v->data = r->main->method_name.data;

  1793.     } else {
  1794.         v->not_found = 1;
  1795.     }

  1797.     return NGX_OK;
  1798. }


  1801. static ngx_int_t
  1802. ‌ngx_http_variable_remote_user(ngx_http_request_t *r,
  1803.     ngx_http_variable_value_t *v, uintptr_t data)
  1804. {
  1805.     ngx_int_t  rc;

  1807.     rc = ngx_http_auth_basic_user(r);

  1809.     if (rc == NGX_DECLINED) {
  1810.         v->not_found = 1;
  1811.         return NGX_OK;
  1812.     }

  1814.     if (rc == NGX_ERROR) {
  1815.         return NGX_ERROR;
  1816.     }

  1818.     v->len = r->headers_in.user.len;
  1819.     v->valid = 1;
  1820.     v->no_cacheable = 0;
  1821.     v->not_found = 0;
  1822.     v->data = r->headers_in.user.data;

  1824.     return NGX_OK;
  1825. }


  1828. static ngx_int_t
  1829. ‌ngx_http_variable_bytes_sent(ngx_http_request_t *r,
  1830.     ngx_http_variable_value_t *v, uintptr_t data)
  1831. {
  1832.     u_char  *p;

  1834.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1835.     if (p == NULL) {
  1836.         return NGX_ERROR;
  1837.     }

  1839.     v->len = ngx_sprintf(p, "%O", r->connection->sent) - p;
  1840.     v->valid = 1;
  1841.     v->no_cacheable = 0;
  1842.     v->not_found = 0;
  1843.     v->data = p;

  1845.     return NGX_OK;
  1846. }


  1849. static ngx_int_t
  1850. ‌ngx_http_variable_body_bytes_sent(ngx_http_request_t *r,
  1851.     ngx_http_variable_value_t *v, uintptr_t data)
  1852. {
  1853.     off_t    sent;
  1854.     u_char  *p;

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

  1858.     if (sent < 0) {
  1859.         sent = 0;
  1860.     }

  1862.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1863.     if (p == NULL) {
  1864.         return NGX_ERROR;
  1865.     }

  1867.     v->len = ngx_sprintf(p, "%O", sent) - p;
  1868.     v->valid = 1;
  1869.     v->no_cacheable = 0;
  1870.     v->not_found = 0;
  1871.     v->data = p;

  1873.     return NGX_OK;
  1874. }


  1877. static ngx_int_t
  1878. ‌ngx_http_variable_pipe(ngx_http_request_t *r,
  1879.     ngx_http_variable_value_t *v, uintptr_t data)
  1880. {
  1881.     v->data = (u_char *) (r->pipeline ? "p" : ".");
  1882.     v->len = 1;
  1883.     v->valid = 1;
  1884.     v->no_cacheable = 0;
  1885.     v->not_found = 0;

  1887.     return NGX_OK;
  1888. }


  1891. static ngx_int_t
  1892. ‌ngx_http_variable_status(ngx_http_request_t *r,
  1893.     ngx_http_variable_value_t *v, uintptr_t data)
  1894. {
  1895.     ngx_uint_t  status;

  1897.     v->data = ngx_pnalloc(r->pool, NGX_INT_T_LEN);
  1898.     if (v->data == NULL) {
  1899.         return NGX_ERROR;
  1900.     }

  1902.     if (r->err_status) {
  1903.         status = r->err_status;

  1905.     } else if (r->headers_out.status) {
  1906.         status = r->headers_out.status;

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

  1911.     } else {
  1912.         status = 0;
  1913.     }

  1915.     v->len = ngx_sprintf(v->data, "%03ui", status) - v->data;
  1916.     v->valid = 1;
  1917.     v->no_cacheable = 0;
  1918.     v->not_found = 0;

  1920.     return NGX_OK;
  1921. }


  1924. static ngx_int_t
  1925. ‌ngx_http_variable_sent_content_type(ngx_http_request_t *r,
  1926.     ngx_http_variable_value_t *v, uintptr_t data)
  1927. {
  1928.     if (r->headers_out.content_type.len) {
  1929.         v->len = r->headers_out.content_type.len;
  1930.         v->valid = 1;
  1931.         v->no_cacheable = 0;
  1932.         v->not_found = 0;
  1933.         v->data = r->headers_out.content_type.data;

  1935.     } else {
  1936.         v->not_found = 1;
  1937.     }

  1939.     return NGX_OK;
  1940. }


  1943. static ngx_int_t
  1944. ‌ngx_http_variable_sent_content_length(ngx_http_request_t *r,
  1945.     ngx_http_variable_value_t *v, uintptr_t data)
  1946. {
  1947.     u_char  *p;

  1949.     if (r->headers_out.content_length) {
  1950.         v->len = r->headers_out.content_length->value.len;
  1951.         v->valid = 1;
  1952.         v->no_cacheable = 0;
  1953.         v->not_found = 0;
  1954.         v->data = r->headers_out.content_length->value.data;

  1956.         return NGX_OK;
  1957.     }

  1959.     if (r->headers_out.content_length_n >= 0) {
  1960.         p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  1961.         if (p == NULL) {
  1962.             return NGX_ERROR;
  1963.         }

  1965.         v->len = ngx_sprintf(p, "%O", r->headers_out.content_length_n) - p;
  1966.         v->valid = 1;
  1967.         v->no_cacheable = 0;
  1968.         v->not_found = 0;
  1969.         v->data = p;

  1971.         return NGX_OK;
  1972.     }

  1974.     v->not_found = 1;

  1976.     return NGX_OK;
  1977. }


  1980. static ngx_int_t
  1981. ‌ngx_http_variable_sent_location(ngx_http_request_t *r,
  1982.     ngx_http_variable_value_t *v, uintptr_t data)
  1983. {
  1984.     ngx_str_t  name;

  1986.     if (r->headers_out.location) {
  1987.         v->len = r->headers_out.location->value.len;
  1988.         v->valid = 1;
  1989.         v->no_cacheable = 0;
  1990.         v->not_found = 0;
  1991.         v->data = r->headers_out.location->value.data;

  1993.         return NGX_OK;
  1994.     }

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

  1998.     return ngx_http_variable_unknown_header(r, v, &name,
  1999.                                             &r->headers_out.headers.part,
  2000.                                             sizeof("sent_http_") - 1);
  2001. }


  2004. static ngx_int_t
  2005. ‌ngx_http_variable_sent_last_modified(ngx_http_request_t *r,
  2006.     ngx_http_variable_value_t *v, uintptr_t data)
  2007. {
  2008.     u_char  *p;

  2010.     if (r->headers_out.last_modified) {
  2011.         v->len = r->headers_out.last_modified->value.len;
  2012.         v->valid = 1;
  2013.         v->no_cacheable = 0;
  2014.         v->not_found = 0;
  2015.         v->data = r->headers_out.last_modified->value.data;

  2017.         return NGX_OK;
  2018.     }

  2020.     if (r->headers_out.last_modified_time >= 0) {
  2021.         p = ngx_pnalloc(r->pool, sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1);
  2022.         if (p == NULL) {
  2023.             return NGX_ERROR;
  2024.         }

  2026.         v->len = ngx_http_time(p, r->headers_out.last_modified_time) - p;
  2027.         v->valid = 1;
  2028.         v->no_cacheable = 0;
  2029.         v->not_found = 0;
  2030.         v->data = p;

  2032.         return NGX_OK;
  2033.     }

  2035.     v->not_found = 1;

  2037.     return NGX_OK;
  2038. }


  2041. static ngx_int_t
  2042. ‌ngx_http_variable_sent_connection(ngx_http_request_t *r,
  2043.     ngx_http_variable_value_t *v, uintptr_t data)
  2044. {
  2045.     size_t   len;
  2046.     char    *p;

  2048.     if (r->headers_out.status == NGX_HTTP_SWITCHING_PROTOCOLS) {
  2049.         len = sizeof("upgrade") - 1;
  2050.         p = "upgrade";

  2052.     } else if (r->keepalive) {
  2053.         len = sizeof("keep-alive") - 1;
  2054.         p = "keep-alive";

  2056.     } else {
  2057.         len = sizeof("close") - 1;
  2058.         p = "close";
  2059.     }

  2061.     v->len = len;
  2062.     v->valid = 1;
  2063.     v->no_cacheable = 0;
  2064.     v->not_found = 0;
  2065.     v->data = (u_char *) p;

  2067.     return NGX_OK;
  2068. }


  2071. static ngx_int_t
  2072. ‌ngx_http_variable_sent_keep_alive(ngx_http_request_t *r,
  2073.     ngx_http_variable_value_t *v, uintptr_t data)
  2074. {
  2075.     u_char                    *p;
  2076.     ngx_http_core_loc_conf_t  *clcf;

  2078.     if (r->keepalive) {
  2079.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2081.         if (clcf->keepalive_header) {

  2083.             p = ngx_pnalloc(r->pool, sizeof("timeout=") - 1 + NGX_TIME_T_LEN);
  2084.             if (p == NULL) {
  2085.                 return NGX_ERROR;
  2086.             }

  2088.             v->len = ngx_sprintf(p, "timeout=%T", clcf->keepalive_header) - p;
  2089.             v->valid = 1;
  2090.             v->no_cacheable = 0;
  2091.             v->not_found = 0;
  2092.             v->data = p;

  2094.             return NGX_OK;
  2095.         }
  2096.     }

  2098.     v->not_found = 1;

  2100.     return NGX_OK;
  2101. }


  2104. static ngx_int_t
  2105. ‌ngx_http_variable_sent_transfer_encoding(ngx_http_request_t *r,
  2106.     ngx_http_variable_value_t *v, uintptr_t data)
  2107. {
  2108.     if (r->chunked) {
  2109.         v->len = sizeof("chunked") - 1;
  2110.         v->valid = 1;
  2111.         v->no_cacheable = 0;
  2112.         v->not_found = 0;
  2113.         v->data = (u_char *) "chunked";

  2115.     } else {
  2116.         v->not_found = 1;
  2117.     }

  2119.     return NGX_OK;
  2120. }


  2123. static void
  2124. ‌ngx_http_variable_set_limit_rate(ngx_http_request_t *r,
  2125.     ngx_http_variable_value_t *v, uintptr_t data)
  2126. {
  2127.     ssize_t    s;
  2128.     ngx_str_t  val;

  2130.     val.len = v->len;
  2131.     val.data = v->data;

  2133.     s = ngx_parse_size(&val);

  2135.     if (s == NGX_ERROR) {
  2136.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2137.                       "invalid $limit_rate \"%V\"", &val);
  2138.         return;
  2139.     }

  2141.     r->limit_rate = s;
  2142.     r->limit_rate_set = 1;
  2143. }


  2146. static ngx_int_t
  2147. ‌ngx_http_variable_request_completion(ngx_http_request_t *r,
  2148.     ngx_http_variable_value_t *v, uintptr_t data)
  2149. {
  2150.     if (r->request_complete) {
  2151.         v->len = 2;
  2152.         v->valid = 1;
  2153.         v->no_cacheable = 0;
  2154.         v->not_found = 0;
  2155.         v->data = (u_char *) "OK";

  2157.         return NGX_OK;
  2158.     }

  2160.     *v = ngx_http_variable_null_value;

  2162.     return NGX_OK;
  2163. }


  2166. static ngx_int_t
  2167. ‌ngx_http_variable_request_body(ngx_http_request_t *r,
  2168.     ngx_http_variable_value_t *v, uintptr_t data)
  2169. {
  2170.     u_char       *p;
  2171.     size_t        len;
  2172.     ngx_buf_t    *buf;
  2173.     ngx_chain_t  *cl;

  2175.     if (r->request_body == NULL
  2176.         || r->request_body->bufs == NULL
  2177.         || r->request_body->temp_file)
  2178.     {
  2179.         v->not_found = 1;

  2181.         return NGX_OK;
  2182.     }

  2184.     cl = r->request_body->bufs;
  2185.     buf = cl->buf;

  2187.     if (cl->next == NULL) {
  2188.         v->len = buf->last - buf->pos;
  2189.         v->valid = 1;
  2190.         v->no_cacheable = 0;
  2191.         v->not_found = 0;
  2192.         v->data = buf->pos;

  2194.         return NGX_OK;
  2195.     }

  2197.     len = buf->last - buf->pos;
  2198.     cl = cl->next;

  2200.     for ( /* void */ ; cl; cl = cl->next) {
  2201.         buf = cl->buf;
  2202.         len += buf->last - buf->pos;
  2203.     }

  2205.     p = ngx_pnalloc(r->pool, len);
  2206.     if (p == NULL) {
  2207.         return NGX_ERROR;
  2208.     }

  2210.     v->data = p;
  2211.     cl = r->request_body->bufs;

  2213.     for ( /* void */ ; cl; cl = cl->next) {
  2214.         buf = cl->buf;
  2215.         p = ngx_cpymem(p, buf->pos, buf->last - buf->pos);
  2216.     }

  2218.     v->len = len;
  2219.     v->valid = 1;
  2220.     v->no_cacheable = 0;
  2221.     v->not_found = 0;

  2223.     return NGX_OK;
  2224. }


  2227. static ngx_int_t
  2228. ‌ngx_http_variable_request_body_file(ngx_http_request_t *r,
  2229.     ngx_http_variable_value_t *v, uintptr_t data)
  2230. {
  2231.     if (r->request_body == NULL || r->request_body->temp_file == NULL) {
  2232.         v->not_found = 1;

  2234.         return NGX_OK;
  2235.     }

  2237.     v->len = r->request_body->temp_file->file.name.len;
  2238.     v->valid = 1;
  2239.     v->no_cacheable = 0;
  2240.     v->not_found = 0;
  2241.     v->data = r->request_body->temp_file->file.name.data;

  2243.     return NGX_OK;
  2244. }


  2247. static ngx_int_t
  2248. ‌ngx_http_variable_request_length(ngx_http_request_t *r,
  2249.     ngx_http_variable_value_t *v, uintptr_t data)
  2250. {
  2251.     u_char  *p;

  2253.     p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
  2254.     if (p == NULL) {
  2255.         return NGX_ERROR;
  2256.     }

  2258.     v->len = ngx_sprintf(p, "%O", r->request_length) - p;
  2259.     v->valid = 1;
  2260.     v->no_cacheable = 0;
  2261.     v->not_found = 0;
  2262.     v->data = p;

  2264.     return NGX_OK;
  2265. }


  2268. static ngx_int_t
  2269. ‌ngx_http_variable_request_time(ngx_http_request_t *r,
  2270.     ngx_http_variable_value_t *v, uintptr_t data)
  2271. {
  2272.     u_char          *p;
  2273.     ngx_time_t      *tp;
  2274.     ngx_msec_int_t   ms;

  2276.     p = ngx_pnalloc(r->pool, NGX_TIME_T_LEN + 4);
  2277.     if (p == NULL) {
  2278.         return NGX_ERROR;
  2279.     }

  2281.     tp = ngx_timeofday();

  2283.     ms = (ngx_msec_int_t)
  2284.              ((tp->sec - r->start_sec) * 1000 + (tp->msec - r->start_msec));
  2285.     ms = ngx_max(ms, 0);

  2287.     v->len = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000) - p;
  2288.     v->valid = 1;
  2289.     v->no_cacheable = 0;
  2290.     v->not_found = 0;
  2291.     v->data = p;

  2293.     return NGX_OK;
  2294. }


  2297. static ngx_int_t
  2298. ‌ngx_http_variable_request_id(ngx_http_request_t *r,
  2299.     ngx_http_variable_value_t *v, uintptr_t data)
  2300. {
  2301.     u_char  *id;

  2303. #if (NGX_OPENSSL)
  2304.     u_char   random_bytes[16];
  2305. #endif

  2307.     id = ngx_pnalloc(r->pool, 32);
  2308.     if (id == NULL) {
  2309.         return NGX_ERROR;
  2310.     }

  2312.     v->valid = 1;
  2313.     v->no_cacheable = 0;
  2314.     v->not_found = 0;

  2316.     v->len = 32;
  2317.     v->data = id;

  2319. #if (NGX_OPENSSL)

  2321.     if (RAND_bytes(random_bytes, 16) == 1) {
  2322.         ngx_hex_dump(id, random_bytes, 16);
  2323.         return NGX_OK;
  2324.     }

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

  2328. #endif

  2330.     ngx_sprintf(id, "%08xD%08xD%08xD%08xD",
  2331.                 (uint32_t) ngx_random(), (uint32_t) ngx_random(),
  2332.                 (uint32_t) ngx_random(), (uint32_t) ngx_random());

  2334.     return NGX_OK;
  2335. }


  2338. static ngx_int_t
  2339. ‌ngx_http_variable_connection(ngx_http_request_t *r,
  2340.     ngx_http_variable_value_t *v, uintptr_t data)
  2341. {
  2342.     u_char  *p;

  2344.     p = ngx_pnalloc(r->pool, NGX_ATOMIC_T_LEN);
  2345.     if (p == NULL) {
  2346.         return NGX_ERROR;
  2347.     }

  2349.     v->len = ngx_sprintf(p, "%uA", r->connection->number) - p;
  2350.     v->valid = 1;
  2351.     v->no_cacheable = 0;
  2352.     v->not_found = 0;
  2353.     v->data = p;

  2355.     return NGX_OK;
  2356. }


  2359. static ngx_int_t
  2360. ‌ngx_http_variable_connection_requests(ngx_http_request_t *r,
  2361.     ngx_http_variable_value_t *v, uintptr_t data)
  2362. {
  2363.     u_char  *p;

  2365.     p = ngx_pnalloc(r->pool, NGX_INT_T_LEN);
  2366.     if (p == NULL) {
  2367.         return NGX_ERROR;
  2368.     }

  2370.     v->len = ngx_sprintf(p, "%ui", r->connection->requests) - p;
  2371.     v->valid = 1;
  2372.     v->no_cacheable = 0;
  2373.     v->not_found = 0;
  2374.     v->data = p;

  2376.     return NGX_OK;
  2377. }


  2380. static ngx_int_t
  2381. ‌ngx_http_variable_connection_time(ngx_http_request_t *r,
  2382.     ngx_http_variable_value_t *v, uintptr_t data)
  2383. {
  2384.     u_char          *p;
  2385.     ngx_msec_int_t   ms;

  2387.     p = ngx_pnalloc(r->pool, NGX_TIME_T_LEN + 4);
  2388.     if (p == NULL) {
  2389.         return NGX_ERROR;
  2390.     }

  2392.     ms = ngx_current_msec - r->connection->start_time;
  2393.     ms = ngx_max(ms, 0);

  2395.     v->len = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000) - p;
  2396.     v->valid = 1;
  2397.     v->no_cacheable = 0;
  2398.     v->not_found = 0;
  2399.     v->data = p;

  2401.     return NGX_OK;
  2402. }


  2405. static ngx_int_t
  2406. ‌ngx_http_variable_nginx_version(ngx_http_request_t *r,
  2407.     ngx_http_variable_value_t *v, uintptr_t data)
  2408. {
  2409.     v->len = sizeof(NGINX_VERSION) - 1;
  2410.     v->valid = 1;
  2411.     v->no_cacheable = 0;
  2412.     v->not_found = 0;
  2413.     v->data = (u_char *) NGINX_VERSION;

  2415.     return NGX_OK;
  2416. }


  2419. static ngx_int_t
  2420. ‌ngx_http_variable_hostname(ngx_http_request_t *r,
  2421.     ngx_http_variable_value_t *v, uintptr_t data)
  2422. {
  2423.     v->len = ngx_cycle->hostname.len;
  2424.     v->valid = 1;
  2425.     v->no_cacheable = 0;
  2426.     v->not_found = 0;
  2427.     v->data = ngx_cycle->hostname.data;

  2429.     return NGX_OK;
  2430. }


  2433. static ngx_int_t
  2434. ‌ngx_http_variable_pid(ngx_http_request_t *r,
  2435.     ngx_http_variable_value_t *v, uintptr_t data)
  2436. {
  2437.     u_char  *p;

  2439.     p = ngx_pnalloc(r->pool, NGX_INT64_LEN);
  2440.     if (p == NULL) {
  2441.         return NGX_ERROR;
  2442.     }

  2444.     v->len = ngx_sprintf(p, "%P", ngx_pid) - p;
  2445.     v->valid = 1;
  2446.     v->no_cacheable = 0;
  2447.     v->not_found = 0;
  2448.     v->data = p;

  2450.     return NGX_OK;
  2451. }


  2454. static ngx_int_t
  2455. ‌ngx_http_variable_msec(ngx_http_request_t *r,
  2456.     ngx_http_variable_value_t *v, uintptr_t data)
  2457. {
  2458.     u_char      *p;
  2459.     ngx_time_t  *tp;

  2461.     p = ngx_pnalloc(r->pool, NGX_TIME_T_LEN + 4);
  2462.     if (p == NULL) {
  2463.         return NGX_ERROR;
  2464.     }

  2466.     tp = ngx_timeofday();

  2468.     v->len = ngx_sprintf(p, "%T.%03M", tp->sec, tp->msec) - p;
  2469.     v->valid = 1;
  2470.     v->no_cacheable = 0;
  2471.     v->not_found = 0;
  2472.     v->data = p;

  2474.     return NGX_OK;
  2475. }


  2478. static ngx_int_t
  2479. ‌ngx_http_variable_time_iso8601(ngx_http_request_t *r,
  2480.     ngx_http_variable_value_t *v, uintptr_t data)
  2481. {
  2482.     u_char  *p;

  2484.     p = ngx_pnalloc(r->pool, ngx_cached_http_log_iso8601.len);
  2485.     if (p == NULL) {
  2486.         return NGX_ERROR;
  2487.     }

  2489.     ngx_memcpy(p, ngx_cached_http_log_iso8601.data,
  2490.                ngx_cached_http_log_iso8601.len);

  2492.     v->len = ngx_cached_http_log_iso8601.len;
  2493.     v->valid = 1;
  2494.     v->no_cacheable = 0;
  2495.     v->not_found = 0;
  2496.     v->data = p;

  2498.     return NGX_OK;
  2499. }


  2502. static ngx_int_t
  2503. ‌ngx_http_variable_time_local(ngx_http_request_t *r,
  2504.     ngx_http_variable_value_t *v, uintptr_t data)
  2505. {
  2506.     u_char  *p;

  2508.     p = ngx_pnalloc(r->pool, ngx_cached_http_log_time.len);
  2509.     if (p == NULL) {
  2510.         return NGX_ERROR;
  2511.     }

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

  2515.     v->len = ngx_cached_http_log_time.len;
  2516.     v->valid = 1;
  2517.     v->no_cacheable = 0;
  2518.     v->not_found = 0;
  2519.     v->data = p;

  2521.     return NGX_OK;
  2522. }


  2525. void *
  2526. ‌ngx_http_map_find(ngx_http_request_t *r, ngx_http_map_t *map, ngx_str_t *match)
  2527. {
  2528.     void        *value;
  2529.     u_char      *low;
  2530.     size_t       len;
  2531.     ngx_uint_t   key;

  2533.     len = match->len;

  2535.     if (len) {
  2536.         low = ngx_pnalloc(r->pool, len);
  2537.         if (low == NULL) {
  2538.             return NULL;
  2539.         }

  2541.     } else {
  2542.         low = NULL;
  2543.     }

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

  2547.     value = ngx_hash_find_combined(&map->hash, key, low, len);
  2548.     if (value) {
  2549.         return value;
  2550.     }

  2552. #if (NGX_PCRE)

  2554.     if (len && map->nregex) {
  2555.         ngx_int_t              n;
  2556.         ngx_uint_t             i;
  2557.         ngx_http_map_regex_t  *reg;

  2559.         reg = map->regex;

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

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

  2565.             if (n == NGX_OK) {
  2566.                 return reg[i].value;
  2567.             }

  2569.             if (n == NGX_DECLINED) {
  2570.                 continue;
  2571.             }

  2573.             /* NGX_ERROR */

  2575.             return NULL;
  2576.         }
  2577.     }

  2579. #endif

  2581.     return NULL;
  2582. }


  2585. #if (NGX_PCRE)

  2587. static ngx_int_t
  2588. ‌ngx_http_variable_not_found(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  2589.     uintptr_t data)
  2590. {
  2591.     v->not_found = 1;
  2592.     return NGX_OK;
  2593. }


  2596. ngx_http_regex_t *
  2597. ‌ngx_http_regex_compile(ngx_conf_t *cf, ngx_regex_compile_t *rc)
  2598. {
  2599.     u_char                     *p;
  2600.     size_t                      size;
  2601.     ngx_str_t                   name;
  2602.     ngx_uint_t                  i, n;
  2603.     ngx_http_variable_t        *v;
  2604.     ngx_http_regex_t           *re;
  2605.     ngx_http_regex_variable_t  *rv;
  2606.     ngx_http_core_main_conf_t  *cmcf;

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

  2610.     if (ngx_regex_compile(rc) != NGX_OK) {
  2611.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc->err);
  2612.         return NULL;
  2613.     }

  2615.     re = ngx_pcalloc(cf->pool, sizeof(ngx_http_regex_t));
  2616.     if (re == NULL) {
  2617.         return NULL;
  2618.     }

  2620.     re->regex = rc->regex;
  2621.     re->ncaptures = rc->captures;
  2622.     re->name = rc->pattern;

  2624.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
  2625.     cmcf->ncaptures = ngx_max(cmcf->ncaptures, re->ncaptures);

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

  2629.     if (n == 0) {
  2630.         return re;
  2631.     }

  2633.     rv = ngx_palloc(rc->pool, n * sizeof(ngx_http_regex_variable_t));
  2634.     if (rv == NULL) {
  2635.         return NULL;
  2636.     }

  2638.     re->variables = rv;
  2639.     re->nvariables = n;

  2641.     size = rc->name_size;
  2642.     p = rc->names;

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

  2647.         name.data = &p[2];
  2648.         name.len = ngx_strlen(name.data);

  2650.         v = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
  2651.         if (v == NULL) {
  2652.             return NULL;
  2653.         }

  2655.         rv[i].index = ngx_http_get_variable_index(cf, &name);
  2656.         if (rv[i].index == NGX_ERROR) {
  2657.             return NULL;
  2658.         }

  2660.         v->get_handler = ngx_http_variable_not_found;

  2662.         p += size;
  2663.     }

  2665.     return re;
  2666. }


  2669. ngx_int_t
  2670. ‌ngx_http_regex_exec(ngx_http_request_t *r, ngx_http_regex_t *re, ngx_str_t *s)
  2671. {
  2672.     ngx_int_t                   rc, index;
  2673.     ngx_uint_t                  i, n, len;
  2674.     ngx_http_variable_value_t  *vv;
  2675.     ngx_http_core_main_conf_t  *cmcf;

  2677.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  2679.     if (re->ncaptures) {
  2680.         len = cmcf->ncaptures;

  2682.         if (r->captures == NULL || r->realloc_captures) {
  2683.             r->realloc_captures = 0;

  2685.             r->captures = ngx_palloc(r->pool, len * sizeof(int));
  2686.             if (r->captures == NULL) {
  2687.                 return NGX_ERROR;
  2688.             }
  2689.         }

  2691.     } else {
  2692.         len = 0;
  2693.     }

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

  2697.     if (rc == NGX_REGEX_NO_MATCHED) {
  2698.         return NGX_DECLINED;
  2699.     }

  2701.     if (rc < 0) {
  2702.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  2703.                       ngx_regex_exec_n " failed: %i on \"%V\" using \"%V\"",
  2704.                       rc, s, &re->name);
  2705.         return NGX_ERROR;
  2706.     }

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

  2710.         n = re->variables[i].capture;
  2711.         index = re->variables[i].index;
  2712.         vv = &r->variables[index];

  2714.         vv->len = r->captures[n + 1] - r->captures[n];
  2715.         vv->valid = 1;
  2716.         vv->no_cacheable = 0;
  2717.         vv->not_found = 0;
  2718.         vv->data = &s->data[r->captures[n]];

  2720. #if (NGX_DEBUG)
  2721.         {
  2722.         ngx_http_variable_t  *v;

  2724.         v = cmcf->variables.elts;

  2726.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2727.                        "http regex set $%V to \"%v\"", &v[index].name, vv);
  2728.         }
  2729. #endif
  2730.     }

  2732.     r->ncaptures = rc * 2;
  2733.     r->captures_data = s->data;

  2735.     return NGX_OK;
  2736. }

  2738. #endif


  2741. ngx_int_t
  2742. ‌ngx_http_variables_add_core_vars(ngx_conf_t *cf)
  2743. {
  2744.     ngx_http_variable_t        *cv, *v;
  2745.     ngx_http_core_main_conf_t  *cmcf;

  2747.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  2749.     cmcf->variables_keys = ngx_pcalloc(cf->temp_pool,
  2750.                                        sizeof(ngx_hash_keys_arrays_t));
  2751.     if (cmcf->variables_keys == NULL) {
  2752.         return NGX_ERROR;
  2753.     }

  2755.     cmcf->variables_keys->pool = cf->pool;
  2756.     cmcf->variables_keys->temp_pool = cf->pool;

  2758.     if (ngx_hash_keys_array_init(cmcf->variables_keys, NGX_HASH_SMALL)
  2759.         != NGX_OK)
  2760.     {
  2761.         return NGX_ERROR;
  2762.     }

  2764.     if (ngx_array_init(&cmcf->prefix_variables, cf->pool, 8,
  2765.                        sizeof(ngx_http_variable_t))
  2766.         != NGX_OK)
  2767.     {
  2768.         return NGX_ERROR;
  2769.     }

  2771.     for (cv = ngx_http_core_variables; cv->name.len; cv++) {
  2772.         v = ngx_http_add_variable(cf, &cv->name, cv->flags);
  2773.         if (v == NULL) {
  2774.             return NGX_ERROR;
  2775.         }

  2777.         *v = *cv;
  2778.     }

  2780.     return NGX_OK;
  2781. }


  2784. ngx_int_t
  2785. ‌ngx_http_variables_init_vars(ngx_conf_t *cf)
  2786. {
  2787.     size_t                      len;
  2788.     ngx_uint_t                  i, n;
  2789.     ngx_hash_key_t             *key;
  2790.     ngx_hash_init_t             hash;
  2791.     ngx_http_variable_t        *v, *av, *pv;
  2792.     ngx_http_core_main_conf_t  *cmcf;

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

  2796.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  2798.     v = cmcf->variables.elts;
  2799.     pv = cmcf->prefix_variables.elts;
  2800.     key = cmcf->variables_keys->keys.elts;

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

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

  2806.             av = key[n].value;

  2808.             if (v[i].name.len == key[n].key.len
  2809.                 && ngx_strncmp(v[i].name.data, key[n].key.data, v[i].name.len)
  2810.                    == 0)
  2811.             {
  2812.                 v[i].get_handler = av->get_handler;
  2813.                 v[i].data = av->data;

  2815.                 av->flags |= NGX_HTTP_VAR_INDEXED;
  2816.                 v[i].flags = av->flags;

  2818.                 av->index = i;

  2820.                 if (av->get_handler == NULL
  2821.                     || (av->flags & NGX_HTTP_VAR_WEAK))
  2822.                 {
  2823.                     break;
  2824.                 }

  2826.                 goto next;
  2827.             }
  2828.         }

  2830.         len = 0;
  2831.         av = NULL;

  2833.         for (n = 0; n < cmcf->prefix_variables.nelts; n++) {
  2834.             if (v[i].name.len >= pv[n].name.len && v[i].name.len > len
  2835.                 && ngx_strncmp(v[i].name.data, pv[n].name.data, pv[n].name.len)
  2836.                    == 0)
  2837.             {
  2838.                 av = &pv[n];
  2839.                 len = pv[n].name.len;
  2840.             }
  2841.         }

  2843.         if (av) {
  2844.             v[i].get_handler = av->get_handler;
  2845.             v[i].data = (uintptr_t) &v[i].name;
  2846.             v[i].flags = av->flags;

  2848.             goto next;
  2849.         }

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

  2855.             return NGX_ERROR;
  2856.         }

  2858.     next:
  2859.         continue;
  2860.     }


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

  2866.         if (av->flags & NGX_HTTP_VAR_NOHASH) {
  2867.             key[n].key.data = NULL;
  2868.         }
  2869.     }


  2872.     hash.hash = &cmcf->variables_hash;
  2873.     hash.key = ngx_hash_key;
  2874.     hash.max_size = cmcf->variables_hash_max_size;
  2875.     hash.bucket_size = cmcf->variables_hash_bucket_size;
  2876.     hash.name = "variables_hash";
  2877.     hash.pool = cf->pool;
  2878.     hash.temp_pool = NULL;

  2880.     if (ngx_hash_init(&hash, cmcf->variables_keys->keys.elts,
  2881.                       cmcf->variables_keys->keys.nelts)
  2882.         != NGX_OK)
  2883.     {
  2884.         return NGX_ERROR;
  2885.     }

  2887.     cmcf->variables_keys = NULL;

  2889.     return NGX_OK;
  2890. }

One Level Up Top Level