One Level Up Top Level

src/http/ngx_http_core_module.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


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


  13. ‌typedef struct {
  14.     u_char    *name;
  15.     uint32_t   method;
  16. ‌} ngx_http_method_name_t;


  19. ‌#define NGX_HTTP_REQUEST_BODY_FILE_OFF    0
  20. ‌#define NGX_HTTP_REQUEST_BODY_FILE_ON     1
  21. ‌#define NGX_HTTP_REQUEST_BODY_FILE_CLEAN  2


  24. static ngx_int_t ngx_http_core_auth_delay(ngx_http_request_t *r);
  25. static void ngx_http_core_auth_delay_handler(ngx_http_request_t *r);

  27. static ngx_int_t ngx_http_core_find_location(ngx_http_request_t *r);
  28. static ngx_int_t ngx_http_core_find_static_location(ngx_http_request_t *r,
  29.     ngx_http_location_tree_node_t *node);

  31. static ngx_int_t ngx_http_core_preconfiguration(ngx_conf_t *cf);
  32. static ngx_int_t ngx_http_core_postconfiguration(ngx_conf_t *cf);
  33. static void *ngx_http_core_create_main_conf(ngx_conf_t *cf);
  34. static char *ngx_http_core_init_main_conf(ngx_conf_t *cf, void *conf);
  35. static void *ngx_http_core_create_srv_conf(ngx_conf_t *cf);
  36. static char *ngx_http_core_merge_srv_conf(ngx_conf_t *cf,
  37.     void *parent, void *child);
  38. static void *ngx_http_core_create_loc_conf(ngx_conf_t *cf);
  39. static char *ngx_http_core_merge_loc_conf(ngx_conf_t *cf,
  40.     void *parent, void *child);

  42. static char *ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd,
  43.     void *dummy);
  44. static char *ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd,
  45.     void *dummy);
  46. static ngx_int_t ngx_http_core_regex_location(ngx_conf_t *cf,
  47.     ngx_http_core_loc_conf_t *clcf, ngx_str_t *regex, ngx_uint_t caseless);

  49. static char *ngx_http_core_types(ngx_conf_t *cf, ngx_command_t *cmd,
  50.     void *conf);
  51. static char *ngx_http_core_type(ngx_conf_t *cf, ngx_command_t *dummy,
  52.     void *conf);

  54. static char *ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd,
  55.     void *conf);
  56. static char *ngx_http_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd,
  57.     void *conf);
  58. static char *ngx_http_core_root(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  59. static char *ngx_http_core_limit_except(ngx_conf_t *cf, ngx_command_t *cmd,
  60.     void *conf);
  61. static char *ngx_http_core_set_aio(ngx_conf_t *cf, ngx_command_t *cmd,
  62.     void *conf);
  63. static char *ngx_http_core_directio(ngx_conf_t *cf, ngx_command_t *cmd,
  64.     void *conf);
  65. static char *ngx_http_core_error_page(ngx_conf_t *cf, ngx_command_t *cmd,
  66.     void *conf);
  67. static char *ngx_http_core_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  68.     void *conf);
  69. static char *ngx_http_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd,
  70.     void *conf);
  71. static char *ngx_http_core_keepalive(ngx_conf_t *cf, ngx_command_t *cmd,
  72.     void *conf);
  73. static char *ngx_http_core_internal(ngx_conf_t *cf, ngx_command_t *cmd,
  74.     void *conf);
  75. static char *ngx_http_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd,
  76.     void *conf);
  77. #if (NGX_HTTP_GZIP)
  78. static ngx_int_t ngx_http_gzip_accept_encoding(ngx_str_t *ae);
  79. static ngx_uint_t ngx_http_gzip_quantity(u_char *p, u_char *last);
  80. static char *ngx_http_gzip_disable(ngx_conf_t *cf, ngx_command_t *cmd,
  81.     void *conf);
  82. #endif
  83. static ngx_int_t ngx_http_get_forwarded_addr_internal(ngx_http_request_t *r,
  84.     ngx_addr_t *addr, u_char *xff, size_t xfflen, ngx_array_t *proxies,
  85.     int recursive);
  86. #if (NGX_HAVE_OPENAT)
  87. static char *ngx_http_disable_symlinks(ngx_conf_t *cf, ngx_command_t *cmd,
  88.     void *conf);
  89. #endif

  91. static char *ngx_http_core_lowat_check(ngx_conf_t *cf, void *post, void *data);
  92. static char *ngx_http_core_pool_size(ngx_conf_t *cf, void *post, void *data);

  94. ‌static ngx_conf_post_t  ngx_http_core_lowat_post =
  95.     { ngx_http_core_lowat_check };

  97. ‌static ngx_conf_post_handler_pt  ngx_http_core_pool_size_p =
  98.     ngx_http_core_pool_size;


  101. ‌static ngx_conf_enum_t  ngx_http_core_request_body_in_file[] = {
  102.     { ngx_string("off"), NGX_HTTP_REQUEST_BODY_FILE_OFF },
  103.     { ngx_string("on"), NGX_HTTP_REQUEST_BODY_FILE_ON },
  104.     { ngx_string("clean"), NGX_HTTP_REQUEST_BODY_FILE_CLEAN },
  105.     { ngx_null_string, 0 }
  106. };


  109. ‌static ngx_conf_enum_t  ngx_http_core_satisfy[] = {
  110.     { ngx_string("all"), NGX_HTTP_SATISFY_ALL },
  111.     { ngx_string("any"), NGX_HTTP_SATISFY_ANY },
  112.     { ngx_null_string, 0 }
  113. };


  116. ‌static ngx_conf_enum_t  ngx_http_core_lingering_close[] = {
  117.     { ngx_string("off"), NGX_HTTP_LINGERING_OFF },
  118.     { ngx_string("on"), NGX_HTTP_LINGERING_ON },
  119.     { ngx_string("always"), NGX_HTTP_LINGERING_ALWAYS },
  120.     { ngx_null_string, 0 }
  121. };


  124. ‌static ngx_conf_enum_t  ngx_http_core_server_tokens[] = {
  125.     { ngx_string("off"), NGX_HTTP_SERVER_TOKENS_OFF },
  126.     { ngx_string("on"), NGX_HTTP_SERVER_TOKENS_ON },
  127.     { ngx_string("build"), NGX_HTTP_SERVER_TOKENS_BUILD },
  128.     { ngx_null_string, 0 }
  129. };


  132. ‌static ngx_conf_enum_t  ngx_http_core_if_modified_since[] = {
  133.     { ngx_string("off"), NGX_HTTP_IMS_OFF },
  134.     { ngx_string("exact"), NGX_HTTP_IMS_EXACT },
  135.     { ngx_string("before"), NGX_HTTP_IMS_BEFORE },
  136.     { ngx_null_string, 0 }
  137. };


  140. ‌static ngx_conf_bitmask_t  ngx_http_core_keepalive_disable[] = {
  141.     { ngx_string("none"), NGX_HTTP_KEEPALIVE_DISABLE_NONE },
  142.     { ngx_string("msie6"), NGX_HTTP_KEEPALIVE_DISABLE_MSIE6 },
  143.     { ngx_string("safari"), NGX_HTTP_KEEPALIVE_DISABLE_SAFARI },
  144.     { ngx_null_string, 0 }
  145. };


  148. ‌static ngx_path_init_t  ngx_http_client_temp_path = {
  149.     ngx_string(NGX_HTTP_CLIENT_TEMP_PATH), { 0, 0, 0 }
  150. };


  153. #if (NGX_HTTP_GZIP)

  155. ‌static ngx_conf_enum_t  ngx_http_gzip_http_version[] = {
  156.     { ngx_string("1.0"), NGX_HTTP_VERSION_10 },
  157.     { ngx_string("1.1"), NGX_HTTP_VERSION_11 },
  158.     { ngx_null_string, 0 }
  159. };


  162. ‌static ngx_conf_bitmask_t  ngx_http_gzip_proxied_mask[] = {
  163.     { ngx_string("off"), NGX_HTTP_GZIP_PROXIED_OFF },
  164.     { ngx_string("expired"), NGX_HTTP_GZIP_PROXIED_EXPIRED },
  165.     { ngx_string("no-cache"), NGX_HTTP_GZIP_PROXIED_NO_CACHE },
  166.     { ngx_string("no-store"), NGX_HTTP_GZIP_PROXIED_NO_STORE },
  167.     { ngx_string("private"), NGX_HTTP_GZIP_PROXIED_PRIVATE },
  168.     { ngx_string("no_last_modified"), NGX_HTTP_GZIP_PROXIED_NO_LM },
  169.     { ngx_string("no_etag"), NGX_HTTP_GZIP_PROXIED_NO_ETAG },
  170.     { ngx_string("auth"), NGX_HTTP_GZIP_PROXIED_AUTH },
  171.     { ngx_string("any"), NGX_HTTP_GZIP_PROXIED_ANY },
  172.     { ngx_null_string, 0 }
  173. };


  176. ‌static ngx_str_t  ngx_http_gzip_no_cache = ngx_string("no-cache");
  177. ‌static ngx_str_t  ngx_http_gzip_no_store = ngx_string("no-store");
  178. ‌static ngx_str_t  ngx_http_gzip_private = ngx_string("private");

  180. #endif


  183. ‌static ngx_command_t  ngx_http_core_commands[] = {

  185.     { ngx_string("variables_hash_max_size"),
  186.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  187.       ngx_conf_set_num_slot,
  188.       NGX_HTTP_MAIN_CONF_OFFSET,
  189.       offsetof(ngx_http_core_main_conf_t, variables_hash_max_size),
  190.       NULL },

  192.     { ngx_string("variables_hash_bucket_size"),
  193.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  194.       ngx_conf_set_num_slot,
  195.       NGX_HTTP_MAIN_CONF_OFFSET,
  196.       offsetof(ngx_http_core_main_conf_t, variables_hash_bucket_size),
  197.       NULL },

  199.     { ngx_string("server_names_hash_max_size"),
  200.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  201.       ngx_conf_set_num_slot,
  202.       NGX_HTTP_MAIN_CONF_OFFSET,
  203.       offsetof(ngx_http_core_main_conf_t, server_names_hash_max_size),
  204.       NULL },

  206.     { ngx_string("server_names_hash_bucket_size"),
  207.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  208.       ngx_conf_set_num_slot,
  209.       NGX_HTTP_MAIN_CONF_OFFSET,
  210.       offsetof(ngx_http_core_main_conf_t, server_names_hash_bucket_size),
  211.       NULL },

  213.     { ngx_string("server"),
  214.       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  215.       ngx_http_core_server,
  216.       0,
  217.       0,
  218.       NULL },

  220.     { ngx_string("connection_pool_size"),
  221.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  222.       ngx_conf_set_size_slot,
  223.       NGX_HTTP_SRV_CONF_OFFSET,
  224.       offsetof(ngx_http_core_srv_conf_t, connection_pool_size),
  225.       &ngx_http_core_pool_size_p },

  227.     { ngx_string("request_pool_size"),
  228.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  229.       ngx_conf_set_size_slot,
  230.       NGX_HTTP_SRV_CONF_OFFSET,
  231.       offsetof(ngx_http_core_srv_conf_t, request_pool_size),
  232.       &ngx_http_core_pool_size_p },

  234.     { ngx_string("client_header_timeout"),
  235.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  236.       ngx_conf_set_msec_slot,
  237.       NGX_HTTP_SRV_CONF_OFFSET,
  238.       offsetof(ngx_http_core_srv_conf_t, client_header_timeout),
  239.       NULL },

  241.     { ngx_string("client_header_buffer_size"),
  242.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  243.       ngx_conf_set_size_slot,
  244.       NGX_HTTP_SRV_CONF_OFFSET,
  245.       offsetof(ngx_http_core_srv_conf_t, client_header_buffer_size),
  246.       NULL },

  248.     { ngx_string("large_client_header_buffers"),
  249.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE2,
  250.       ngx_conf_set_bufs_slot,
  251.       NGX_HTTP_SRV_CONF_OFFSET,
  252.       offsetof(ngx_http_core_srv_conf_t, large_client_header_buffers),
  253.       NULL },

  255.     { ngx_string("max_headers"),
  256.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  257.       ngx_conf_set_num_slot,
  258.       NGX_HTTP_SRV_CONF_OFFSET,
  259.       offsetof(ngx_http_core_srv_conf_t, max_headers),
  260.       NULL },

  262.     { ngx_string("ignore_invalid_headers"),
  263.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
  264.       ngx_conf_set_flag_slot,
  265.       NGX_HTTP_SRV_CONF_OFFSET,
  266.       offsetof(ngx_http_core_srv_conf_t, ignore_invalid_headers),
  267.       NULL },

  269.     { ngx_string("merge_slashes"),
  270.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
  271.       ngx_conf_set_flag_slot,
  272.       NGX_HTTP_SRV_CONF_OFFSET,
  273.       offsetof(ngx_http_core_srv_conf_t, merge_slashes),
  274.       NULL },

  276.     { ngx_string("underscores_in_headers"),
  277.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
  278.       ngx_conf_set_flag_slot,
  279.       NGX_HTTP_SRV_CONF_OFFSET,
  280.       offsetof(ngx_http_core_srv_conf_t, underscores_in_headers),
  281.       NULL },

  283.     { ngx_string("location"),
  284.       NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12,
  285.       ngx_http_core_location,
  286.       NGX_HTTP_SRV_CONF_OFFSET,
  287.       0,
  288.       NULL },

  290.     { ngx_string("listen"),
  291.       NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
  292.       ngx_http_core_listen,
  293.       NGX_HTTP_SRV_CONF_OFFSET,
  294.       0,
  295.       NULL },

  297.     { ngx_string("server_name"),
  298.       NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
  299.       ngx_http_core_server_name,
  300.       NGX_HTTP_SRV_CONF_OFFSET,
  301.       0,
  302.       NULL },

  304.     { ngx_string("types_hash_max_size"),
  305.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  306.       ngx_conf_set_num_slot,
  307.       NGX_HTTP_LOC_CONF_OFFSET,
  308.       offsetof(ngx_http_core_loc_conf_t, types_hash_max_size),
  309.       NULL },

  311.     { ngx_string("types_hash_bucket_size"),
  312.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  313.       ngx_conf_set_num_slot,
  314.       NGX_HTTP_LOC_CONF_OFFSET,
  315.       offsetof(ngx_http_core_loc_conf_t, types_hash_bucket_size),
  316.       NULL },

  318.     { ngx_string("types"),
  319.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF
  320.                                           |NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  321.       ngx_http_core_types,
  322.       NGX_HTTP_LOC_CONF_OFFSET,
  323.       0,
  324.       NULL },

  326.     { ngx_string("default_type"),
  327.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  328.       ngx_conf_set_str_slot,
  329.       NGX_HTTP_LOC_CONF_OFFSET,
  330.       offsetof(ngx_http_core_loc_conf_t, default_type),
  331.       NULL },

  333.     { ngx_string("root"),
  334.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  335.                         |NGX_CONF_TAKE1,
  336.       ngx_http_core_root,
  337.       NGX_HTTP_LOC_CONF_OFFSET,
  338.       0,
  339.       NULL },

  341.     { ngx_string("alias"),
  342.       NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  343.       ngx_http_core_root,
  344.       NGX_HTTP_LOC_CONF_OFFSET,
  345.       0,
  346.       NULL },

  348.     { ngx_string("limit_except"),
  349.       NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_1MORE,
  350.       ngx_http_core_limit_except,
  351.       NGX_HTTP_LOC_CONF_OFFSET,
  352.       0,
  353.       NULL },

  355.     { ngx_string("client_max_body_size"),
  356.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  357.       ngx_conf_set_off_slot,
  358.       NGX_HTTP_LOC_CONF_OFFSET,
  359.       offsetof(ngx_http_core_loc_conf_t, client_max_body_size),
  360.       NULL },

  362.     { ngx_string("client_body_buffer_size"),
  363.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  364.       ngx_conf_set_size_slot,
  365.       NGX_HTTP_LOC_CONF_OFFSET,
  366.       offsetof(ngx_http_core_loc_conf_t, client_body_buffer_size),
  367.       NULL },

  369.     { ngx_string("client_body_timeout"),
  370.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  371.       ngx_conf_set_msec_slot,
  372.       NGX_HTTP_LOC_CONF_OFFSET,
  373.       offsetof(ngx_http_core_loc_conf_t, client_body_timeout),
  374.       NULL },

  376.     { ngx_string("client_body_temp_path"),
  377.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  378.       ngx_conf_set_path_slot,
  379.       NGX_HTTP_LOC_CONF_OFFSET,
  380.       offsetof(ngx_http_core_loc_conf_t, client_body_temp_path),
  381.       NULL },

  383.     { ngx_string("client_body_in_file_only"),
  384.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  385.       ngx_conf_set_enum_slot,
  386.       NGX_HTTP_LOC_CONF_OFFSET,
  387.       offsetof(ngx_http_core_loc_conf_t, client_body_in_file_only),
  388.       &ngx_http_core_request_body_in_file },

  390.     { ngx_string("client_body_in_single_buffer"),
  391.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  392.       ngx_conf_set_flag_slot,
  393.       NGX_HTTP_LOC_CONF_OFFSET,
  394.       offsetof(ngx_http_core_loc_conf_t, client_body_in_single_buffer),
  395.       NULL },

  397.     { ngx_string("sendfile"),
  398.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  399.                         |NGX_CONF_FLAG,
  400.       ngx_conf_set_flag_slot,
  401.       NGX_HTTP_LOC_CONF_OFFSET,
  402.       offsetof(ngx_http_core_loc_conf_t, sendfile),
  403.       NULL },

  405.     { ngx_string("sendfile_max_chunk"),
  406.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  407.       ngx_conf_set_size_slot,
  408.       NGX_HTTP_LOC_CONF_OFFSET,
  409.       offsetof(ngx_http_core_loc_conf_t, sendfile_max_chunk),
  410.       NULL },

  412.     { ngx_string("subrequest_output_buffer_size"),
  413.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  414.       ngx_conf_set_size_slot,
  415.       NGX_HTTP_LOC_CONF_OFFSET,
  416.       offsetof(ngx_http_core_loc_conf_t, subrequest_output_buffer_size),
  417.       NULL },

  419.     { ngx_string("aio"),
  420.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  421.       ngx_http_core_set_aio,
  422.       NGX_HTTP_LOC_CONF_OFFSET,
  423.       0,
  424.       NULL },

  426.     { ngx_string("aio_write"),
  427.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  428.       ngx_conf_set_flag_slot,
  429.       NGX_HTTP_LOC_CONF_OFFSET,
  430.       offsetof(ngx_http_core_loc_conf_t, aio_write),
  431.       NULL },

  433.     { ngx_string("read_ahead"),
  434.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  435.       ngx_conf_set_size_slot,
  436.       NGX_HTTP_LOC_CONF_OFFSET,
  437.       offsetof(ngx_http_core_loc_conf_t, read_ahead),
  438.       NULL },

  440.     { ngx_string("directio"),
  441.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  442.       ngx_http_core_directio,
  443.       NGX_HTTP_LOC_CONF_OFFSET,
  444.       0,
  445.       NULL },

  447.     { ngx_string("directio_alignment"),
  448.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  449.       ngx_conf_set_off_slot,
  450.       NGX_HTTP_LOC_CONF_OFFSET,
  451.       offsetof(ngx_http_core_loc_conf_t, directio_alignment),
  452.       NULL },

  454.     { ngx_string("tcp_nopush"),
  455.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  456.       ngx_conf_set_flag_slot,
  457.       NGX_HTTP_LOC_CONF_OFFSET,
  458.       offsetof(ngx_http_core_loc_conf_t, tcp_nopush),
  459.       NULL },

  461.     { ngx_string("tcp_nodelay"),
  462.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  463.       ngx_conf_set_flag_slot,
  464.       NGX_HTTP_LOC_CONF_OFFSET,
  465.       offsetof(ngx_http_core_loc_conf_t, tcp_nodelay),
  466.       NULL },

  468.     { ngx_string("send_timeout"),
  469.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  470.       ngx_conf_set_msec_slot,
  471.       NGX_HTTP_LOC_CONF_OFFSET,
  472.       offsetof(ngx_http_core_loc_conf_t, send_timeout),
  473.       NULL },

  475.     { ngx_string("send_lowat"),
  476.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  477.       ngx_conf_set_size_slot,
  478.       NGX_HTTP_LOC_CONF_OFFSET,
  479.       offsetof(ngx_http_core_loc_conf_t, send_lowat),
  480.       &ngx_http_core_lowat_post },

  482.     { ngx_string("postpone_output"),
  483.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  484.       ngx_conf_set_size_slot,
  485.       NGX_HTTP_LOC_CONF_OFFSET,
  486.       offsetof(ngx_http_core_loc_conf_t, postpone_output),
  487.       NULL },

  489.     { ngx_string("limit_rate"),
  490.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  491.                         |NGX_CONF_TAKE1,
  492.       ngx_http_set_complex_value_size_slot,
  493.       NGX_HTTP_LOC_CONF_OFFSET,
  494.       offsetof(ngx_http_core_loc_conf_t, limit_rate),
  495.       NULL },

  497.     { ngx_string("limit_rate_after"),
  498.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  499.                         |NGX_CONF_TAKE1,
  500.       ngx_http_set_complex_value_size_slot,
  501.       NGX_HTTP_LOC_CONF_OFFSET,
  502.       offsetof(ngx_http_core_loc_conf_t, limit_rate_after),
  503.       NULL },

  505.     { ngx_string("keepalive_time"),
  506.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  507.       ngx_conf_set_msec_slot,
  508.       NGX_HTTP_LOC_CONF_OFFSET,
  509.       offsetof(ngx_http_core_loc_conf_t, keepalive_time),
  510.       NULL },

  512.     { ngx_string("keepalive_timeout"),
  513.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  514.       ngx_http_core_keepalive,
  515.       NGX_HTTP_LOC_CONF_OFFSET,
  516.       0,
  517.       NULL },

  519.     { ngx_string("keepalive_min_timeout"),
  520.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  521.       ngx_conf_set_msec_slot,
  522.       NGX_HTTP_LOC_CONF_OFFSET,
  523.       offsetof(ngx_http_core_loc_conf_t, keepalive_min_timeout),
  524.       NULL },

  526.     { ngx_string("keepalive_requests"),
  527.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  528.       ngx_conf_set_num_slot,
  529.       NGX_HTTP_LOC_CONF_OFFSET,
  530.       offsetof(ngx_http_core_loc_conf_t, keepalive_requests),
  531.       NULL },

  533.     { ngx_string("keepalive_disable"),
  534.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  535.       ngx_conf_set_bitmask_slot,
  536.       NGX_HTTP_LOC_CONF_OFFSET,
  537.       offsetof(ngx_http_core_loc_conf_t, keepalive_disable),
  538.       &ngx_http_core_keepalive_disable },

  540.     { ngx_string("satisfy"),
  541.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  542.       ngx_conf_set_enum_slot,
  543.       NGX_HTTP_LOC_CONF_OFFSET,
  544.       offsetof(ngx_http_core_loc_conf_t, satisfy),
  545.       &ngx_http_core_satisfy },

  547.     { ngx_string("auth_delay"),
  548.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  549.       ngx_conf_set_msec_slot,
  550.       NGX_HTTP_LOC_CONF_OFFSET,
  551.       offsetof(ngx_http_core_loc_conf_t, auth_delay),
  552.       NULL },

  554.     { ngx_string("internal"),
  555.       NGX_HTTP_LOC_CONF|NGX_CONF_NOARGS,
  556.       ngx_http_core_internal,
  557.       NGX_HTTP_LOC_CONF_OFFSET,
  558.       0,
  559.       NULL },

  561.     { ngx_string("lingering_close"),
  562.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  563.       ngx_conf_set_enum_slot,
  564.       NGX_HTTP_LOC_CONF_OFFSET,
  565.       offsetof(ngx_http_core_loc_conf_t, lingering_close),
  566.       &ngx_http_core_lingering_close },

  568.     { ngx_string("lingering_time"),
  569.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  570.       ngx_conf_set_msec_slot,
  571.       NGX_HTTP_LOC_CONF_OFFSET,
  572.       offsetof(ngx_http_core_loc_conf_t, lingering_time),
  573.       NULL },

  575.     { ngx_string("lingering_timeout"),
  576.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  577.       ngx_conf_set_msec_slot,
  578.       NGX_HTTP_LOC_CONF_OFFSET,
  579.       offsetof(ngx_http_core_loc_conf_t, lingering_timeout),
  580.       NULL },

  582.     { ngx_string("reset_timedout_connection"),
  583.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  584.       ngx_conf_set_flag_slot,
  585.       NGX_HTTP_LOC_CONF_OFFSET,
  586.       offsetof(ngx_http_core_loc_conf_t, reset_timedout_connection),
  587.       NULL },

  589.     { ngx_string("absolute_redirect"),
  590.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  591.       ngx_conf_set_flag_slot,
  592.       NGX_HTTP_LOC_CONF_OFFSET,
  593.       offsetof(ngx_http_core_loc_conf_t, absolute_redirect),
  594.       NULL },

  596.     { ngx_string("server_name_in_redirect"),
  597.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  598.       ngx_conf_set_flag_slot,
  599.       NGX_HTTP_LOC_CONF_OFFSET,
  600.       offsetof(ngx_http_core_loc_conf_t, server_name_in_redirect),
  601.       NULL },

  603.     { ngx_string("port_in_redirect"),
  604.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  605.       ngx_conf_set_flag_slot,
  606.       NGX_HTTP_LOC_CONF_OFFSET,
  607.       offsetof(ngx_http_core_loc_conf_t, port_in_redirect),
  608.       NULL },

  610.     { ngx_string("msie_padding"),
  611.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  612.       ngx_conf_set_flag_slot,
  613.       NGX_HTTP_LOC_CONF_OFFSET,
  614.       offsetof(ngx_http_core_loc_conf_t, msie_padding),
  615.       NULL },

  617.     { ngx_string("msie_refresh"),
  618.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  619.       ngx_conf_set_flag_slot,
  620.       NGX_HTTP_LOC_CONF_OFFSET,
  621.       offsetof(ngx_http_core_loc_conf_t, msie_refresh),
  622.       NULL },

  624.     { ngx_string("log_not_found"),
  625.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  626.       ngx_conf_set_flag_slot,
  627.       NGX_HTTP_LOC_CONF_OFFSET,
  628.       offsetof(ngx_http_core_loc_conf_t, log_not_found),
  629.       NULL },

  631.     { ngx_string("log_subrequest"),
  632.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  633.       ngx_conf_set_flag_slot,
  634.       NGX_HTTP_LOC_CONF_OFFSET,
  635.       offsetof(ngx_http_core_loc_conf_t, log_subrequest),
  636.       NULL },

  638.     { ngx_string("recursive_error_pages"),
  639.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  640.       ngx_conf_set_flag_slot,
  641.       NGX_HTTP_LOC_CONF_OFFSET,
  642.       offsetof(ngx_http_core_loc_conf_t, recursive_error_pages),
  643.       NULL },

  645.     { ngx_string("server_tokens"),
  646.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  647.       ngx_conf_set_enum_slot,
  648.       NGX_HTTP_LOC_CONF_OFFSET,
  649.       offsetof(ngx_http_core_loc_conf_t, server_tokens),
  650.       &ngx_http_core_server_tokens },

  652.     { ngx_string("if_modified_since"),
  653.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  654.       ngx_conf_set_enum_slot,
  655.       NGX_HTTP_LOC_CONF_OFFSET,
  656.       offsetof(ngx_http_core_loc_conf_t, if_modified_since),
  657.       &ngx_http_core_if_modified_since },

  659.     { ngx_string("max_ranges"),
  660.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  661.       ngx_conf_set_num_slot,
  662.       NGX_HTTP_LOC_CONF_OFFSET,
  663.       offsetof(ngx_http_core_loc_conf_t, max_ranges),
  664.       NULL },

  666.     { ngx_string("chunked_transfer_encoding"),
  667.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  668.       ngx_conf_set_flag_slot,
  669.       NGX_HTTP_LOC_CONF_OFFSET,
  670.       offsetof(ngx_http_core_loc_conf_t, chunked_transfer_encoding),
  671.       NULL },

  673.     { ngx_string("etag"),
  674.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  675.       ngx_conf_set_flag_slot,
  676.       NGX_HTTP_LOC_CONF_OFFSET,
  677.       offsetof(ngx_http_core_loc_conf_t, etag),
  678.       NULL },

  680.     { ngx_string("early_hints"),
  681.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  682.       ngx_http_set_predicate_slot,
  683.       NGX_HTTP_LOC_CONF_OFFSET,
  684.       offsetof(ngx_http_core_loc_conf_t, early_hints),
  685.       NULL },

  687.     { ngx_string("error_page"),
  688.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  689.                         |NGX_CONF_2MORE,
  690.       ngx_http_core_error_page,
  691.       NGX_HTTP_LOC_CONF_OFFSET,
  692.       0,
  693.       NULL },

  695.     { ngx_string("post_action"),
  696.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  697.                         |NGX_CONF_TAKE1,
  698.       ngx_conf_set_str_slot,
  699.       NGX_HTTP_LOC_CONF_OFFSET,
  700.       offsetof(ngx_http_core_loc_conf_t, post_action),
  701.       NULL },

  703.     { ngx_string("error_log"),
  704.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  705.       ngx_http_core_error_log,
  706.       NGX_HTTP_LOC_CONF_OFFSET,
  707.       0,
  708.       NULL },

  710.     { ngx_string("open_file_cache"),
  711.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  712.       ngx_http_core_open_file_cache,
  713.       NGX_HTTP_LOC_CONF_OFFSET,
  714.       offsetof(ngx_http_core_loc_conf_t, open_file_cache),
  715.       NULL },

  717.     { ngx_string("open_file_cache_valid"),
  718.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  719.       ngx_conf_set_sec_slot,
  720.       NGX_HTTP_LOC_CONF_OFFSET,
  721.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_valid),
  722.       NULL },

  724.     { ngx_string("open_file_cache_min_uses"),
  725.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  726.       ngx_conf_set_num_slot,
  727.       NGX_HTTP_LOC_CONF_OFFSET,
  728.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_min_uses),
  729.       NULL },

  731.     { ngx_string("open_file_cache_errors"),
  732.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  733.       ngx_conf_set_flag_slot,
  734.       NGX_HTTP_LOC_CONF_OFFSET,
  735.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_errors),
  736.       NULL },

  738.     { ngx_string("open_file_cache_events"),
  739.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  740.       ngx_conf_set_flag_slot,
  741.       NGX_HTTP_LOC_CONF_OFFSET,
  742.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_events),
  743.       NULL },

  745.     { ngx_string("resolver"),
  746.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  747.       ngx_http_core_resolver,
  748.       NGX_HTTP_LOC_CONF_OFFSET,
  749.       0,
  750.       NULL },

  752.     { ngx_string("resolver_timeout"),
  753.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  754.       ngx_conf_set_msec_slot,
  755.       NGX_HTTP_LOC_CONF_OFFSET,
  756.       offsetof(ngx_http_core_loc_conf_t, resolver_timeout),
  757.       NULL },

  759. #if (NGX_HTTP_GZIP)

  761.     { ngx_string("gzip_vary"),
  762.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  763.       ngx_conf_set_flag_slot,
  764.       NGX_HTTP_LOC_CONF_OFFSET,
  765.       offsetof(ngx_http_core_loc_conf_t, gzip_vary),
  766.       NULL },

  768.     { ngx_string("gzip_http_version"),
  769.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  770.       ngx_conf_set_enum_slot,
  771.       NGX_HTTP_LOC_CONF_OFFSET,
  772.       offsetof(ngx_http_core_loc_conf_t, gzip_http_version),
  773.       &ngx_http_gzip_http_version },

  775.     { ngx_string("gzip_proxied"),
  776.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  777.       ngx_conf_set_bitmask_slot,
  778.       NGX_HTTP_LOC_CONF_OFFSET,
  779.       offsetof(ngx_http_core_loc_conf_t, gzip_proxied),
  780.       &ngx_http_gzip_proxied_mask },

  782.     { ngx_string("gzip_disable"),
  783.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  784.       ngx_http_gzip_disable,
  785.       NGX_HTTP_LOC_CONF_OFFSET,
  786.       0,
  787.       NULL },

  789. #endif

  791. #if (NGX_HAVE_OPENAT)

  793.     { ngx_string("disable_symlinks"),
  794.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  795.       ngx_http_disable_symlinks,
  796.       NGX_HTTP_LOC_CONF_OFFSET,
  797.       0,
  798.       NULL },

  800. #endif

  802.       ngx_null_command
  803. };


  806. ‌static ngx_http_module_t  ngx_http_core_module_ctx = {
  807.     ngx_http_core_preconfiguration,        /* preconfiguration */
  808.     ngx_http_core_postconfiguration,       /* postconfiguration */

  810.     ngx_http_core_create_main_conf,        /* create main configuration */
  811.     ngx_http_core_init_main_conf,          /* init main configuration */

  813.     ngx_http_core_create_srv_conf,         /* create server configuration */
  814.     ngx_http_core_merge_srv_conf,          /* merge server configuration */

  816.     ngx_http_core_create_loc_conf,         /* create location configuration */
  817.     ngx_http_core_merge_loc_conf           /* merge location configuration */
  818. };


  821. ‌ngx_module_t  ngx_http_core_module = {
  822.     NGX_MODULE_V1,
  823.     &ngx_http_core_module_ctx,             /* module context */
  824.     ngx_http_core_commands,                /* module directives */
  825.     NGX_HTTP_MODULE,                       /* module type */
  826.     NULL,                                  /* init master */
  827.     NULL,                                  /* init module */
  828.     NULL,                                  /* init process */
  829.     NULL,                                  /* init thread */
  830.     NULL,                                  /* exit thread */
  831.     NULL,                                  /* exit process */
  832.     NULL,                                  /* exit master */
  833.     NGX_MODULE_V1_PADDING
  834. };


  837. ‌ngx_str_t  ngx_http_core_get_method = { 3, (u_char *) "GET" };


  840. void
  841. ‌ngx_http_handler(ngx_http_request_t *r)
  842. {
  843.     ngx_http_core_main_conf_t  *cmcf;

  845.     r->connection->log->action = NULL;

  847.     if (!r->internal) {

  849.         if (r->method != NGX_HTTP_CONNECT) {
  850.             switch (r->headers_in.connection_type) {
  851.             case 0:
  852.                 r->keepalive = (r->http_version > NGX_HTTP_VERSION_10);
  853.                 break;

  855.             case NGX_HTTP_CONNECTION_CLOSE:
  856.                 r->keepalive = 0;
  857.                 break;

  859.             case NGX_HTTP_CONNECTION_KEEP_ALIVE:
  860.                 r->keepalive = 1;
  861.                 break;
  862.             }
  863.         }

  865.         r->lingering_close = (r->headers_in.content_length_n > 0
  866.                               || r->headers_in.chunked);
  867.         r->phase_handler = 0;

  869.     } else {
  870.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
  871.         r->phase_handler = cmcf->phase_engine.server_rewrite_index;
  872.     }

  874.     r->valid_location = 1;
  875. #if (NGX_HTTP_GZIP)
  876.     r->gzip_tested = 0;
  877.     r->gzip_ok = 0;
  878.     r->gzip_vary = 0;
  879. #endif

  881.     r->write_event_handler = ngx_http_core_run_phases;
  882.     ngx_http_core_run_phases(r);
  883. }


  886. void
  887. ‌ngx_http_core_run_phases(ngx_http_request_t *r)
  888. {
  889.     ngx_int_t                   rc;
  890.     ngx_http_phase_handler_t   *ph;
  891.     ngx_http_core_main_conf_t  *cmcf;

  893.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  895.     ph = cmcf->phase_engine.handlers;

  897.     while (ph[r->phase_handler].checker) {

  899.         rc = ph[r->phase_handler].checker(r, &ph[r->phase_handler]);

  901.         if (rc == NGX_OK) {
  902.             return;
  903.         }
  904.     }
  905. }


  908. ngx_int_t
  909. ‌ngx_http_core_generic_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  910. {
  911.     ngx_int_t  rc;

  913.     /*
  914.      * generic phase checker,
  915.      * used by the post read and pre-access phases
  916.      */

  918.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  919.                    "generic phase: %ui", r->phase_handler);

  921.     rc = ph->handler(r);

  923.     if (rc == NGX_OK) {
  924.         r->phase_handler = ph->next;
  925.         return NGX_AGAIN;
  926.     }

  928.     if (rc == NGX_DECLINED) {
  929.         r->phase_handler++;
  930.         return NGX_AGAIN;
  931.     }

  933.     if (rc == NGX_AGAIN || rc == NGX_DONE) {
  934.         return NGX_OK;
  935.     }

  937.     /* rc == NGX_ERROR || rc == NGX_HTTP_...  */

  939.     ngx_http_finalize_request(r, rc);

  941.     return NGX_OK;
  942. }


  945. ngx_int_t
  946. ‌ngx_http_core_rewrite_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  947. {
  948.     ngx_int_t  rc;

  950.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  951.                    "rewrite phase: %ui", r->phase_handler);

  953.     rc = ph->handler(r);

  955.     if (rc == NGX_DECLINED) {
  956.         r->phase_handler++;
  957.         return NGX_AGAIN;
  958.     }

  960.     if (rc == NGX_DONE) {
  961.         return NGX_OK;
  962.     }

  964.     /* NGX_OK, NGX_AGAIN, NGX_ERROR, NGX_HTTP_...  */

  966.     ngx_http_finalize_request(r, rc);

  968.     return NGX_OK;
  969. }


  972. ngx_int_t
  973. ‌ngx_http_core_find_config_phase(ngx_http_request_t *r,
  974.     ngx_http_phase_handler_t *ph)
  975. {
  976.     u_char                    *p;
  977.     size_t                     len;
  978.     ngx_int_t                  rc;
  979.     ngx_http_core_loc_conf_t  *clcf;

  981.     r->content_handler = NULL;
  982.     r->uri_changed = 0;

  984.     rc = ngx_http_core_find_location(r);

  986.     if (rc == NGX_ERROR) {
  987.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  988.         return NGX_OK;
  989.     }

  991.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  993.     if (!r->internal && clcf->internal) {
  994.         ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  995.         return NGX_OK;
  996.     }

  998.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  999.                    "using configuration \"%s%V\"",
  1000.                    (clcf->noname ? "*" : (clcf->exact_match ? "=" : "")),
  1001.                    &clcf->name);

  1003.     ngx_http_update_location_config(r);

  1005.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1006.                    "http cl:%O max:%O",
  1007.                    r->headers_in.content_length_n, clcf->client_max_body_size);

  1009.     if (r->headers_in.content_length_n != -1
  1010.         && !r->discard_body
  1011.         && clcf->client_max_body_size
  1012.         && clcf->client_max_body_size < r->headers_in.content_length_n)
  1013.     {
  1014.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1015.                       "client intended to send too large body: %O bytes",
  1016.                       r->headers_in.content_length_n);

  1018.         r->expect_tested = 1;
  1019.         (void) ngx_http_discard_request_body(r);
  1020.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_ENTITY_TOO_LARGE);
  1021.         return NGX_OK;
  1022.     }

  1024.     if (rc == NGX_DONE) {
  1025.         ngx_http_clear_location(r);

  1027.         r->headers_out.location = ngx_list_push(&r->headers_out.headers);
  1028.         if (r->headers_out.location == NULL) {
  1029.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1030.             return NGX_OK;
  1031.         }

  1033.         r->headers_out.location->hash = 1;
  1034.         r->headers_out.location->next = NULL;
  1035.         ngx_str_set(&r->headers_out.location->key, "Location");

  1037.         if (r->args.len == 0) {
  1038.             r->headers_out.location->value = clcf->escaped_name;

  1040.         } else {
  1041.             len = clcf->escaped_name.len + 1 + r->args.len;
  1042.             p = ngx_pnalloc(r->pool, len);

  1044.             if (p == NULL) {
  1045.                 ngx_http_clear_location(r);
  1046.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1047.                 return NGX_OK;
  1048.             }

  1050.             r->headers_out.location->value.len = len;
  1051.             r->headers_out.location->value.data = p;

  1053.             p = ngx_cpymem(p, clcf->escaped_name.data, clcf->escaped_name.len);
  1054.             *p++ = '?';
  1055.             ngx_memcpy(p, r->args.data, r->args.len);
  1056.         }

  1058.         ngx_http_finalize_request(r, NGX_HTTP_MOVED_PERMANENTLY);
  1059.         return NGX_OK;
  1060.     }

  1062.     r->phase_handler++;
  1063.     return NGX_AGAIN;
  1064. }


  1067. ngx_int_t
  1068. ‌ngx_http_core_post_rewrite_phase(ngx_http_request_t *r,
  1069.     ngx_http_phase_handler_t *ph)
  1070. {
  1071.     ngx_http_core_srv_conf_t  *cscf;

  1073.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1074.                    "post rewrite phase: %ui", r->phase_handler);

  1076.     if (!r->uri_changed) {
  1077.         r->phase_handler++;
  1078.         return NGX_AGAIN;
  1079.     }

  1081.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1082.                    "uri changes: %d", r->uri_changes);

  1084.     /*
  1085.      * gcc before 3.3 compiles the broken code for
  1086.      *     if (r->uri_changes-- == 0)
  1087.      * if the r->uri_changes is defined as
  1088.      *     unsigned  uri_changes:4
  1089.      */

  1091.     r->uri_changes--;

  1093.     if (r->uri_changes == 0) {
  1094.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1095.                       "rewrite or internal redirection cycle "
  1096.                       "while processing \"%V\"", &r->uri);

  1098.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1099.         return NGX_OK;
  1100.     }

  1102.     r->phase_handler = ph->next;

  1104.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  1105.     r->loc_conf = cscf->ctx->loc_conf;

  1107.     return NGX_AGAIN;
  1108. }


  1111. ngx_int_t
  1112. ‌ngx_http_core_access_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  1113. {
  1114.     ngx_int_t                  rc;
  1115.     ngx_table_elt_t           *h;
  1116.     ngx_http_core_loc_conf_t  *clcf;

  1118.     if (r != r->main) {
  1119.         r->phase_handler = ph->next;
  1120.         return NGX_AGAIN;
  1121.     }

  1123.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1124.                    "access phase: %ui", r->phase_handler);

  1126.     rc = ph->handler(r);

  1128.     if (rc == NGX_DECLINED) {
  1129.         r->phase_handler++;
  1130.         return NGX_AGAIN;
  1131.     }

  1133.     if (rc == NGX_AGAIN || rc == NGX_DONE) {
  1134.         return NGX_OK;
  1135.     }

  1137.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1139.     if (clcf->satisfy == NGX_HTTP_SATISFY_ALL) {

  1141.         if (rc == NGX_OK) {
  1142.             r->phase_handler++;
  1143.             return NGX_AGAIN;
  1144.         }

  1146.     } else {
  1147.         if (rc == NGX_OK) {
  1148.             r->access_code = 0;

  1150.             h = ngx_http_proxy_auth(r) ? r->headers_out.proxy_authenticate
  1151.                                        : r->headers_out.www_authenticate;

  1153.             for ( /* void */ ; h; h = h->next) {
  1154.                 h->hash = 0;
  1155.             }

  1157.             r->phase_handler = ph->next;
  1158.             return NGX_AGAIN;
  1159.         }

  1161.         if (rc == NGX_HTTP_FORBIDDEN
  1162.             || rc == NGX_HTTP_UNAUTHORIZED
  1163.             || rc == NGX_HTTP_PROXY_AUTH_REQUIRED)
  1164.         {
  1165.             if (r->access_code != NGX_HTTP_UNAUTHORIZED
  1166.                 && r->access_code != NGX_HTTP_PROXY_AUTH_REQUIRED)
  1167.             {
  1168.                 r->access_code = rc;
  1169.             }

  1171.             r->phase_handler++;
  1172.             return NGX_AGAIN;
  1173.         }
  1174.     }

  1176.     /* rc == NGX_ERROR || rc == NGX_HTTP_...  */

  1178.     if (rc == NGX_HTTP_UNAUTHORIZED || rc == NGX_HTTP_PROXY_AUTH_REQUIRED) {
  1179.         r->access_code = rc;
  1180.         return ngx_http_core_auth_delay(r);
  1181.     }

  1183.     ngx_http_finalize_request(r, rc);
  1184.     return NGX_OK;
  1185. }


  1188. ngx_int_t
  1189. ‌ngx_http_core_post_access_phase(ngx_http_request_t *r,
  1190.     ngx_http_phase_handler_t *ph)
  1191. {
  1192.     ngx_int_t  access_code;

  1194.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1195.                    "post access phase: %ui", r->phase_handler);

  1197.     access_code = r->access_code;

  1199.     if (access_code) {
  1200.         if (access_code == NGX_HTTP_FORBIDDEN) {
  1201.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1202.                           "access forbidden by rule");
  1203.         }

  1205.         if (access_code == NGX_HTTP_UNAUTHORIZED
  1206.             || access_code == NGX_HTTP_PROXY_AUTH_REQUIRED)
  1207.         {
  1208.             return ngx_http_core_auth_delay(r);
  1209.         }

  1211.         r->access_code = 0;

  1213.         ngx_http_finalize_request(r, access_code);
  1214.         return NGX_OK;
  1215.     }

  1217.     r->phase_handler++;
  1218.     return NGX_AGAIN;
  1219. }


  1222. static ngx_int_t
  1223. ‌ngx_http_core_auth_delay(ngx_http_request_t *r)
  1224. {
  1225.     ngx_int_t                  access_code;
  1226.     ngx_http_core_loc_conf_t  *clcf;

  1228.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1230.     if (clcf->auth_delay == 0) {
  1231.         access_code = r->access_code;
  1232.         r->access_code = 0;

  1234.         ngx_http_finalize_request(r, access_code);
  1235.         return NGX_OK;
  1236.     }

  1238.     ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1239.                   "delaying unauthorized request");

  1241.     if (r->connection->read->ready) {
  1242.         ngx_post_event(r->connection->read, &ngx_posted_events);

  1244.     } else {
  1245.         if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
  1246.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1247.         }
  1248.     }

  1250.     r->read_event_handler = ngx_http_test_reading;
  1251.     r->write_event_handler = ngx_http_core_auth_delay_handler;

  1253.     r->connection->write->delayed = 1;
  1254.     ngx_add_timer(r->connection->write, clcf->auth_delay);

  1256.     /*
  1257.      * trigger an additional event loop iteration
  1258.      * to ensure constant-time processing
  1259.      */

  1261.     ngx_post_event(r->connection->write, &ngx_posted_next_events);

  1263.     return NGX_OK;
  1264. }


  1267. static void
  1268. ‌ngx_http_core_auth_delay_handler(ngx_http_request_t *r)
  1269. {
  1270.     ngx_int_t     access_code;
  1271.     ngx_event_t  *wev;

  1273.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1274.                    "auth delay handler");

  1276.     wev = r->connection->write;

  1278.     if (wev->delayed) {

  1280.         if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  1281.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1282.         }

  1284.         return;
  1285.     }

  1287.     access_code = r->access_code;
  1288.     r->access_code = 0;

  1290.     ngx_http_finalize_request(r, access_code);
  1291. }


  1294. ngx_int_t
  1295. ‌ngx_http_core_content_phase(ngx_http_request_t *r,
  1296.     ngx_http_phase_handler_t *ph)
  1297. {
  1298.     size_t     root;
  1299.     ngx_int_t  rc;
  1300.     ngx_str_t  path;

  1302.     if (r->content_handler) {
  1303.         r->write_event_handler = ngx_http_request_empty_handler;
  1304.         ngx_http_finalize_request(r, r->content_handler(r));
  1305.         return NGX_OK;
  1306.     }

  1308.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1309.                    "content phase: %ui", r->phase_handler);

  1311.     rc = ph->handler(r);

  1313.     if (rc != NGX_DECLINED) {
  1314.         ngx_http_finalize_request(r, rc);
  1315.         return NGX_OK;
  1316.     }

  1318.     /* rc == NGX_DECLINED */

  1320.     ph++;

  1322.     if (ph->checker) {
  1323.         r->phase_handler++;
  1324.         return NGX_AGAIN;
  1325.     }

  1327.     /* no content handler was found */

  1329.     if (r->uri.data[r->uri.len - 1] == '/') {

  1331.         if (ngx_http_map_uri_to_path(r, &path, &root, 0) != NULL) {
  1332.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1333.                           "directory index of \"%s\" is forbidden", path.data);
  1334.         }

  1336.         ngx_http_finalize_request(r, NGX_HTTP_FORBIDDEN);
  1337.         return NGX_OK;
  1338.     }

  1340.     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "no handler found");

  1342.     ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  1343.     return NGX_OK;
  1344. }


  1347. void
  1348. ‌ngx_http_update_location_config(ngx_http_request_t *r)
  1349. {
  1350.     ngx_http_core_loc_conf_t  *clcf;

  1352.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1354.     if (r->method & clcf->limit_except) {
  1355.         r->loc_conf = clcf->limit_except_loc_conf;
  1356.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  1357.     }

  1359.     if (r == r->main) {
  1360.         ngx_set_connection_log(r->connection, clcf->error_log);
  1361.     }

  1363.     if ((ngx_io.flags & NGX_IO_SENDFILE) && clcf->sendfile) {
  1364.         r->connection->sendfile = 1;

  1366.     } else {
  1367.         r->connection->sendfile = 0;
  1368.     }

  1370.     if (clcf->client_body_in_file_only) {
  1371.         r->request_body_in_file_only = 1;
  1372.         r->request_body_in_persistent_file = 1;
  1373.         r->request_body_in_clean_file =
  1374.             clcf->client_body_in_file_only == NGX_HTTP_REQUEST_BODY_FILE_CLEAN;
  1375.         r->request_body_file_log_level = NGX_LOG_NOTICE;

  1377.     } else {
  1378.         r->request_body_file_log_level = NGX_LOG_WARN;
  1379.     }

  1381.     r->request_body_in_single_buf = clcf->client_body_in_single_buffer;

  1383.     if (r->keepalive) {
  1384.         if (clcf->keepalive_timeout == 0) {
  1385.             r->keepalive = 0;

  1387.         } else if (r->connection->requests >= clcf->keepalive_requests) {
  1388.             r->keepalive = 0;

  1390.         } else if (ngx_current_msec - r->connection->start_time
  1391.                    > clcf->keepalive_time)
  1392.         {
  1393.             r->keepalive = 0;

  1395.         } else if (r->headers_in.msie6
  1396.                    && r->method == NGX_HTTP_POST
  1397.                    && (clcf->keepalive_disable
  1398.                        & NGX_HTTP_KEEPALIVE_DISABLE_MSIE6))
  1399.         {
  1400.             /*
  1401.              * MSIE may wait for some time if an response for
  1402.              * a POST request was sent over a keepalive connection
  1403.              */
  1404.             r->keepalive = 0;

  1406.         } else if (r->headers_in.safari
  1407.                    && (clcf->keepalive_disable
  1408.                        & NGX_HTTP_KEEPALIVE_DISABLE_SAFARI))
  1409.         {
  1410.             /*
  1411.              * Safari may send a POST request to a closed keepalive
  1412.              * connection and may stall for some time, see
  1413.              *     https://bugs.webkit.org/show_bug.cgi?id=5760
  1414.              */
  1415.             r->keepalive = 0;
  1416.         }
  1417.     }

  1419.     if (!clcf->tcp_nopush) {
  1420.         /* disable TCP_NOPUSH/TCP_CORK use */
  1421.         r->connection->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  1422.     }

  1424.     if (clcf->handler) {
  1425.         r->content_handler = clcf->handler;
  1426.     }
  1427. }


  1430. /*
  1431. * NGX_OK       - exact or regex match
  1432. * NGX_DONE     - auto redirect
  1433. * NGX_AGAIN    - inclusive match
  1434. * NGX_ERROR    - regex error
  1435. * NGX_DECLINED - no match
  1436. */

  1438. static ngx_int_t
  1439. ‌ngx_http_core_find_location(ngx_http_request_t *r)
  1440. {
  1441.     ngx_int_t                  rc;
  1442.     ngx_http_core_loc_conf_t  *pclcf;
  1443. #if (NGX_PCRE)
  1444.     ngx_int_t                  n;
  1445.     ngx_uint_t                 noregex;
  1446.     ngx_http_core_loc_conf_t  *clcf, **clcfp;

  1448.     noregex = 0;
  1449. #endif

  1451.     pclcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1453.     rc = ngx_http_core_find_static_location(r, pclcf->static_locations);

  1455.     if (rc == NGX_AGAIN) {

  1457. #if (NGX_PCRE)
  1458.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1460.         noregex = clcf->noregex;
  1461. #endif

  1463.         /* look up nested locations */

  1465.         rc = ngx_http_core_find_location(r);
  1466.     }

  1468.     if (rc == NGX_OK || rc == NGX_DONE) {
  1469.         return rc;
  1470.     }

  1472.     /* rc == NGX_DECLINED or rc == NGX_AGAIN in nested location */

  1474. #if (NGX_PCRE)

  1476.     if (noregex == 0 && pclcf->regex_locations) {

  1478.         for (clcfp = pclcf->regex_locations; *clcfp; clcfp++) {

  1480.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1481.                            "test location: ~ \"%V\"", &(*clcfp)->name);

  1483.             n = ngx_http_regex_exec(r, (*clcfp)->regex, &r->uri);

  1485.             if (n == NGX_OK) {
  1486.                 r->loc_conf = (*clcfp)->loc_conf;

  1488.                 /* look up nested locations */

  1490.                 rc = ngx_http_core_find_location(r);

  1492.                 return (rc == NGX_ERROR) ? rc : NGX_OK;
  1493.             }

  1495.             if (n == NGX_DECLINED) {
  1496.                 continue;
  1497.             }

  1499.             return NGX_ERROR;
  1500.         }
  1501.     }
  1502. #endif

  1504.     return rc;
  1505. }


  1508. /*
  1509. * NGX_OK       - exact match
  1510. * NGX_DONE     - auto redirect
  1511. * NGX_AGAIN    - inclusive match
  1512. * NGX_DECLINED - no match
  1513. */

  1515. static ngx_int_t
  1516. ‌ngx_http_core_find_static_location(ngx_http_request_t *r,
  1517.     ngx_http_location_tree_node_t *node)
  1518. {
  1519.     u_char     *uri;
  1520.     size_t      len, n;
  1521.     ngx_int_t   rc, rv;

  1523.     len = r->uri.len;
  1524.     uri = r->uri.data;

  1526.     rv = NGX_DECLINED;

  1528.     for ( ;; ) {

  1530.         if (node == NULL) {
  1531.             return rv;
  1532.         }

  1534.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1535.                        "test location: \"%*s\"",
  1536.                        (size_t) node->len, node->name);

  1538.         n = (len <= (size_t) node->len) ? len : node->len;

  1540.         rc = ngx_filename_cmp(uri, node->name, n);

  1542.         if (rc != 0) {
  1543.             node = (rc < 0) ? node->left : node->right;

  1545.             continue;
  1546.         }

  1548.         if (len > (size_t) node->len) {

  1550.             if (node->inclusive) {

  1552.                 r->loc_conf = node->inclusive->loc_conf;
  1553.                 rv = NGX_AGAIN;

  1555.                 node = node->tree;
  1556.                 uri += n;
  1557.                 len -= n;

  1559.                 continue;
  1560.             }

  1562.             /* exact only */

  1564.             node = node->right;

  1566.             continue;
  1567.         }

  1569.         if (len == (size_t) node->len) {

  1571.             if (node->exact) {
  1572.                 r->loc_conf = node->exact->loc_conf;
  1573.                 return NGX_OK;

  1575.             } else {
  1576.                 r->loc_conf = node->inclusive->loc_conf;
  1577.                 return NGX_AGAIN;
  1578.             }
  1579.         }

  1581.         /* len < node->len */

  1583.         if (len + 1 == (size_t) node->len && node->auto_redirect) {

  1585.             r->loc_conf = (node->exact) ? node->exact->loc_conf:
  1586.                                           node->inclusive->loc_conf;
  1587.             rv = NGX_DONE;
  1588.         }

  1590.         node = node->left;
  1591.     }
  1592. }


  1595. void *
  1596. ‌ngx_http_test_content_type(ngx_http_request_t *r, ngx_hash_t *types_hash)
  1597. {
  1598.     u_char      c, *lowcase;
  1599.     size_t      len;
  1600.     ngx_uint_t  i, hash;

  1602.     if (types_hash->size == 0) {
  1603.         return (void *) 4;
  1604.     }

  1606.     if (r->headers_out.content_type.len == 0) {
  1607.         return NULL;
  1608.     }

  1610.     len = r->headers_out.content_type_len;

  1612.     if (r->headers_out.content_type_lowcase == NULL) {

  1614.         lowcase = ngx_pnalloc(r->pool, len);
  1615.         if (lowcase == NULL) {
  1616.             return NULL;
  1617.         }

  1619.         r->headers_out.content_type_lowcase = lowcase;

  1621.         hash = 0;

  1623.         for (i = 0; i < len; i++) {
  1624.             c = ngx_tolower(r->headers_out.content_type.data[i]);
  1625.             hash = ngx_hash(hash, c);
  1626.             lowcase[i] = c;
  1627.         }

  1629.         r->headers_out.content_type_hash = hash;
  1630.     }

  1632.     return ngx_hash_find(types_hash, r->headers_out.content_type_hash,
  1633.                          r->headers_out.content_type_lowcase, len);
  1634. }


  1637. ngx_int_t
  1638. ‌ngx_http_set_content_type(ngx_http_request_t *r)
  1639. {
  1640.     u_char                     c, *exten;
  1641.     ngx_str_t                 *type;
  1642.     ngx_uint_t                 i, hash;
  1643.     ngx_http_core_loc_conf_t  *clcf;

  1645.     if (r->headers_out.content_type.len) {
  1646.         return NGX_OK;
  1647.     }

  1649.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1651.     if (r->exten.len) {

  1653.         hash = 0;

  1655.         for (i = 0; i < r->exten.len; i++) {
  1656.             c = r->exten.data[i];

  1658.             if (c >= 'A' && c <= 'Z') {

  1660.                 exten = ngx_pnalloc(r->pool, r->exten.len);
  1661.                 if (exten == NULL) {
  1662.                     return NGX_ERROR;
  1663.                 }

  1665.                 hash = ngx_hash_strlow(exten, r->exten.data, r->exten.len);

  1667.                 r->exten.data = exten;

  1669.                 break;
  1670.             }

  1672.             hash = ngx_hash(hash, c);
  1673.         }

  1675.         type = ngx_hash_find(&clcf->types_hash, hash,
  1676.                              r->exten.data, r->exten.len);

  1678.         if (type) {
  1679.             r->headers_out.content_type_len = type->len;
  1680.             r->headers_out.content_type = *type;

  1682.             return NGX_OK;
  1683.         }
  1684.     }

  1686.     r->headers_out.content_type_len = clcf->default_type.len;
  1687.     r->headers_out.content_type = clcf->default_type;

  1689.     return NGX_OK;
  1690. }


  1693. void
  1694. ‌ngx_http_set_exten(ngx_http_request_t *r)
  1695. {
  1696.     ngx_int_t  i;

  1698.     ngx_str_null(&r->exten);

  1700.     for (i = r->uri.len - 1; i > 1; i--) {
  1701.         if (r->uri.data[i] == '.' && r->uri.data[i - 1] != '/') {

  1703.             r->exten.len = r->uri.len - i - 1;
  1704.             r->exten.data = &r->uri.data[i + 1];

  1706.             return;

  1708.         } else if (r->uri.data[i] == '/') {
  1709.             return;
  1710.         }
  1711.     }

  1713.     return;
  1714. }


  1717. ngx_int_t
  1718. ‌ngx_http_set_etag(ngx_http_request_t *r)
  1719. {
  1720.     ngx_table_elt_t           *etag;
  1721.     ngx_http_core_loc_conf_t  *clcf;

  1723.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1725.     if (!clcf->etag) {
  1726.         return NGX_OK;
  1727.     }

  1729.     etag = ngx_list_push(&r->headers_out.headers);
  1730.     if (etag == NULL) {
  1731.         return NGX_ERROR;
  1732.     }

  1734.     etag->hash = 1;
  1735.     etag->next = NULL;
  1736.     ngx_str_set(&etag->key, "ETag");

  1738.     etag->value.data = ngx_pnalloc(r->pool, NGX_OFF_T_LEN + NGX_TIME_T_LEN + 3);
  1739.     if (etag->value.data == NULL) {
  1740.         etag->hash = 0;
  1741.         return NGX_ERROR;
  1742.     }

  1744.     etag->value.len = ngx_sprintf(etag->value.data, "\"%xT-%xO\"",
  1745.                                   r->headers_out.last_modified_time,
  1746.                                   r->headers_out.content_length_n)
  1747.                       - etag->value.data;

  1749.     r->headers_out.etag = etag;

  1751.     return NGX_OK;
  1752. }


  1755. void
  1756. ‌ngx_http_weak_etag(ngx_http_request_t *r)
  1757. {
  1758.     size_t            len;
  1759.     u_char           *p;
  1760.     ngx_table_elt_t  *etag;

  1762.     etag = r->headers_out.etag;

  1764.     if (etag == NULL) {
  1765.         return;
  1766.     }

  1768.     if (etag->value.len > 2
  1769.         && etag->value.data[0] == 'W'
  1770.         && etag->value.data[1] == '/')
  1771.     {
  1772.         return;
  1773.     }

  1775.     if (etag->value.len < 1 || etag->value.data[0] != '"') {
  1776.         r->headers_out.etag->hash = 0;
  1777.         r->headers_out.etag = NULL;
  1778.         return;
  1779.     }

  1781.     p = ngx_pnalloc(r->pool, etag->value.len + 2);
  1782.     if (p == NULL) {
  1783.         r->headers_out.etag->hash = 0;
  1784.         r->headers_out.etag = NULL;
  1785.         return;
  1786.     }

  1788.     len = ngx_sprintf(p, "W/%V", &etag->value) - p;

  1790.     etag->value.data = p;
  1791.     etag->value.len = len;
  1792. }


  1795. ngx_int_t
  1796. ‌ngx_http_send_response(ngx_http_request_t *r, ngx_uint_t status,
  1797.     ngx_str_t *ct, ngx_http_complex_value_t *cv)
  1798. {
  1799.     ngx_int_t     rc;
  1800.     ngx_str_t     val;
  1801.     ngx_buf_t    *b;
  1802.     ngx_chain_t   out;

  1804.     rc = ngx_http_discard_request_body(r);

  1806.     if (rc != NGX_OK) {
  1807.         return rc;
  1808.     }

  1810.     r->headers_out.status = status;

  1812.     if (ngx_http_complex_value(r, cv, &val) != NGX_OK) {
  1813.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1814.     }

  1816.     if (status == NGX_HTTP_MOVED_PERMANENTLY
  1817.         || status == NGX_HTTP_MOVED_TEMPORARILY
  1818.         || status == NGX_HTTP_SEE_OTHER
  1819.         || status == NGX_HTTP_TEMPORARY_REDIRECT
  1820.         || status == NGX_HTTP_PERMANENT_REDIRECT)
  1821.     {
  1822.         ngx_http_clear_location(r);

  1824.         r->headers_out.location = ngx_list_push(&r->headers_out.headers);
  1825.         if (r->headers_out.location == NULL) {
  1826.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1827.         }

  1829.         r->headers_out.location->hash = 1;
  1830.         r->headers_out.location->next = NULL;
  1831.         ngx_str_set(&r->headers_out.location->key, "Location");
  1832.         r->headers_out.location->value = val;

  1834.         return status;
  1835.     }

  1837.     r->headers_out.content_length_n = val.len;

  1839.     if (ct) {
  1840.         r->headers_out.content_type_len = ct->len;
  1841.         r->headers_out.content_type = *ct;

  1843.     } else {
  1844.         if (ngx_http_set_content_type(r) != NGX_OK) {
  1845.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1846.         }
  1847.     }

  1849.     b = ngx_calloc_buf(r->pool);
  1850.     if (b == NULL) {
  1851.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1852.     }

  1854.     b->pos = val.data;
  1855.     b->last = val.data + val.len;
  1856.     b->memory = val.len ? 1 : 0;
  1857.     b->last_buf = (r == r->main) ? 1 : 0;
  1858.     b->last_in_chain = 1;
  1859.     b->sync = (b->last_buf || b->memory) ? 0 : 1;

  1861.     out.buf = b;
  1862.     out.next = NULL;

  1864.     rc = ngx_http_send_header(r);

  1866.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  1867.         return rc;
  1868.     }

  1870.     return ngx_http_output_filter(r, &out);
  1871. }


  1874. ngx_int_t
  1875. ‌ngx_http_send_header(ngx_http_request_t *r)
  1876. {
  1877.     if (r->post_action) {
  1878.         return NGX_OK;
  1879.     }

  1881.     if (r->header_sent) {
  1882.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1883.                       "header already sent");
  1884.         return NGX_ERROR;
  1885.     }

  1887.     if (r->err_status) {
  1888.         r->headers_out.status = r->err_status;
  1889.         r->headers_out.status_line.len = 0;
  1890.     }

  1892.     return ngx_http_top_header_filter(r);
  1893. }


  1896. ngx_int_t
  1897. ‌ngx_http_send_early_hints(ngx_http_request_t *r)
  1898. {
  1899.     ngx_int_t                  rc;
  1900.     ngx_http_core_loc_conf_t  *clcf;

  1902.     if (r->post_action) {
  1903.         return NGX_OK;
  1904.     }

  1906.     if (r->header_sent) {
  1907.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1908.                       "header already sent");
  1909.         return NGX_ERROR;
  1910.     }

  1912.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1914.     rc = ngx_http_test_predicates(r, clcf->early_hints);

  1916.     if (rc != NGX_DECLINED) {
  1917.         return rc;
  1918.     }

  1920.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1921.                    "http send early hints \"%V?%V\"", &r->uri, &r->args);

  1923.     return ngx_http_top_early_hints_filter(r);
  1924. }


  1927. ngx_int_t
  1928. ‌ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1929. {
  1930.     ngx_int_t          rc;
  1931.     ngx_connection_t  *c;

  1933.     c = r->connection;

  1935.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1936.                    "http output filter \"%V?%V\"", &r->uri, &r->args);

  1938.     rc = ngx_http_top_body_filter(r, in);

  1940.     if (rc == NGX_ERROR) {
  1941.         /* NGX_ERROR may be returned by any filter */
  1942.         c->error = 1;
  1943.     }

  1945.     return rc;
  1946. }


  1949. u_char *
  1950. ‌ngx_http_map_uri_to_path(ngx_http_request_t *r, ngx_str_t *path,
  1951.     size_t *root_length, size_t reserved)
  1952. {
  1953.     u_char                    *last;
  1954.     size_t                     alias;
  1955.     ngx_http_core_loc_conf_t  *clcf;

  1957.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1959.     alias = clcf->alias;

  1961.     if (alias && !r->valid_location) {
  1962.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1963.                       "\"alias\" cannot be used in location \"%V\" "
  1964.                       "where URI was rewritten", &clcf->name);
  1965.         return NULL;
  1966.     }

  1968.     if (clcf->root_lengths == NULL) {

  1970.         *root_length = clcf->root.len;

  1972.         path->len = clcf->root.len + reserved + r->uri.len - alias + 1;

  1974.         path->data = ngx_pnalloc(r->pool, path->len);
  1975.         if (path->data == NULL) {
  1976.             return NULL;
  1977.         }

  1979.         last = ngx_copy(path->data, clcf->root.data, clcf->root.len);

  1981.     } else {

  1983.         if (alias == NGX_MAX_SIZE_T_VALUE) {
  1984.             reserved += r->add_uri_to_alias ? r->uri.len + 1 : 1;

  1986.         } else {
  1987.             reserved += r->uri.len - alias + 1;
  1988.         }

  1990.         if (ngx_http_script_run(r, path, clcf->root_lengths->elts, reserved,
  1991.                                 clcf->root_values->elts)
  1992.             == NULL)
  1993.         {
  1994.             return NULL;
  1995.         }

  1997.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, path)
  1998.             != NGX_OK)
  1999.         {
  2000.             return NULL;
  2001.         }

  2003.         *root_length = path->len - reserved;
  2004.         last = path->data + *root_length;

  2006.         if (alias == NGX_MAX_SIZE_T_VALUE) {
  2007.             if (!r->add_uri_to_alias) {
  2008.                 *last = '\0';
  2009.                 return last;
  2010.             }

  2012.             alias = 0;
  2013.         }
  2014.     }

  2016.     last = ngx_copy(last, r->uri.data + alias, r->uri.len - alias);
  2017.     *last = '\0';

  2019.     return last;
  2020. }


  2023. ngx_int_t
  2024. ‌ngx_http_auth_basic_user(ngx_http_request_t *r)
  2025. {
  2026.     ngx_str_t         auth, encoded;
  2027.     ngx_uint_t        len;
  2028.     ngx_table_elt_t  *h;

  2030.     if (r->headers_in.user.len == 0 && r->headers_in.user.data != NULL) {
  2031.         return NGX_DECLINED;
  2032.     }

  2034.     h = ngx_http_proxy_auth(r) ? r->headers_in.proxy_authorization
  2035.                                : r->headers_in.authorization;

  2037.     if (h == NULL) {
  2038.         r->headers_in.user.data = (u_char *) "";
  2039.         return NGX_DECLINED;
  2040.     }

  2042.     encoded = h->value;

  2044.     if (encoded.len < sizeof("Basic ") - 1
  2045.         || ngx_strncasecmp(encoded.data, (u_char *) "Basic ",
  2046.                            sizeof("Basic ") - 1)
  2047.            != 0)
  2048.     {
  2049.         r->headers_in.user.data = (u_char *) "";
  2050.         return NGX_DECLINED;
  2051.     }

  2053.     encoded.len -= sizeof("Basic ") - 1;
  2054.     encoded.data += sizeof("Basic ") - 1;

  2056.     while (encoded.len && encoded.data[0] == ' ') {
  2057.         encoded.len--;
  2058.         encoded.data++;
  2059.     }

  2061.     if (encoded.len == 0) {
  2062.         r->headers_in.user.data = (u_char *) "";
  2063.         return NGX_DECLINED;
  2064.     }

  2066.     auth.len = ngx_base64_decoded_length(encoded.len);
  2067.     auth.data = ngx_pnalloc(r->pool, auth.len + 1);
  2068.     if (auth.data == NULL) {
  2069.         return NGX_ERROR;
  2070.     }

  2072.     if (ngx_decode_base64(&auth, &encoded) != NGX_OK) {
  2073.         r->headers_in.user.data = (u_char *) "";
  2074.         return NGX_DECLINED;
  2075.     }

  2077.     auth.data[auth.len] = '\0';

  2079.     for (len = 0; len < auth.len; len++) {
  2080.         if (auth.data[len] == ':') {
  2081.             break;
  2082.         }
  2083.     }

  2085.     if (len == 0 || len == auth.len) {
  2086.         r->headers_in.user.data = (u_char *) "";
  2087.         return NGX_DECLINED;
  2088.     }

  2090.     r->headers_in.user.len = len;
  2091.     r->headers_in.user.data = auth.data;
  2092.     r->headers_in.passwd.len = auth.len - len - 1;
  2093.     r->headers_in.passwd.data = &auth.data[len + 1];

  2095.     return NGX_OK;
  2096. }


  2099. #if (NGX_HTTP_GZIP)

  2101. ngx_int_t
  2102. ‌ngx_http_gzip_ok(ngx_http_request_t *r)
  2103. {
  2104.     time_t                     date, expires;
  2105.     ngx_uint_t                 p;
  2106.     ngx_table_elt_t           *e, *d, *ae, *cc;
  2107.     ngx_http_core_loc_conf_t  *clcf;

  2109.     r->gzip_tested = 1;

  2111.     if (r != r->main) {
  2112.         return NGX_DECLINED;
  2113.     }

  2115.     ae = r->headers_in.accept_encoding;
  2116.     if (ae == NULL) {
  2117.         return NGX_DECLINED;
  2118.     }

  2120.     if (ae->value.len < sizeof("gzip") - 1) {
  2121.         return NGX_DECLINED;
  2122.     }

  2124.     /*
  2125.      * test first for the most common case "gzip,...":
  2126.      *   MSIE:    "gzip, deflate"
  2127.      *   Firefox: "gzip,deflate"
  2128.      *   Chrome:  "gzip,deflate,sdch"
  2129.      *   Safari:  "gzip, deflate"
  2130.      *   Opera:   "gzip, deflate"
  2131.      */

  2133.     if (ngx_memcmp(ae->value.data, "gzip,", 5) != 0
  2134.         && ngx_http_gzip_accept_encoding(&ae->value) != NGX_OK)
  2135.     {
  2136.         return NGX_DECLINED;
  2137.     }

  2139.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2141.     if (r->headers_in.msie6 && clcf->gzip_disable_msie6) {
  2142.         return NGX_DECLINED;
  2143.     }

  2145.     if (r->http_version < clcf->gzip_http_version) {
  2146.         return NGX_DECLINED;
  2147.     }

  2149.     if (r->headers_in.via == NULL) {
  2150.         goto ok;
  2151.     }

  2153.     p = clcf->gzip_proxied;

  2155.     if (p & NGX_HTTP_GZIP_PROXIED_OFF) {
  2156.         return NGX_DECLINED;
  2157.     }

  2159.     if (p & NGX_HTTP_GZIP_PROXIED_ANY) {
  2160.         goto ok;
  2161.     }

  2163.     if (r->headers_in.authorization && (p & NGX_HTTP_GZIP_PROXIED_AUTH)) {
  2164.         goto ok;
  2165.     }

  2167.     e = r->headers_out.expires;

  2169.     if (e) {

  2171.         if (!(p & NGX_HTTP_GZIP_PROXIED_EXPIRED)) {
  2172.             return NGX_DECLINED;
  2173.         }

  2175.         expires = ngx_parse_http_time(e->value.data, e->value.len);
  2176.         if (expires == NGX_ERROR) {
  2177.             return NGX_DECLINED;
  2178.         }

  2180.         d = r->headers_out.date;

  2182.         if (d) {
  2183.             date = ngx_parse_http_time(d->value.data, d->value.len);
  2184.             if (date == NGX_ERROR) {
  2185.                 return NGX_DECLINED;
  2186.             }

  2188.         } else {
  2189.             date = ngx_time();
  2190.         }

  2192.         if (expires < date) {
  2193.             goto ok;
  2194.         }

  2196.         return NGX_DECLINED;
  2197.     }

  2199.     cc = r->headers_out.cache_control;

  2201.     if (cc) {

  2203.         if ((p & NGX_HTTP_GZIP_PROXIED_NO_CACHE)
  2204.             && ngx_http_parse_multi_header_lines(r, cc, &ngx_http_gzip_no_cache,
  2205.                                                  NULL)
  2206.                != NULL)
  2207.         {
  2208.             goto ok;
  2209.         }

  2211.         if ((p & NGX_HTTP_GZIP_PROXIED_NO_STORE)
  2212.             && ngx_http_parse_multi_header_lines(r, cc, &ngx_http_gzip_no_store,
  2213.                                                  NULL)
  2214.                != NULL)
  2215.         {
  2216.             goto ok;
  2217.         }

  2219.         if ((p & NGX_HTTP_GZIP_PROXIED_PRIVATE)
  2220.             && ngx_http_parse_multi_header_lines(r, cc, &ngx_http_gzip_private,
  2221.                                                  NULL)
  2222.                != NULL)
  2223.         {
  2224.             goto ok;
  2225.         }

  2227.         return NGX_DECLINED;
  2228.     }

  2230.     if ((p & NGX_HTTP_GZIP_PROXIED_NO_LM) && r->headers_out.last_modified) {
  2231.         return NGX_DECLINED;
  2232.     }

  2234.     if ((p & NGX_HTTP_GZIP_PROXIED_NO_ETAG) && r->headers_out.etag) {
  2235.         return NGX_DECLINED;
  2236.     }

  2238. ok:

  2240. #if (NGX_PCRE)

  2242.     if (clcf->gzip_disable && r->headers_in.user_agent) {

  2244.         if (ngx_regex_exec_array(clcf->gzip_disable,
  2245.                                  &r->headers_in.user_agent->value,
  2246.                                  r->connection->log)
  2247.             != NGX_DECLINED)
  2248.         {
  2249.             return NGX_DECLINED;
  2250.         }
  2251.     }

  2253. #endif

  2255.     r->gzip_ok = 1;

  2257.     return NGX_OK;
  2258. }


  2261. /*
  2262. * gzip is enabled for the following quantities:
  2263. *     "gzip; q=0.001" ... "gzip; q=1.000"
  2264. * gzip is disabled for the following quantities:
  2265. *     "gzip; q=0" ... "gzip; q=0.000", and for any invalid cases
  2266. */

  2268. static ngx_int_t
  2269. ‌ngx_http_gzip_accept_encoding(ngx_str_t *ae)
  2270. {
  2271.     u_char  *p, *start, *last;

  2273.     start = ae->data;
  2274.     last = start + ae->len;

  2276.     for ( ;; ) {
  2277.         p = ngx_strcasestrn(start, "gzip", 4 - 1);
  2278.         if (p == NULL) {
  2279.             return NGX_DECLINED;
  2280.         }

  2282.         if (p == start || (*(p - 1) == ',' || *(p - 1) == ' ')) {
  2283.             break;
  2284.         }

  2286.         start = p + 4;
  2287.     }

  2289.     p += 4;

  2291.     while (p < last) {
  2292.         switch (*p++) {
  2293.         case ',':
  2294.             return NGX_OK;
  2295.         case ';':
  2296.             goto quantity;
  2297.         case ' ':
  2298.             continue;
  2299.         default:
  2300.             return NGX_DECLINED;
  2301.         }
  2302.     }

  2304.     return NGX_OK;

  2306. quantity:

  2308.     while (p < last) {
  2309.         switch (*p++) {
  2310.         case 'q':
  2311.         case 'Q':
  2312.             goto equal;
  2313.         case ' ':
  2314.             continue;
  2315.         default:
  2316.             return NGX_DECLINED;
  2317.         }
  2318.     }

  2320.     return NGX_OK;

  2322. equal:

  2324.     if (p + 2 > last || *p++ != '=') {
  2325.         return NGX_DECLINED;
  2326.     }

  2328.     if (ngx_http_gzip_quantity(p, last) == 0) {
  2329.         return NGX_DECLINED;
  2330.     }

  2332.     return NGX_OK;
  2333. }


  2336. static ngx_uint_t
  2337. ‌ngx_http_gzip_quantity(u_char *p, u_char *last)
  2338. {
  2339.     u_char      c;
  2340.     ngx_uint_t  n, q;

  2342.     c = *p++;

  2344.     if (c != '0' && c != '1') {
  2345.         return 0;
  2346.     }

  2348.     q = (c - '0') * 100;

  2350.     if (p == last) {
  2351.         return q;
  2352.     }

  2354.     c = *p++;

  2356.     if (c == ',' || c == ' ') {
  2357.         return q;
  2358.     }

  2360.     if (c != '.') {
  2361.         return 0;
  2362.     }

  2364.     n = 0;

  2366.     while (p < last) {
  2367.         c = *p++;

  2369.         if (c == ',' || c == ' ') {
  2370.             break;
  2371.         }

  2373.         if (c >= '0' && c <= '9') {
  2374.             q += c - '0';
  2375.             n++;
  2376.             continue;
  2377.         }

  2379.         return 0;
  2380.     }

  2382.     if (q > 100 || n > 3) {
  2383.         return 0;
  2384.     }

  2386.     return q;
  2387. }

  2389. #endif


  2392. ngx_int_t
  2393. ‌ngx_http_subrequest(ngx_http_request_t *r,
  2394.     ngx_str_t *uri, ngx_str_t *args, ngx_http_request_t **psr,
  2395.     ngx_http_post_subrequest_t *ps, ngx_uint_t flags)
  2396. {
  2397.     ngx_time_t                    *tp;
  2398.     ngx_connection_t              *c;
  2399.     ngx_http_request_t            *sr;
  2400.     ngx_http_core_srv_conf_t      *cscf;
  2401.     ngx_http_posted_request_t     *posted;
  2402.     ngx_http_postponed_request_t  *pr, *p;

  2404.     if (r->subrequests == 0) {
  2405.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2406.                       "subrequests cycle while processing \"%V\"", uri);
  2407.         return NGX_ERROR;
  2408.     }

  2410.     /*
  2411.      * 1000 is reserved for other purposes.
  2412.      */
  2413.     if (r->main->count >= 65535 - 1000) {
  2414.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  2415.                       "request reference counter overflow "
  2416.                       "while processing \"%V\"", uri);
  2417.         return NGX_ERROR;
  2418.     }

  2420.     if (r->subrequest_in_memory) {
  2421.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2422.                       "nested in-memory subrequest \"%V\"", uri);
  2423.         return NGX_ERROR;
  2424.     }

  2426.     sr = ngx_pcalloc(r->pool, sizeof(ngx_http_request_t));
  2427.     if (sr == NULL) {
  2428.         return NGX_ERROR;
  2429.     }

  2431.     sr->signature = NGX_HTTP_MODULE;

  2433.     c = r->connection;
  2434.     sr->connection = c;

  2436.     sr->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);
  2437.     if (sr->ctx == NULL) {
  2438.         return NGX_ERROR;
  2439.     }

  2441.     if (ngx_list_init(&sr->headers_out.headers, r->pool, 20,
  2442.                       sizeof(ngx_table_elt_t))
  2443.         != NGX_OK)
  2444.     {
  2445.         return NGX_ERROR;
  2446.     }

  2448.     if (ngx_list_init(&sr->headers_out.trailers, r->pool, 4,
  2449.                       sizeof(ngx_table_elt_t))
  2450.         != NGX_OK)
  2451.     {
  2452.         return NGX_ERROR;
  2453.     }

  2455.     posted = ngx_palloc(r->pool, sizeof(ngx_http_posted_request_t));
  2456.     if (posted == NULL) {
  2457.         return NGX_ERROR;
  2458.     }

  2460.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2461.     sr->main_conf = cscf->ctx->main_conf;
  2462.     sr->srv_conf = cscf->ctx->srv_conf;
  2463.     sr->loc_conf = cscf->ctx->loc_conf;

  2465.     sr->pool = r->pool;

  2467.     sr->headers_in = r->headers_in;

  2469.     ngx_http_clear_content_length(sr);
  2470.     ngx_http_clear_accept_ranges(sr);
  2471.     ngx_http_clear_last_modified(sr);

  2473.     sr->request_body = r->request_body;

  2475. #if (NGX_HTTP_V2)
  2476.     sr->stream = r->stream;
  2477. #endif

  2479.     sr->method = NGX_HTTP_GET;
  2480.     sr->http_version = r->http_version;

  2482.     sr->port = r->port;

  2484.     sr->request_line = r->request_line;
  2485.     sr->uri = *uri;

  2487.     if (args) {
  2488.         sr->args = *args;
  2489.     }

  2491.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2492.                    "http subrequest \"%V?%V\"", uri, &sr->args);

  2494.     sr->subrequest_in_memory = (flags & NGX_HTTP_SUBREQUEST_IN_MEMORY) != 0;
  2495.     sr->waited = (flags & NGX_HTTP_SUBREQUEST_WAITED) != 0;
  2496.     sr->background = (flags & NGX_HTTP_SUBREQUEST_BACKGROUND) != 0;

  2498.     sr->unparsed_uri = r->unparsed_uri;
  2499.     sr->method_name = ngx_http_core_get_method;
  2500.     sr->http_protocol = r->http_protocol;
  2501.     sr->schema = r->schema;

  2503.     ngx_http_set_exten(sr);

  2505.     sr->main = r->main;
  2506.     sr->parent = r;
  2507.     sr->post_subrequest = ps;
  2508.     sr->read_event_handler = ngx_http_request_empty_handler;
  2509.     sr->write_event_handler = ngx_http_handler;

  2511.     sr->variables = r->variables;

  2513.     sr->log_handler = r->log_handler;

  2515.     if (sr->subrequest_in_memory) {
  2516.         sr->filter_need_in_memory = 1;
  2517.     }

  2519.     if (!sr->background) {
  2520.         pr = ngx_palloc(r->pool, sizeof(ngx_http_postponed_request_t));
  2521.         if (pr == NULL) {
  2522.             return NGX_ERROR;
  2523.         }

  2525.         pr->request = sr;
  2526.         pr->out = NULL;
  2527.         pr->next = NULL;

  2529.         if (c->data == r && r->postponed == NULL) {
  2530.             c->data = sr;
  2531.         }

  2533.         if (r->postponed) {
  2534.             for (p = r->postponed; p->next; p = p->next) { /* void */ }
  2535.             p->next = pr;

  2537.         } else {
  2538.             r->postponed = pr;
  2539.         }
  2540.     }

  2542.     sr->internal = 1;

  2544.     sr->discard_body = r->discard_body;
  2545.     sr->expect_tested = 1;
  2546.     sr->main_filter_need_in_memory = r->main_filter_need_in_memory;

  2548.     sr->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;
  2549.     sr->subrequests = r->subrequests - 1;

  2551.     tp = ngx_timeofday();
  2552.     sr->start_sec = tp->sec;
  2553.     sr->start_msec = tp->msec;

  2555.     r->main->count++;

  2557.     *psr = sr;

  2559.     if (flags & NGX_HTTP_SUBREQUEST_CLONE) {
  2560.         sr->method = r->method;
  2561.         sr->method_name = r->method_name;
  2562.         sr->loc_conf = r->loc_conf;
  2563.         sr->valid_location = r->valid_location;
  2564.         sr->valid_unparsed_uri = r->valid_unparsed_uri;
  2565.         sr->content_handler = r->content_handler;
  2566.         sr->phase_handler = r->phase_handler;
  2567.         sr->write_event_handler = ngx_http_core_run_phases;

  2569. #if (NGX_PCRE)
  2570.         sr->ncaptures = r->ncaptures;
  2571.         sr->captures = r->captures;
  2572.         sr->captures_data = r->captures_data;
  2573.         sr->realloc_captures = 1;
  2574.         r->realloc_captures = 1;
  2575. #endif

  2577.         ngx_http_update_location_config(sr);
  2578.     }

  2580.     return ngx_http_post_request(sr, posted);
  2581. }


  2584. ngx_int_t
  2585. ‌ngx_http_internal_redirect(ngx_http_request_t *r,
  2586.     ngx_str_t *uri, ngx_str_t *args)
  2587. {
  2588.     ngx_http_core_srv_conf_t  *cscf;

  2590.     r->uri_changes--;

  2592.     if (r->uri_changes == 0) {
  2593.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2594.                       "rewrite or internal redirection cycle "
  2595.                       "while internally redirecting to \"%V\"", uri);

  2597.         r->main->count++;
  2598.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2599.         return NGX_DONE;
  2600.     }

  2602.     r->uri = *uri;

  2604.     if (args) {
  2605.         r->args = *args;

  2607.     } else {
  2608.         ngx_str_null(&r->args);
  2609.     }

  2611.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2612.                    "internal redirect: \"%V?%V\"", uri, &r->args);

  2614.     ngx_http_set_exten(r);

  2616.     /* clear the modules contexts */
  2617.     ngx_memzero(r->ctx, sizeof(void *) * ngx_http_max_module);

  2619.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2620.     r->loc_conf = cscf->ctx->loc_conf;

  2622.     ngx_http_update_location_config(r);

  2624. #if (NGX_HTTP_CACHE)
  2625.     r->cache = NULL;
  2626. #endif

  2628.     r->internal = 1;
  2629.     r->valid_unparsed_uri = 0;
  2630.     r->add_uri_to_alias = 0;
  2631.     r->main->count++;

  2633.     ngx_http_handler(r);

  2635.     return NGX_DONE;
  2636. }


  2639. ngx_int_t
  2640. ‌ngx_http_named_location(ngx_http_request_t *r, ngx_str_t *name)
  2641. {
  2642.     ngx_http_core_srv_conf_t    *cscf;
  2643.     ngx_http_core_loc_conf_t   **clcfp;
  2644.     ngx_http_core_main_conf_t   *cmcf;

  2646.     r->main->count++;
  2647.     r->uri_changes--;

  2649.     if (r->uri_changes == 0) {
  2650.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2651.                       "rewrite or internal redirection cycle "
  2652.                       "while redirect to named location \"%V\"", name);

  2654.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2655.         return NGX_DONE;
  2656.     }

  2658.     if (r->uri.len == 0) {
  2659.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2660.                       "empty URI in redirect to named location \"%V\"", name);

  2662.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2663.         return NGX_DONE;
  2664.     }

  2666.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  2668.     if (cscf->named_locations) {

  2670.         for (clcfp = cscf->named_locations; *clcfp; clcfp++) {

  2672.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2673.                            "test location: \"%V\"", &(*clcfp)->name);

  2675.             if (name->len != (*clcfp)->name.len
  2676.                 || ngx_strncmp(name->data, (*clcfp)->name.data, name->len) != 0)
  2677.             {
  2678.                 continue;
  2679.             }

  2681.             ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2682.                            "using location: %V \"%V?%V\"",
  2683.                            name, &r->uri, &r->args);

  2685.             r->internal = 1;
  2686.             r->content_handler = NULL;
  2687.             r->uri_changed = 0;
  2688.             r->loc_conf = (*clcfp)->loc_conf;

  2690.             /* clear the modules contexts */
  2691.             ngx_memzero(r->ctx, sizeof(void *) * ngx_http_max_module);

  2693.             ngx_http_update_location_config(r);

  2695.             cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  2697.             r->phase_handler = cmcf->phase_engine.location_rewrite_index;

  2699.             r->write_event_handler = ngx_http_core_run_phases;
  2700.             ngx_http_core_run_phases(r);

  2702.             return NGX_DONE;
  2703.         }
  2704.     }

  2706.     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2707.                   "could not find named location \"%V\"", name);

  2709.     ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);

  2711.     return NGX_DONE;
  2712. }


  2715. ngx_http_cleanup_t *
  2716. ‌ngx_http_cleanup_add(ngx_http_request_t *r, size_t size)
  2717. {
  2718.     ngx_http_cleanup_t  *cln;

  2720.     r = r->main;

  2722.     cln = ngx_palloc(r->pool, sizeof(ngx_http_cleanup_t));
  2723.     if (cln == NULL) {
  2724.         return NULL;
  2725.     }

  2727.     if (size) {
  2728.         cln->data = ngx_palloc(r->pool, size);
  2729.         if (cln->data == NULL) {
  2730.             return NULL;
  2731.         }

  2733.     } else {
  2734.         cln->data = NULL;
  2735.     }

  2737.     cln->handler = NULL;
  2738.     cln->next = r->cleanup;

  2740.     r->cleanup = cln;

  2742.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2743.                    "http cleanup add: %p", cln);

  2745.     return cln;
  2746. }


  2749. ngx_int_t
  2750. ‌ngx_http_set_disable_symlinks(ngx_http_request_t *r,
  2751.     ngx_http_core_loc_conf_t *clcf, ngx_str_t *path, ngx_open_file_info_t *of)
  2752. {
  2753. #if (NGX_HAVE_OPENAT)
  2754.     u_char     *p;
  2755.     ngx_str_t   from;

  2757.     of->disable_symlinks = clcf->disable_symlinks;

  2759.     if (clcf->disable_symlinks_from == NULL) {
  2760.         return NGX_OK;
  2761.     }

  2763.     if (ngx_http_complex_value(r, clcf->disable_symlinks_from, &from)
  2764.         != NGX_OK)
  2765.     {
  2766.         return NGX_ERROR;
  2767.     }

  2769.     if (from.len == 0
  2770.         || from.len > path->len
  2771.         || ngx_memcmp(path->data, from.data, from.len) != 0)
  2772.     {
  2773.         return NGX_OK;
  2774.     }

  2776.     if (from.len == path->len) {
  2777.         of->disable_symlinks = NGX_DISABLE_SYMLINKS_OFF;
  2778.         return NGX_OK;
  2779.     }

  2781.     p = path->data + from.len;

  2783.     if (*p == '/') {
  2784.         of->disable_symlinks_from = from.len;
  2785.         return NGX_OK;
  2786.     }

  2788.     p--;

  2790.     if (*p == '/') {
  2791.         of->disable_symlinks_from = from.len - 1;
  2792.     }
  2793. #endif

  2795.     return NGX_OK;
  2796. }


  2799. ngx_int_t
  2800. ‌ngx_http_get_forwarded_addr(ngx_http_request_t *r, ngx_addr_t *addr,
  2801.     ngx_table_elt_t *headers, ngx_str_t *value, ngx_array_t *proxies,
  2802.     int recursive)
  2803. {
  2804.     ngx_int_t         rc;
  2805.     ngx_uint_t        found;
  2806.     ngx_table_elt_t  *h, *next;

  2808.     if (headers == NULL) {
  2809.         return ngx_http_get_forwarded_addr_internal(r, addr, value->data,
  2810.                                                     value->len, proxies,
  2811.                                                     recursive);
  2812.     }

  2814.     /* revert headers order */

  2816.     for (h = headers, headers = NULL; h; h = next) {
  2817.         next = h->next;
  2818.         h->next = headers;
  2819.         headers = h;
  2820.     }

  2822.     /* iterate over all headers in reverse order */

  2824.     rc = NGX_DECLINED;

  2826.     found = 0;

  2828.     for (h = headers; h; h = h->next) {
  2829.         rc = ngx_http_get_forwarded_addr_internal(r, addr, h->value.data,
  2830.                                                   h->value.len, proxies,
  2831.                                                   recursive);

  2833.         if (!recursive) {
  2834.             break;
  2835.         }

  2837.         if (rc == NGX_DECLINED && found) {
  2838.             rc = NGX_DONE;
  2839.             break;
  2840.         }

  2842.         if (rc != NGX_OK) {
  2843.             break;
  2844.         }

  2846.         found = 1;
  2847.     }

  2849.     /* restore headers order */

  2851.     for (h = headers, headers = NULL; h; h = next) {
  2852.         next = h->next;
  2853.         h->next = headers;
  2854.         headers = h;
  2855.     }

  2857.     return rc;
  2858. }


  2861. static ngx_int_t
  2862. ‌ngx_http_get_forwarded_addr_internal(ngx_http_request_t *r, ngx_addr_t *addr,
  2863.     u_char *xff, size_t xfflen, ngx_array_t *proxies, int recursive)
  2864. {
  2865.     u_char      *p;
  2866.     ngx_addr_t   paddr;
  2867.     ngx_uint_t   found;

  2869.     found = 0;

  2871.     do {

  2873.         if (ngx_cidr_match(addr->sockaddr, proxies) != NGX_OK) {
  2874.             return found ? NGX_DONE : NGX_DECLINED;
  2875.         }

  2877.         for (p = xff + xfflen - 1; p > xff; p--, xfflen--) {
  2878.             if (*p != ' ' && *p != ',') {
  2879.                 break;
  2880.             }
  2881.         }

  2883.         for ( /* void */ ; p > xff; p--) {
  2884.             if (*p == ' ' || *p == ',') {
  2885.                 p++;
  2886.                 break;
  2887.             }
  2888.         }

  2890.         if (ngx_parse_addr_port(r->pool, &paddr, p, xfflen - (p - xff))
  2891.             != NGX_OK)
  2892.         {
  2893.             return found ? NGX_DONE : NGX_DECLINED;
  2894.         }

  2896.         *addr = paddr;
  2897.         found = 1;
  2898.         xfflen = p - 1 - xff;

  2900.     } while (recursive && p > xff);

  2902.     return NGX_OK;
  2903. }


  2906. ngx_int_t
  2907. ‌ngx_http_link_multi_headers(ngx_http_request_t *r)
  2908. {
  2909.     ngx_uint_t        i, j;
  2910.     ngx_list_part_t  *part, *ppart;
  2911.     ngx_table_elt_t  *header, *pheader, **ph;

  2913.     if (r->headers_in.multi_linked) {
  2914.         return NGX_OK;
  2915.     }

  2917.     r->headers_in.multi_linked = 1;

  2919.     part = &r->headers_in.headers.part;
  2920.     header = part->elts;

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

  2924.         if (i >= part->nelts) {
  2925.             if (part->next == NULL) {
  2926.                 break;
  2927.             }

  2929.             part = part->next;
  2930.             header = part->elts;
  2931.             i = 0;
  2932.         }

  2934.         header[i].next = NULL;

  2936.         /*
  2937.          * search for previous headers with the same name;
  2938.          * if there are any, link to them
  2939.          */

  2941.         ppart = &r->headers_in.headers.part;
  2942.         pheader = ppart->elts;

  2944.         for (j = 0; /* void */; j++) {

  2946.             if (j >= ppart->nelts) {
  2947.                 if (ppart->next == NULL) {
  2948.                     break;
  2949.                 }

  2951.                 ppart = ppart->next;
  2952.                 pheader = ppart->elts;
  2953.                 j = 0;
  2954.             }

  2956.             if (part == ppart && i == j) {
  2957.                 break;
  2958.             }

  2960.             if (header[i].key.len == pheader[j].key.len
  2961.                 && ngx_strncasecmp(header[i].key.data, pheader[j].key.data,
  2962.                                    header[i].key.len)
  2963.                    == 0)
  2964.             {
  2965.                 ph = &pheader[j].next;
  2966.                 while (*ph) { ph = &(*ph)->next; }
  2967.                 *ph = &header[i];

  2969.                 r->headers_in.multi = 1;

  2971.                 break;
  2972.             }
  2973.         }
  2974.     }

  2976.     return NGX_OK;
  2977. }


  2980. static char *
  2981. ‌ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  2982. {
  2983.     char                        *rv;
  2984.     void                        *mconf;
  2985.     size_t                       len;
  2986.     u_char                      *p;
  2987.     ngx_uint_t                   i;
  2988.     ngx_conf_t                   pcf;
  2989.     ngx_http_module_t           *module;
  2990.     struct sockaddr_in          *sin;
  2991.     ngx_http_conf_ctx_t         *ctx, *http_ctx;
  2992.     ngx_http_listen_opt_t        lsopt;
  2993.     ngx_http_core_srv_conf_t    *cscf, **cscfp;
  2994.     ngx_http_core_main_conf_t   *cmcf;

  2996.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  2997.     if (ctx == NULL) {
  2998.         return NGX_CONF_ERROR;
  2999.     }

  3001.     http_ctx = cf->ctx;
  3002.     ctx->main_conf = http_ctx->main_conf;

  3004.     /* the server{}'s srv_conf */

  3006.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  3007.     if (ctx->srv_conf == NULL) {
  3008.         return NGX_CONF_ERROR;
  3009.     }

  3011.     /* the server{}'s loc_conf */

  3013.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  3014.     if (ctx->loc_conf == NULL) {
  3015.         return NGX_CONF_ERROR;
  3016.     }

  3018.     for (i = 0; cf->cycle->modules[i]; i++) {
  3019.         if (cf->cycle->modules[i]->type != NGX_HTTP_MODULE) {
  3020.             continue;
  3021.         }

  3023.         module = cf->cycle->modules[i]->ctx;

  3025.         if (module->create_srv_conf) {
  3026.             mconf = module->create_srv_conf(cf);
  3027.             if (mconf == NULL) {
  3028.                 return NGX_CONF_ERROR;
  3029.             }

  3031.             ctx->srv_conf[cf->cycle->modules[i]->ctx_index] = mconf;
  3032.         }

  3034.         if (module->create_loc_conf) {
  3035.             mconf = module->create_loc_conf(cf);
  3036.             if (mconf == NULL) {
  3037.                 return NGX_CONF_ERROR;
  3038.             }

  3040.             ctx->loc_conf[cf->cycle->modules[i]->ctx_index] = mconf;
  3041.         }
  3042.     }


  3045.     /* the server configuration context */

  3047.     cscf = ctx->srv_conf[ngx_http_core_module.ctx_index];
  3048.     cscf->ctx = ctx;


  3051.     cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];

  3053.     cscfp = ngx_array_push(&cmcf->servers);
  3054.     if (cscfp == NULL) {
  3055.         return NGX_CONF_ERROR;
  3056.     }

  3058.     *cscfp = cscf;


  3061.     /* parse inside server{} */

  3063.     pcf = *cf;
  3064.     cf->ctx = ctx;
  3065.     cf->cmd_type = NGX_HTTP_SRV_CONF;

  3067.     rv = ngx_conf_parse(cf, NULL);

  3069.     *cf = pcf;

  3071.     if (rv == NGX_CONF_OK && !cscf->listen) {
  3072.         ngx_memzero(&lsopt, sizeof(ngx_http_listen_opt_t));

  3074.         p = ngx_pcalloc(cf->pool, sizeof(struct sockaddr_in));
  3075.         if (p == NULL) {
  3076.             return NGX_CONF_ERROR;
  3077.         }

  3079.         lsopt.sockaddr = (struct sockaddr *) p;

  3081.         sin = (struct sockaddr_in *) p;

  3083.         sin->sin_family = AF_INET;
  3084. #if (NGX_WIN32)
  3085.         sin->sin_port = htons(80);
  3086. #else
  3087.         sin->sin_port = htons((getuid() == 0) ? 80 : 8000);
  3088. #endif
  3089.         sin->sin_addr.s_addr = INADDR_ANY;

  3091.         lsopt.socklen = sizeof(struct sockaddr_in);

  3093.         lsopt.backlog = NGX_LISTEN_BACKLOG;
  3094.         lsopt.type = SOCK_STREAM;
  3095.         lsopt.rcvbuf = -1;
  3096.         lsopt.sndbuf = -1;
  3097. #if (NGX_HAVE_SETFIB)
  3098.         lsopt.setfib = -1;
  3099. #endif
  3100. #if (NGX_HAVE_TCP_FASTOPEN)
  3101.         lsopt.fastopen = -1;
  3102. #endif
  3103.         lsopt.wildcard = 1;

  3105.         len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;

  3107.         p = ngx_pnalloc(cf->pool, len);
  3108.         if (p == NULL) {
  3109.             return NGX_CONF_ERROR;
  3110.         }

  3112.         lsopt.addr_text.data = p;
  3113.         lsopt.addr_text.len = ngx_sock_ntop(lsopt.sockaddr, lsopt.socklen, p,
  3114.                                             len, 1);

  3116.         if (ngx_http_add_listen(cf, cscf, &lsopt) != NGX_OK) {
  3117.             return NGX_CONF_ERROR;
  3118.         }
  3119.     }

  3121.     return rv;
  3122. }


  3125. static char *
  3126. ‌ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  3127. {
  3128.     char                      *rv;
  3129.     u_char                    *mod;
  3130.     size_t                     len;
  3131.     ngx_str_t                 *value, *name;
  3132.     ngx_uint_t                 i;
  3133.     ngx_conf_t                 save;
  3134.     ngx_http_module_t         *module;
  3135.     ngx_http_conf_ctx_t       *ctx, *pctx;
  3136.     ngx_http_core_loc_conf_t  *clcf, *pclcf;

  3138.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  3139.     if (ctx == NULL) {
  3140.         return NGX_CONF_ERROR;
  3141.     }

  3143.     pctx = cf->ctx;
  3144.     ctx->main_conf = pctx->main_conf;
  3145.     ctx->srv_conf = pctx->srv_conf;

  3147.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  3148.     if (ctx->loc_conf == NULL) {
  3149.         return NGX_CONF_ERROR;
  3150.     }

  3152.     for (i = 0; cf->cycle->modules[i]; i++) {
  3153.         if (cf->cycle->modules[i]->type != NGX_HTTP_MODULE) {
  3154.             continue;
  3155.         }

  3157.         module = cf->cycle->modules[i]->ctx;

  3159.         if (module->create_loc_conf) {
  3160.             ctx->loc_conf[cf->cycle->modules[i]->ctx_index] =
  3161.                                                    module->create_loc_conf(cf);
  3162.             if (ctx->loc_conf[cf->cycle->modules[i]->ctx_index] == NULL) {
  3163.                 return NGX_CONF_ERROR;
  3164.             }
  3165.         }
  3166.     }

  3168.     clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
  3169.     clcf->loc_conf = ctx->loc_conf;

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

  3173.     if (cf->args->nelts == 3) {

  3175.         len = value[1].len;
  3176.         mod = value[1].data;
  3177.         name = &value[2];

  3179.         if (len == 1 && mod[0] == '=') {

  3181.             clcf->name = *name;
  3182.             clcf->exact_match = 1;

  3184.         } else if (len == 2 && mod[0] == '^' && mod[1] == '~') {

  3186.             clcf->name = *name;
  3187.             clcf->noregex = 1;

  3189.         } else if (len == 1 && mod[0] == '~') {

  3191.             if (ngx_http_core_regex_location(cf, clcf, name, 0) != NGX_OK) {
  3192.                 return NGX_CONF_ERROR;
  3193.             }

  3195.         } else if (len == 2 && mod[0] == '~' && mod[1] == '*') {

  3197.             if (ngx_http_core_regex_location(cf, clcf, name, 1) != NGX_OK) {
  3198.                 return NGX_CONF_ERROR;
  3199.             }

  3201.         } else {
  3202.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3203.                                "invalid location modifier \"%V\"", &value[1]);
  3204.             return NGX_CONF_ERROR;
  3205.         }

  3207.     } else {

  3209.         name = &value[1];

  3211.         if (name->data[0] == '=') {

  3213.             clcf->name.len = name->len - 1;
  3214.             clcf->name.data = name->data + 1;
  3215.             clcf->exact_match = 1;

  3217.         } else if (name->data[0] == '^' && name->data[1] == '~') {

  3219.             clcf->name.len = name->len - 2;
  3220.             clcf->name.data = name->data + 2;
  3221.             clcf->noregex = 1;

  3223.         } else if (name->data[0] == '~') {

  3225.             name->len--;
  3226.             name->data++;

  3228.             if (name->data[0] == '*') {

  3230.                 name->len--;
  3231.                 name->data++;

  3233.                 if (ngx_http_core_regex_location(cf, clcf, name, 1) != NGX_OK) {
  3234.                     return NGX_CONF_ERROR;
  3235.                 }

  3237.             } else {
  3238.                 if (ngx_http_core_regex_location(cf, clcf, name, 0) != NGX_OK) {
  3239.                     return NGX_CONF_ERROR;
  3240.                 }
  3241.             }

  3243.         } else {

  3245.             clcf->name = *name;

  3247.             if (name->data[0] == '@') {
  3248.                 clcf->named = 1;
  3249.             }
  3250.         }
  3251.     }

  3253.     pclcf = pctx->loc_conf[ngx_http_core_module.ctx_index];

  3255.     if (cf->cmd_type == NGX_HTTP_LOC_CONF) {

  3257.         /* nested location */

  3259. #if 0
  3260.         clcf->prev_location = pclcf;
  3261. #endif

  3263.         if (pclcf->exact_match) {
  3264.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3265.                                "location \"%V\" cannot be inside "
  3266.                                "the exact location \"%V\"",
  3267.                                &clcf->name, &pclcf->name);
  3268.             return NGX_CONF_ERROR;
  3269.         }

  3271.         if (pclcf->named) {
  3272.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3273.                                "location \"%V\" cannot be inside "
  3274.                                "the named location \"%V\"",
  3275.                                &clcf->name, &pclcf->name);
  3276.             return NGX_CONF_ERROR;
  3277.         }

  3279.         if (clcf->named) {
  3280.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3281.                                "named location \"%V\" can be "
  3282.                                "on the server level only",
  3283.                                &clcf->name);
  3284.             return NGX_CONF_ERROR;
  3285.         }

  3287.         len = pclcf->name.len;

  3289. #if (NGX_PCRE)
  3290.         if (clcf->regex == NULL
  3291.             && ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
  3292. #else
  3293.         if (ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
  3294. #endif
  3295.         {
  3296.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3297.                                "location \"%V\" is outside location \"%V\"",
  3298.                                &clcf->name, &pclcf->name);
  3299.             return NGX_CONF_ERROR;
  3300.         }
  3301.     }

  3303.     if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
  3304.         return NGX_CONF_ERROR;
  3305.     }

  3307.     save = *cf;
  3308.     cf->ctx = ctx;
  3309.     cf->cmd_type = NGX_HTTP_LOC_CONF;

  3311.     rv = ngx_conf_parse(cf, NULL);

  3313.     *cf = save;

  3315.     return rv;
  3316. }


  3319. static ngx_int_t
  3320. ‌ngx_http_core_regex_location(ngx_conf_t *cf, ngx_http_core_loc_conf_t *clcf,
  3321.     ngx_str_t *regex, ngx_uint_t caseless)
  3322. {
  3323. #if (NGX_PCRE)
  3324.     ngx_regex_compile_t  rc;
  3325.     u_char               errstr[NGX_MAX_CONF_ERRSTR];

  3327.     ngx_memzero(&rc, sizeof(ngx_regex_compile_t));

  3329.     rc.pattern = *regex;
  3330.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  3331.     rc.err.data = errstr;

  3333. #if (NGX_HAVE_CASELESS_FILESYSTEM)
  3334.     rc.options = NGX_REGEX_CASELESS;
  3335. #else
  3336.     rc.options = caseless ? NGX_REGEX_CASELESS : 0;
  3337. #endif

  3339.     clcf->regex = ngx_http_regex_compile(cf, &rc);
  3340.     if (clcf->regex == NULL) {
  3341.         return NGX_ERROR;
  3342.     }

  3344.     clcf->name = *regex;

  3346.     return NGX_OK;

  3348. #else

  3350.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3351.                        "using regex \"%V\" requires PCRE library",
  3352.                        regex);
  3353.     return NGX_ERROR;

  3355. #endif
  3356. }


  3359. static char *
  3360. ‌ngx_http_core_types(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3361. {
  3362.     ngx_http_core_loc_conf_t *clcf = conf;

  3364.     char        *rv;
  3365.     ngx_conf_t   save;

  3367.     if (clcf->types == NULL) {
  3368.         clcf->types = ngx_array_create(cf->pool, 64, sizeof(ngx_hash_key_t));
  3369.         if (clcf->types == NULL) {
  3370.             return NGX_CONF_ERROR;
  3371.         }
  3372.     }

  3374.     save = *cf;
  3375.     cf->handler = ngx_http_core_type;
  3376.     cf->handler_conf = conf;

  3378.     rv = ngx_conf_parse(cf, NULL);

  3380.     *cf = save;

  3382.     return rv;
  3383. }


  3386. static char *
  3387. ‌ngx_http_core_type(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
  3388. {
  3389.     ngx_http_core_loc_conf_t *clcf = conf;

  3391.     ngx_str_t       *value, *content_type, *old;
  3392.     ngx_uint_t       i, n, hash;
  3393.     ngx_hash_key_t  *type;

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

  3397.     if (ngx_strcmp(value[0].data, "include") == 0) {
  3398.         if (cf->args->nelts != 2) {
  3399.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3400.                                "invalid number of arguments"
  3401.                                " in \"include\" directive");
  3402.             return NGX_CONF_ERROR;
  3403.         }

  3405.         return ngx_conf_include(cf, dummy, conf);
  3406.     }

  3408.     content_type = ngx_palloc(cf->pool, sizeof(ngx_str_t));
  3409.     if (content_type == NULL) {
  3410.         return NGX_CONF_ERROR;
  3411.     }

  3413.     *content_type = value[0];

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

  3417.         hash = ngx_hash_strlow(value[i].data, value[i].data, value[i].len);

  3419.         type = clcf->types->elts;
  3420.         for (n = 0; n < clcf->types->nelts; n++) {
  3421.             if (ngx_strcmp(value[i].data, type[n].key.data) == 0) {
  3422.                 old = type[n].value;
  3423.                 type[n].value = content_type;

  3425.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  3426.                                    "duplicate extension \"%V\", "
  3427.                                    "content type: \"%V\", "
  3428.                                    "previous content type: \"%V\"",
  3429.                                    &value[i], content_type, old);
  3430.                 goto next;
  3431.             }
  3432.         }


  3435.         type = ngx_array_push(clcf->types);
  3436.         if (type == NULL) {
  3437.             return NGX_CONF_ERROR;
  3438.         }

  3440.         type->key = value[i];
  3441.         type->key_hash = hash;
  3442.         type->value = content_type;

  3444.     next:
  3445.         continue;
  3446.     }

  3448.     return NGX_CONF_OK;
  3449. }


  3452. static ngx_int_t
  3453. ‌ngx_http_core_preconfiguration(ngx_conf_t *cf)
  3454. {
  3455.     return ngx_http_variables_add_core_vars(cf);
  3456. }


  3459. static ngx_int_t
  3460. ‌ngx_http_core_postconfiguration(ngx_conf_t *cf)
  3461. {
  3462.     ngx_http_top_request_body_filter = ngx_http_request_body_save_filter;

  3464.     return NGX_OK;
  3465. }


  3468. static void *
  3469. ‌ngx_http_core_create_main_conf(ngx_conf_t *cf)
  3470. {
  3471.     ngx_http_core_main_conf_t  *cmcf;

  3473.     cmcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_main_conf_t));
  3474.     if (cmcf == NULL) {
  3475.         return NULL;
  3476.     }

  3478.     if (ngx_array_init(&cmcf->servers, cf->pool, 4,
  3479.                        sizeof(ngx_http_core_srv_conf_t *))
  3480.         != NGX_OK)
  3481.     {
  3482.         return NULL;
  3483.     }

  3485.     cmcf->server_names_hash_max_size = NGX_CONF_UNSET_UINT;
  3486.     cmcf->server_names_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3488.     cmcf->variables_hash_max_size = NGX_CONF_UNSET_UINT;
  3489.     cmcf->variables_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3491.     return cmcf;
  3492. }


  3495. static char *
  3496. ‌ngx_http_core_init_main_conf(ngx_conf_t *cf, void *conf)
  3497. {
  3498.     ngx_http_core_main_conf_t *cmcf = conf;

  3500.     ngx_conf_init_uint_value(cmcf->server_names_hash_max_size, 512);
  3501.     ngx_conf_init_uint_value(cmcf->server_names_hash_bucket_size,
  3502.                              ngx_cacheline_size);

  3504.     cmcf->server_names_hash_bucket_size =
  3505.             ngx_align(cmcf->server_names_hash_bucket_size, ngx_cacheline_size);


  3508.     ngx_conf_init_uint_value(cmcf->variables_hash_max_size, 1024);
  3509.     ngx_conf_init_uint_value(cmcf->variables_hash_bucket_size, 64);

  3511.     cmcf->variables_hash_bucket_size =
  3512.                ngx_align(cmcf->variables_hash_bucket_size, ngx_cacheline_size);

  3514.     if (cmcf->ncaptures) {
  3515.         cmcf->ncaptures = (cmcf->ncaptures + 1) * 3;
  3516.     }

  3518.     return NGX_CONF_OK;
  3519. }


  3522. static void *
  3523. ‌ngx_http_core_create_srv_conf(ngx_conf_t *cf)
  3524. {
  3525.     ngx_http_core_srv_conf_t  *cscf;

  3527.     cscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_srv_conf_t));
  3528.     if (cscf == NULL) {
  3529.         return NULL;
  3530.     }

  3532.     /*
  3533.      * set by ngx_pcalloc():
  3534.      *
  3535.      *     conf->client_large_buffers.num = 0;
  3536.      */

  3538.     if (ngx_array_init(&cscf->server_names, cf->temp_pool, 4,
  3539.                        sizeof(ngx_http_server_name_t))
  3540.         != NGX_OK)
  3541.     {
  3542.         return NULL;
  3543.     }

  3545.     cscf->connection_pool_size = NGX_CONF_UNSET_SIZE;
  3546.     cscf->request_pool_size = NGX_CONF_UNSET_SIZE;
  3547.     cscf->client_header_timeout = NGX_CONF_UNSET_MSEC;
  3548.     cscf->client_header_buffer_size = NGX_CONF_UNSET_SIZE;
  3549.     cscf->max_headers = NGX_CONF_UNSET_UINT;
  3550.     cscf->ignore_invalid_headers = NGX_CONF_UNSET;
  3551.     cscf->merge_slashes = NGX_CONF_UNSET;
  3552.     cscf->underscores_in_headers = NGX_CONF_UNSET;

  3554.     cscf->file_name = cf->conf_file->file.name.data;
  3555.     cscf->line = cf->conf_file->line;

  3557.     return cscf;
  3558. }


  3561. static char *
  3562. ‌ngx_http_core_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  3563. {
  3564.     ngx_http_core_srv_conf_t *prev = parent;
  3565.     ngx_http_core_srv_conf_t *conf = child;

  3567.     ngx_str_t                name;
  3568.     ngx_http_server_name_t  *sn;

  3570.     /* TODO: it does not merge, it inits only */

  3572.     ngx_conf_merge_size_value(conf->connection_pool_size,
  3573.                               prev->connection_pool_size, 64 * sizeof(void *));
  3574.     ngx_conf_merge_size_value(conf->request_pool_size,
  3575.                               prev->request_pool_size, 4096);
  3576.     ngx_conf_merge_msec_value(conf->client_header_timeout,
  3577.                               prev->client_header_timeout, 60000);
  3578.     ngx_conf_merge_size_value(conf->client_header_buffer_size,
  3579.                               prev->client_header_buffer_size, 1024);
  3580.     ngx_conf_merge_bufs_value(conf->large_client_header_buffers,
  3581.                               prev->large_client_header_buffers,
  3582.                               4, 8192);

  3584.     if (conf->large_client_header_buffers.size < conf->connection_pool_size) {
  3585.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3586.                            "the \"large_client_header_buffers\" size must be "
  3587.                            "equal to or greater than \"connection_pool_size\"");
  3588.         return NGX_CONF_ERROR;
  3589.     }

  3591.     ngx_conf_merge_uint_value(conf->max_headers, prev->max_headers, 1000);

  3593.     ngx_conf_merge_value(conf->ignore_invalid_headers,
  3594.                               prev->ignore_invalid_headers, 1);

  3596.     ngx_conf_merge_value(conf->merge_slashes, prev->merge_slashes, 1);

  3598.     ngx_conf_merge_value(conf->underscores_in_headers,
  3599.                               prev->underscores_in_headers, 0);

  3601.     if (conf->server_names.nelts == 0) {
  3602.         /* the array has 4 empty preallocated elements, so push cannot fail */
  3603.         sn = ngx_array_push(&conf->server_names);
  3604. #if (NGX_PCRE)
  3605.         sn->regex = NULL;
  3606. #endif
  3607.         sn->server = conf;
  3608.         ngx_str_set(&sn->name, "");
  3609.     }

  3611.     sn = conf->server_names.elts;
  3612.     name = sn[0].name;

  3614. #if (NGX_PCRE)
  3615.     if (sn->regex) {
  3616.         name.len++;
  3617.         name.data--;
  3618.     } else
  3619. #endif

  3621.     if (name.data[0] == '.') {
  3622.         name.len--;
  3623.         name.data++;
  3624.     }

  3626.     conf->server_name.len = name.len;
  3627.     conf->server_name.data = ngx_pstrdup(cf->pool, &name);
  3628.     if (conf->server_name.data == NULL) {
  3629.         return NGX_CONF_ERROR;
  3630.     }

  3632.     return NGX_CONF_OK;
  3633. }


  3636. static void *
  3637. ‌ngx_http_core_create_loc_conf(ngx_conf_t *cf)
  3638. {
  3639.     ngx_http_core_loc_conf_t  *clcf;

  3641.     clcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_loc_conf_t));
  3642.     if (clcf == NULL) {
  3643.         return NULL;
  3644.     }

  3646.     /*
  3647.      * set by ngx_pcalloc():
  3648.      *
  3649.      *     clcf->escaped_name = { 0, NULL };
  3650.      *     clcf->root = { 0, NULL };
  3651.      *     clcf->limit_except = 0;
  3652.      *     clcf->post_action = { 0, NULL };
  3653.      *     clcf->types = NULL;
  3654.      *     clcf->default_type = { 0, NULL };
  3655.      *     clcf->error_log = NULL;
  3656.      *     clcf->error_pages = NULL;
  3657.      *     clcf->client_body_path = NULL;
  3658.      *     clcf->regex = NULL;
  3659.      *     clcf->exact_match = 0;
  3660.      *     clcf->auto_redirect = 0;
  3661.      *     clcf->alias = 0;
  3662.      *     clcf->gzip_proxied = 0;
  3663.      *     clcf->keepalive_disable = 0;
  3664.      */

  3666.     clcf->client_max_body_size = NGX_CONF_UNSET;
  3667.     clcf->client_body_buffer_size = NGX_CONF_UNSET_SIZE;
  3668.     clcf->client_body_timeout = NGX_CONF_UNSET_MSEC;
  3669.     clcf->satisfy = NGX_CONF_UNSET_UINT;
  3670.     clcf->auth_delay = NGX_CONF_UNSET_MSEC;
  3671.     clcf->if_modified_since = NGX_CONF_UNSET_UINT;
  3672.     clcf->max_ranges = NGX_CONF_UNSET_UINT;
  3673.     clcf->client_body_in_file_only = NGX_CONF_UNSET_UINT;
  3674.     clcf->client_body_in_single_buffer = NGX_CONF_UNSET;
  3675.     clcf->internal = NGX_CONF_UNSET;
  3676.     clcf->sendfile = NGX_CONF_UNSET;
  3677.     clcf->sendfile_max_chunk = NGX_CONF_UNSET_SIZE;
  3678.     clcf->subrequest_output_buffer_size = NGX_CONF_UNSET_SIZE;
  3679.     clcf->aio = NGX_CONF_UNSET;
  3680.     clcf->aio_write = NGX_CONF_UNSET;
  3681. #if (NGX_THREADS)
  3682.     clcf->thread_pool = NGX_CONF_UNSET_PTR;
  3683.     clcf->thread_pool_value = NGX_CONF_UNSET_PTR;
  3684. #endif
  3685.     clcf->read_ahead = NGX_CONF_UNSET_SIZE;
  3686.     clcf->directio = NGX_CONF_UNSET;
  3687.     clcf->directio_alignment = NGX_CONF_UNSET;
  3688.     clcf->tcp_nopush = NGX_CONF_UNSET;
  3689.     clcf->tcp_nodelay = NGX_CONF_UNSET;
  3690.     clcf->send_timeout = NGX_CONF_UNSET_MSEC;
  3691.     clcf->send_lowat = NGX_CONF_UNSET_SIZE;
  3692.     clcf->postpone_output = NGX_CONF_UNSET_SIZE;
  3693.     clcf->limit_rate = NGX_CONF_UNSET_PTR;
  3694.     clcf->limit_rate_after = NGX_CONF_UNSET_PTR;
  3695.     clcf->keepalive_time = NGX_CONF_UNSET_MSEC;
  3696.     clcf->keepalive_timeout = NGX_CONF_UNSET_MSEC;
  3697.     clcf->keepalive_header = NGX_CONF_UNSET;
  3698.     clcf->keepalive_min_timeout = NGX_CONF_UNSET_MSEC;
  3699.     clcf->keepalive_requests = NGX_CONF_UNSET_UINT;
  3700.     clcf->lingering_close = NGX_CONF_UNSET_UINT;
  3701.     clcf->lingering_time = NGX_CONF_UNSET_MSEC;
  3702.     clcf->lingering_timeout = NGX_CONF_UNSET_MSEC;
  3703.     clcf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  3704.     clcf->reset_timedout_connection = NGX_CONF_UNSET;
  3705.     clcf->absolute_redirect = NGX_CONF_UNSET;
  3706.     clcf->server_name_in_redirect = NGX_CONF_UNSET;
  3707.     clcf->port_in_redirect = NGX_CONF_UNSET;
  3708.     clcf->msie_padding = NGX_CONF_UNSET;
  3709.     clcf->msie_refresh = NGX_CONF_UNSET;
  3710.     clcf->log_not_found = NGX_CONF_UNSET;
  3711.     clcf->log_subrequest = NGX_CONF_UNSET;
  3712.     clcf->recursive_error_pages = NGX_CONF_UNSET;
  3713.     clcf->chunked_transfer_encoding = NGX_CONF_UNSET;
  3714.     clcf->etag = NGX_CONF_UNSET;
  3715.     clcf->server_tokens = NGX_CONF_UNSET_UINT;
  3716.     clcf->early_hints = NGX_CONF_UNSET_PTR;
  3717.     clcf->types_hash_max_size = NGX_CONF_UNSET_UINT;
  3718.     clcf->types_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3720.     clcf->open_file_cache = NGX_CONF_UNSET_PTR;
  3721.     clcf->open_file_cache_valid = NGX_CONF_UNSET;
  3722.     clcf->open_file_cache_min_uses = NGX_CONF_UNSET_UINT;
  3723.     clcf->open_file_cache_errors = NGX_CONF_UNSET;
  3724.     clcf->open_file_cache_events = NGX_CONF_UNSET;

  3726. #if (NGX_HTTP_GZIP)
  3727.     clcf->gzip_vary = NGX_CONF_UNSET;
  3728.     clcf->gzip_http_version = NGX_CONF_UNSET_UINT;
  3729. #if (NGX_PCRE)
  3730.     clcf->gzip_disable = NGX_CONF_UNSET_PTR;
  3731. #endif
  3732.     clcf->gzip_disable_msie6 = 3;
  3733. #if (NGX_HTTP_DEGRADATION)
  3734.     clcf->gzip_disable_degradation = 3;
  3735. #endif
  3736. #endif

  3738. #if (NGX_HAVE_OPENAT)
  3739.     clcf->disable_symlinks = NGX_CONF_UNSET_UINT;
  3740.     clcf->disable_symlinks_from = NGX_CONF_UNSET_PTR;
  3741. #endif

  3743.     return clcf;
  3744. }


  3747. ‌static ngx_str_t  ngx_http_core_text_html_type = ngx_string("text/html");
  3748. ‌static ngx_str_t  ngx_http_core_image_gif_type = ngx_string("image/gif");
  3749. ‌static ngx_str_t  ngx_http_core_image_jpeg_type = ngx_string("image/jpeg");

  3751. ‌static ngx_hash_key_t  ngx_http_core_default_types[] = {
  3752.     { ngx_string("html"), 0, &ngx_http_core_text_html_type },
  3753.     { ngx_string("gif"), 0, &ngx_http_core_image_gif_type },
  3754.     { ngx_string("jpg"), 0, &ngx_http_core_image_jpeg_type },
  3755.     { ngx_null_string, 0, NULL }
  3756. };


  3759. static char *
  3760. ‌ngx_http_core_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  3761. {
  3762.     ngx_http_core_loc_conf_t *prev = parent;
  3763.     ngx_http_core_loc_conf_t *conf = child;

  3765.     ngx_uint_t        i;
  3766.     ngx_hash_key_t   *type;
  3767.     ngx_hash_init_t   types_hash;

  3769.     if (conf->root.data == NULL) {

  3771.         conf->alias = prev->alias;
  3772.         conf->root = prev->root;
  3773.         conf->root_lengths = prev->root_lengths;
  3774.         conf->root_values = prev->root_values;

  3776.         if (prev->root.data == NULL) {
  3777.             ngx_str_set(&conf->root, "html");

  3779.             if (ngx_conf_full_name(cf->cycle, &conf->root, 0) != NGX_OK) {
  3780.                 return NGX_CONF_ERROR;
  3781.             }
  3782.         }
  3783.     }

  3785.     if (conf->post_action.data == NULL) {
  3786.         conf->post_action = prev->post_action;
  3787.     }

  3789.     ngx_conf_merge_uint_value(conf->types_hash_max_size,
  3790.                               prev->types_hash_max_size, 1024);

  3792.     ngx_conf_merge_uint_value(conf->types_hash_bucket_size,
  3793.                               prev->types_hash_bucket_size, 64);

  3795.     conf->types_hash_bucket_size = ngx_align(conf->types_hash_bucket_size,
  3796.                                              ngx_cacheline_size);

  3798.     /*
  3799.      * the special handling of the "types" directive in the "http" section
  3800.      * to inherit the http's conf->types_hash to all servers
  3801.      */

  3803.     if (prev->types && prev->types_hash.buckets == NULL) {

  3805.         types_hash.hash = &prev->types_hash;
  3806.         types_hash.key = ngx_hash_key_lc;
  3807.         types_hash.max_size = conf->types_hash_max_size;
  3808.         types_hash.bucket_size = conf->types_hash_bucket_size;
  3809.         types_hash.name = "types_hash";
  3810.         types_hash.pool = cf->pool;
  3811.         types_hash.temp_pool = NULL;

  3813.         if (ngx_hash_init(&types_hash, prev->types->elts, prev->types->nelts)
  3814.             != NGX_OK)
  3815.         {
  3816.             return NGX_CONF_ERROR;
  3817.         }
  3818.     }

  3820.     if (conf->types == NULL) {
  3821.         conf->types = prev->types;
  3822.         conf->types_hash = prev->types_hash;
  3823.     }

  3825.     if (conf->types == NULL) {
  3826.         conf->types = ngx_array_create(cf->pool, 3, sizeof(ngx_hash_key_t));
  3827.         if (conf->types == NULL) {
  3828.             return NGX_CONF_ERROR;
  3829.         }

  3831.         for (i = 0; ngx_http_core_default_types[i].key.len; i++) {
  3832.             type = ngx_array_push(conf->types);
  3833.             if (type == NULL) {
  3834.                 return NGX_CONF_ERROR;
  3835.             }

  3837.             type->key = ngx_http_core_default_types[i].key;
  3838.             type->key_hash =
  3839.                        ngx_hash_key_lc(ngx_http_core_default_types[i].key.data,
  3840.                                        ngx_http_core_default_types[i].key.len);
  3841.             type->value = ngx_http_core_default_types[i].value;
  3842.         }
  3843.     }

  3845.     if (conf->types_hash.buckets == NULL) {

  3847.         types_hash.hash = &conf->types_hash;
  3848.         types_hash.key = ngx_hash_key_lc;
  3849.         types_hash.max_size = conf->types_hash_max_size;
  3850.         types_hash.bucket_size = conf->types_hash_bucket_size;
  3851.         types_hash.name = "types_hash";
  3852.         types_hash.pool = cf->pool;
  3853.         types_hash.temp_pool = NULL;

  3855.         if (ngx_hash_init(&types_hash, conf->types->elts, conf->types->nelts)
  3856.             != NGX_OK)
  3857.         {
  3858.             return NGX_CONF_ERROR;
  3859.         }
  3860.     }

  3862.     if (conf->error_log == NULL) {
  3863.         if (prev->error_log) {
  3864.             conf->error_log = prev->error_log;
  3865.         } else {
  3866.             conf->error_log = &cf->cycle->new_log;
  3867.         }
  3868.     }

  3870.     if (conf->error_pages == NULL && prev->error_pages) {
  3871.         conf->error_pages = prev->error_pages;
  3872.     }

  3874.     ngx_conf_merge_str_value(conf->default_type,
  3875.                               prev->default_type, "text/plain");

  3877.     ngx_conf_merge_off_value(conf->client_max_body_size,
  3878.                               prev->client_max_body_size, 1 * 1024 * 1024);
  3879.     ngx_conf_merge_size_value(conf->client_body_buffer_size,
  3880.                               prev->client_body_buffer_size,
  3881.                               (size_t) 2 * ngx_pagesize);
  3882.     ngx_conf_merge_msec_value(conf->client_body_timeout,
  3883.                               prev->client_body_timeout, 60000);

  3885.     ngx_conf_merge_bitmask_value(conf->keepalive_disable,
  3886.                               prev->keepalive_disable,
  3887.                               (NGX_CONF_BITMASK_SET
  3888.                                |NGX_HTTP_KEEPALIVE_DISABLE_MSIE6));
  3889.     ngx_conf_merge_uint_value(conf->satisfy, prev->satisfy,
  3890.                               NGX_HTTP_SATISFY_ALL);
  3891.     ngx_conf_merge_msec_value(conf->auth_delay, prev->auth_delay, 0);
  3892.     ngx_conf_merge_uint_value(conf->if_modified_since, prev->if_modified_since,
  3893.                               NGX_HTTP_IMS_EXACT);
  3894.     ngx_conf_merge_uint_value(conf->max_ranges, prev->max_ranges,
  3895.                               NGX_MAX_INT32_VALUE);
  3896.     ngx_conf_merge_uint_value(conf->client_body_in_file_only,
  3897.                               prev->client_body_in_file_only,
  3898.                               NGX_HTTP_REQUEST_BODY_FILE_OFF);
  3899.     ngx_conf_merge_value(conf->client_body_in_single_buffer,
  3900.                               prev->client_body_in_single_buffer, 0);
  3901.     ngx_conf_merge_value(conf->internal, prev->internal, 0);
  3902.     ngx_conf_merge_value(conf->sendfile, prev->sendfile, 0);
  3903.     ngx_conf_merge_size_value(conf->sendfile_max_chunk,
  3904.                               prev->sendfile_max_chunk, 2 * 1024 * 1024);
  3905.     ngx_conf_merge_size_value(conf->subrequest_output_buffer_size,
  3906.                               prev->subrequest_output_buffer_size,
  3907.                               (size_t) ngx_pagesize);
  3908.     ngx_conf_merge_value(conf->aio, prev->aio, NGX_HTTP_AIO_OFF);
  3909.     ngx_conf_merge_value(conf->aio_write, prev->aio_write, 0);
  3910. #if (NGX_THREADS)
  3911.     ngx_conf_merge_ptr_value(conf->thread_pool, prev->thread_pool, NULL);
  3912.     ngx_conf_merge_ptr_value(conf->thread_pool_value, prev->thread_pool_value,
  3913.                              NULL);
  3914. #endif
  3915.     ngx_conf_merge_size_value(conf->read_ahead, prev->read_ahead, 0);
  3916.     ngx_conf_merge_off_value(conf->directio, prev->directio,
  3917.                               NGX_OPEN_FILE_DIRECTIO_OFF);
  3918.     ngx_conf_merge_off_value(conf->directio_alignment, prev->directio_alignment,
  3919.                               512);
  3920.     ngx_conf_merge_value(conf->tcp_nopush, prev->tcp_nopush, 0);
  3921.     ngx_conf_merge_value(conf->tcp_nodelay, prev->tcp_nodelay, 1);

  3923.     ngx_conf_merge_msec_value(conf->send_timeout, prev->send_timeout, 60000);
  3924.     ngx_conf_merge_size_value(conf->send_lowat, prev->send_lowat, 0);
  3925.     ngx_conf_merge_size_value(conf->postpone_output, prev->postpone_output,
  3926.                               1460);

  3928.     ngx_conf_merge_ptr_value(conf->limit_rate, prev->limit_rate, NULL);
  3929.     ngx_conf_merge_ptr_value(conf->limit_rate_after,
  3930.                               prev->limit_rate_after, NULL);

  3932.     ngx_conf_merge_msec_value(conf->keepalive_time,
  3933.                               prev->keepalive_time, 3600000);
  3934.     ngx_conf_merge_msec_value(conf->keepalive_timeout,
  3935.                               prev->keepalive_timeout, 75000);
  3936.     ngx_conf_merge_sec_value(conf->keepalive_header,
  3937.                               prev->keepalive_header, 0);
  3938.     ngx_conf_merge_msec_value(conf->keepalive_min_timeout,
  3939.                               prev->keepalive_min_timeout, 0);
  3940.     ngx_conf_merge_uint_value(conf->keepalive_requests,
  3941.                               prev->keepalive_requests, 1000);
  3942.     ngx_conf_merge_uint_value(conf->lingering_close,
  3943.                               prev->lingering_close, NGX_HTTP_LINGERING_ON);
  3944.     ngx_conf_merge_msec_value(conf->lingering_time,
  3945.                               prev->lingering_time, 30000);
  3946.     ngx_conf_merge_msec_value(conf->lingering_timeout,
  3947.                               prev->lingering_timeout, 5000);
  3948.     ngx_conf_merge_msec_value(conf->resolver_timeout,
  3949.                               prev->resolver_timeout, 30000);

  3951.     if (conf->resolver == NULL) {

  3953.         if (prev->resolver == NULL) {

  3955.             /*
  3956.              * create dummy resolver in http {} context
  3957.              * to inherit it in all servers
  3958.              */

  3960.             prev->resolver = ngx_resolver_create(cf, NULL, 0);
  3961.             if (prev->resolver == NULL) {
  3962.                 return NGX_CONF_ERROR;
  3963.             }
  3964.         }

  3966.         conf->resolver = prev->resolver;
  3967.     }

  3969.     if (ngx_conf_merge_path_value(cf, &conf->client_body_temp_path,
  3970.                               prev->client_body_temp_path,
  3971.                               &ngx_http_client_temp_path)
  3972.         != NGX_CONF_OK)
  3973.     {
  3974.         return NGX_CONF_ERROR;
  3975.     }

  3977.     ngx_conf_merge_value(conf->reset_timedout_connection,
  3978.                               prev->reset_timedout_connection, 0);
  3979.     ngx_conf_merge_value(conf->absolute_redirect,
  3980.                               prev->absolute_redirect, 1);
  3981.     ngx_conf_merge_value(conf->server_name_in_redirect,
  3982.                               prev->server_name_in_redirect, 0);
  3983.     ngx_conf_merge_value(conf->port_in_redirect, prev->port_in_redirect, 1);
  3984.     ngx_conf_merge_value(conf->msie_padding, prev->msie_padding, 1);
  3985.     ngx_conf_merge_value(conf->msie_refresh, prev->msie_refresh, 0);
  3986.     ngx_conf_merge_value(conf->log_not_found, prev->log_not_found, 1);
  3987.     ngx_conf_merge_value(conf->log_subrequest, prev->log_subrequest, 0);
  3988.     ngx_conf_merge_value(conf->recursive_error_pages,
  3989.                               prev->recursive_error_pages, 0);
  3990.     ngx_conf_merge_value(conf->chunked_transfer_encoding,
  3991.                               prev->chunked_transfer_encoding, 1);
  3992.     ngx_conf_merge_value(conf->etag, prev->etag, 1);

  3994.     ngx_conf_merge_uint_value(conf->server_tokens, prev->server_tokens,
  3995.                               NGX_HTTP_SERVER_TOKENS_ON);

  3997.     ngx_conf_merge_ptr_value(conf->early_hints, prev->early_hints, NULL);

  3999.     ngx_conf_merge_ptr_value(conf->open_file_cache,
  4000.                               prev->open_file_cache, NULL);

  4002.     ngx_conf_merge_sec_value(conf->open_file_cache_valid,
  4003.                               prev->open_file_cache_valid, 60);

  4005.     ngx_conf_merge_uint_value(conf->open_file_cache_min_uses,
  4006.                               prev->open_file_cache_min_uses, 1);

  4008.     ngx_conf_merge_sec_value(conf->open_file_cache_errors,
  4009.                               prev->open_file_cache_errors, 0);

  4011.     ngx_conf_merge_sec_value(conf->open_file_cache_events,
  4012.                               prev->open_file_cache_events, 0);
  4013. #if (NGX_HTTP_GZIP)

  4015.     ngx_conf_merge_value(conf->gzip_vary, prev->gzip_vary, 0);
  4016.     ngx_conf_merge_uint_value(conf->gzip_http_version, prev->gzip_http_version,
  4017.                               NGX_HTTP_VERSION_11);
  4018.     ngx_conf_merge_bitmask_value(conf->gzip_proxied, prev->gzip_proxied,
  4019.                               (NGX_CONF_BITMASK_SET|NGX_HTTP_GZIP_PROXIED_OFF));

  4021. #if (NGX_PCRE)
  4022.     ngx_conf_merge_ptr_value(conf->gzip_disable, prev->gzip_disable, NULL);
  4023. #endif

  4025.     if (conf->gzip_disable_msie6 == 3) {
  4026.         conf->gzip_disable_msie6 =
  4027.             (prev->gzip_disable_msie6 == 3) ? 0 : prev->gzip_disable_msie6;
  4028.     }

  4030. #if (NGX_HTTP_DEGRADATION)

  4032.     if (conf->gzip_disable_degradation == 3) {
  4033.         conf->gzip_disable_degradation =
  4034.             (prev->gzip_disable_degradation == 3) ?
  4035.                  0 : prev->gzip_disable_degradation;
  4036.     }

  4038. #endif
  4039. #endif

  4041. #if (NGX_HAVE_OPENAT)
  4042.     ngx_conf_merge_uint_value(conf->disable_symlinks, prev->disable_symlinks,
  4043.                               NGX_DISABLE_SYMLINKS_OFF);
  4044.     ngx_conf_merge_ptr_value(conf->disable_symlinks_from,
  4045.                              prev->disable_symlinks_from, NULL);
  4046. #endif

  4048.     return NGX_CONF_OK;
  4049. }


  4052. static char *
  4053. ‌ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4054. {
  4055.     ngx_http_core_srv_conf_t *cscf = conf;

  4057.     ngx_str_t              *value, size;
  4058.     ngx_url_t               u;
  4059.     ngx_uint_t              n, i, backlog;
  4060.     ngx_http_listen_opt_t   lsopt;

  4062.     cscf->listen = 1;

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

  4066.     ngx_memzero(&u, sizeof(ngx_url_t));

  4068.     u.url = value[1];
  4069.     u.listen = 1;
  4070.     u.default_port = 80;

  4072.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  4073.         if (u.err) {
  4074.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4075.                                "%s in \"%V\" of the \"listen\" directive",
  4076.                                u.err, &u.url);
  4077.         }

  4079.         return NGX_CONF_ERROR;
  4080.     }

  4082.     ngx_memzero(&lsopt, sizeof(ngx_http_listen_opt_t));

  4084.     lsopt.backlog = NGX_LISTEN_BACKLOG;
  4085.     lsopt.type = SOCK_STREAM;
  4086.     lsopt.rcvbuf = -1;
  4087.     lsopt.sndbuf = -1;
  4088. #if (NGX_HAVE_SETFIB)
  4089.     lsopt.setfib = -1;
  4090. #endif
  4091. #if (NGX_HAVE_TCP_FASTOPEN)
  4092.     lsopt.fastopen = -1;
  4093. #endif
  4094. #if (NGX_HAVE_INET6)
  4095.     lsopt.ipv6only = 1;
  4096. #endif

  4098.     backlog = 0;

  4100.     for (n = 2; n < cf->args->nelts; n++) {

  4102.         if (ngx_strcmp(value[n].data, "default_server") == 0
  4103.             || ngx_strcmp(value[n].data, "default") == 0)
  4104.         {
  4105.             lsopt.default_server = 1;
  4106.             continue;
  4107.         }

  4109.         if (ngx_strcmp(value[n].data, "bind") == 0) {
  4110.             lsopt.set = 1;
  4111.             lsopt.bind = 1;
  4112.             continue;
  4113.         }

  4115. #if (NGX_HAVE_SETFIB)
  4116.         if (ngx_strncmp(value[n].data, "setfib=", 7) == 0) {
  4117.             lsopt.setfib = ngx_atoi(value[n].data + 7, value[n].len - 7);
  4118.             lsopt.set = 1;
  4119.             lsopt.bind = 1;

  4121.             if (lsopt.setfib == NGX_ERROR) {
  4122.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4123.                                    "invalid setfib \"%V\"", &value[n]);
  4124.                 return NGX_CONF_ERROR;
  4125.             }

  4127.             continue;
  4128.         }
  4129. #endif

  4131. #if (NGX_HAVE_TCP_FASTOPEN)
  4132.         if (ngx_strncmp(value[n].data, "fastopen=", 9) == 0) {
  4133.             lsopt.fastopen = ngx_atoi(value[n].data + 9, value[n].len - 9);
  4134.             lsopt.set = 1;
  4135.             lsopt.bind = 1;

  4137.             if (lsopt.fastopen == NGX_ERROR) {
  4138.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4139.                                    "invalid fastopen \"%V\"", &value[n]);
  4140.                 return NGX_CONF_ERROR;
  4141.             }

  4143.             continue;
  4144.         }
  4145. #endif

  4147.         if (ngx_strncmp(value[n].data, "backlog=", 8) == 0) {
  4148.             lsopt.backlog = ngx_atoi(value[n].data + 8, value[n].len - 8);
  4149.             lsopt.set = 1;
  4150.             lsopt.bind = 1;

  4152.             if (lsopt.backlog == NGX_ERROR || lsopt.backlog == 0) {
  4153.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4154.                                    "invalid backlog \"%V\"", &value[n]);
  4155.                 return NGX_CONF_ERROR;
  4156.             }

  4158.             backlog = 1;

  4160.             continue;
  4161.         }

  4163.         if (ngx_strncmp(value[n].data, "rcvbuf=", 7) == 0) {
  4164.             size.len = value[n].len - 7;
  4165.             size.data = value[n].data + 7;

  4167.             lsopt.rcvbuf = ngx_parse_size(&size);
  4168.             lsopt.set = 1;
  4169.             lsopt.bind = 1;

  4171.             if (lsopt.rcvbuf == NGX_ERROR) {
  4172.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4173.                                    "invalid rcvbuf \"%V\"", &value[n]);
  4174.                 return NGX_CONF_ERROR;
  4175.             }

  4177.             continue;
  4178.         }

  4180.         if (ngx_strncmp(value[n].data, "sndbuf=", 7) == 0) {
  4181.             size.len = value[n].len - 7;
  4182.             size.data = value[n].data + 7;

  4184.             lsopt.sndbuf = ngx_parse_size(&size);
  4185.             lsopt.set = 1;
  4186.             lsopt.bind = 1;

  4188.             if (lsopt.sndbuf == NGX_ERROR) {
  4189.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4190.                                    "invalid sndbuf \"%V\"", &value[n]);
  4191.                 return NGX_CONF_ERROR;
  4192.             }

  4194.             continue;
  4195.         }

  4197.         if (ngx_strncmp(value[n].data, "accept_filter=", 14) == 0) {
  4198. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  4199.             lsopt.accept_filter = (char *) &value[n].data[14];
  4200.             lsopt.set = 1;
  4201.             lsopt.bind = 1;
  4202. #else
  4203.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4204.                                "accept filters \"%V\" are not supported "
  4205.                                "on this platform, ignored",
  4206.                                &value[n]);
  4207. #endif
  4208.             continue;
  4209.         }

  4211.         if (ngx_strcmp(value[n].data, "deferred") == 0) {
  4212. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  4213.             lsopt.deferred_accept = 1;
  4214.             lsopt.set = 1;
  4215.             lsopt.bind = 1;
  4216. #else
  4217.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4218.                                "the deferred accept is not supported "
  4219.                                "on this platform, ignored");
  4220. #endif
  4221.             continue;
  4222.         }

  4224.         if (ngx_strncmp(value[n].data, "ipv6only=o", 10) == 0) {
  4225. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  4226.             if (ngx_strcmp(&value[n].data[10], "n") == 0) {
  4227.                 lsopt.ipv6only = 1;

  4229.             } else if (ngx_strcmp(&value[n].data[10], "ff") == 0) {
  4230.                 lsopt.ipv6only = 0;

  4232.             } else {
  4233.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4234.                                    "invalid ipv6only flags \"%s\"",
  4235.                                    &value[n].data[9]);
  4236.                 return NGX_CONF_ERROR;
  4237.             }

  4239.             lsopt.set = 1;
  4240.             lsopt.bind = 1;

  4242.             continue;
  4243. #else
  4244.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4245.                                "ipv6only is not supported "
  4246.                                "on this platform");
  4247.             return NGX_CONF_ERROR;
  4248. #endif
  4249.         }

  4251.         if (ngx_strcmp(value[n].data, "reuseport") == 0) {
  4252. #if (NGX_HAVE_REUSEPORT)
  4253.             lsopt.reuseport = 1;
  4254.             lsopt.set = 1;
  4255.             lsopt.bind = 1;
  4256. #else
  4257.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4258.                                "reuseport is not supported "
  4259.                                "on this platform, ignored");
  4260. #endif
  4261.             continue;
  4262.         }

  4264.         if (ngx_strcmp(value[n].data, "multipath") == 0) {
  4265. #ifdef IPPROTO_MPTCP
  4266.             lsopt.protocol = IPPROTO_MPTCP;
  4267.             lsopt.set = 1;
  4268.             lsopt.bind = 1;
  4269. #else
  4270.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4271.                                "multipath is not supported "
  4272.                                "on this platform, ignored");
  4273. #endif
  4274.             continue;
  4275.         }

  4277.         if (ngx_strcmp(value[n].data, "ssl") == 0) {
  4278. #if (NGX_HTTP_SSL)
  4279.             lsopt.ssl = 1;
  4280.             continue;
  4281. #else
  4282.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4283.                                "the \"ssl\" parameter requires "
  4284.                                "ngx_http_ssl_module");
  4285.             return NGX_CONF_ERROR;
  4286. #endif
  4287.         }

  4289.         if (ngx_strcmp(value[n].data, "http2") == 0) {
  4290. #if (NGX_HTTP_V2)
  4291.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  4292.                                "the \"listen ... http2\" directive "
  4293.                                "is deprecated, use "
  4294.                                "the \"http2\" directive instead");

  4296.             lsopt.http2 = 1;
  4297.             continue;
  4298. #else
  4299.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4300.                                "the \"http2\" parameter requires "
  4301.                                "ngx_http_v2_module");
  4302.             return NGX_CONF_ERROR;
  4303. #endif
  4304.         }

  4306.         if (ngx_strcmp(value[n].data, "quic") == 0) {
  4307. #if (NGX_HTTP_V3)
  4308.             lsopt.quic = 1;
  4309.             lsopt.type = SOCK_DGRAM;
  4310.             continue;
  4311. #else
  4312.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4313.                                "the \"quic\" parameter requires "
  4314.                                "ngx_http_v3_module");
  4315.             return NGX_CONF_ERROR;
  4316. #endif
  4317.         }

  4319.         if (ngx_strncmp(value[n].data, "so_keepalive=", 13) == 0) {

  4321.             if (ngx_strcmp(&value[n].data[13], "on") == 0) {
  4322.                 lsopt.so_keepalive = 1;

  4324.             } else if (ngx_strcmp(&value[n].data[13], "off") == 0) {
  4325.                 lsopt.so_keepalive = 2;

  4327.             } else {

  4329. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  4330.                 u_char     *p, *end;
  4331.                 ngx_str_t   s;

  4333.                 end = value[n].data + value[n].len;
  4334.                 s.data = value[n].data + 13;

  4336.                 p = ngx_strlchr(s.data, end, ':');
  4337.                 if (p == NULL) {
  4338.                     p = end;
  4339.                 }

  4341.                 if (p > s.data) {
  4342.                     s.len = p - s.data;

  4344.                     lsopt.tcp_keepidle = ngx_parse_time(&s, 1);
  4345.                     if (lsopt.tcp_keepidle == (time_t) NGX_ERROR) {
  4346.                         goto invalid_so_keepalive;
  4347.                     }
  4348.                 }

  4350.                 s.data = (p < end) ? (p + 1) : end;

  4352.                 p = ngx_strlchr(s.data, end, ':');
  4353.                 if (p == NULL) {
  4354.                     p = end;
  4355.                 }

  4357.                 if (p > s.data) {
  4358.                     s.len = p - s.data;

  4360.                     lsopt.tcp_keepintvl = ngx_parse_time(&s, 1);
  4361.                     if (lsopt.tcp_keepintvl == (time_t) NGX_ERROR) {
  4362.                         goto invalid_so_keepalive;
  4363.                     }
  4364.                 }

  4366.                 s.data = (p < end) ? (p + 1) : end;

  4368.                 if (s.data < end) {
  4369.                     s.len = end - s.data;

  4371.                     lsopt.tcp_keepcnt = ngx_atoi(s.data, s.len);
  4372.                     if (lsopt.tcp_keepcnt == NGX_ERROR) {
  4373.                         goto invalid_so_keepalive;
  4374.                     }
  4375.                 }

  4377.                 if (lsopt.tcp_keepidle == 0 && lsopt.tcp_keepintvl == 0
  4378.                     && lsopt.tcp_keepcnt == 0)
  4379.                 {
  4380.                     goto invalid_so_keepalive;
  4381.                 }

  4383.                 lsopt.so_keepalive = 1;

  4385. #else

  4387.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4388.                                    "the \"so_keepalive\" parameter accepts "
  4389.                                    "only \"on\" or \"off\" on this platform");
  4390.                 return NGX_CONF_ERROR;

  4392. #endif
  4393.             }

  4395.             lsopt.set = 1;
  4396.             lsopt.bind = 1;

  4398.             continue;

  4400. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  4401.         invalid_so_keepalive:

  4403.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4404.                                "invalid so_keepalive value: \"%s\"",
  4405.                                &value[n].data[13]);
  4406.             return NGX_CONF_ERROR;
  4407. #endif
  4408.         }

  4410.         if (ngx_strcmp(value[n].data, "proxy_protocol") == 0) {
  4411.             lsopt.proxy_protocol = 1;
  4412.             continue;
  4413.         }

  4415.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4416.                            "invalid parameter \"%V\"", &value[n]);
  4417.         return NGX_CONF_ERROR;
  4418.     }

  4420.     if (lsopt.quic) {
  4421. #if (NGX_HAVE_TCP_FASTOPEN)
  4422.         if (lsopt.fastopen != -1) {
  4423.             return "\"fastopen\" parameter is incompatible with \"quic\"";
  4424.         }
  4425. #endif

  4427.         if (backlog) {
  4428.             return "\"backlog\" parameter is incompatible with \"quic\"";
  4429.         }

  4431. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  4432.         if (lsopt.accept_filter) {
  4433.             return "\"accept_filter\" parameter is incompatible with \"quic\"";
  4434.         }
  4435. #endif

  4437. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  4438.         if (lsopt.deferred_accept) {
  4439.             return "\"deferred\" parameter is incompatible with \"quic\"";
  4440.         }
  4441. #endif

  4443. #ifdef IPPROTO_MPTCP
  4444.         if (lsopt.protocol == IPPROTO_MPTCP) {
  4445.              return "\"multipath\" parameter is incompatible with \"quic\"";
  4446.         }
  4447. #endif

  4449. #if (NGX_HTTP_SSL)
  4450.         if (lsopt.ssl) {
  4451.             return "\"ssl\" parameter is incompatible with \"quic\"";
  4452.         }
  4453. #endif

  4455. #if (NGX_HTTP_V2)
  4456.         if (lsopt.http2) {
  4457.             return "\"http2\" parameter is incompatible with \"quic\"";
  4458.         }
  4459. #endif

  4461.         if (lsopt.so_keepalive) {
  4462.             return "\"so_keepalive\" parameter is incompatible with \"quic\"";
  4463.         }

  4465.         if (lsopt.proxy_protocol) {
  4466.             return "\"proxy_protocol\" parameter is incompatible with \"quic\"";
  4467.         }
  4468.     }

  4470.     for (n = 0; n < u.naddrs; n++) {

  4472.         for (i = 0; i < n; i++) {
  4473.             if (ngx_cmp_sockaddr(u.addrs[n].sockaddr, u.addrs[n].socklen,
  4474.                                  u.addrs[i].sockaddr, u.addrs[i].socklen, 1)
  4475.                 == NGX_OK)
  4476.             {
  4477.                 goto next;
  4478.             }
  4479.         }

  4481.         lsopt.sockaddr = u.addrs[n].sockaddr;
  4482.         lsopt.socklen = u.addrs[n].socklen;
  4483.         lsopt.addr_text = u.addrs[n].name;
  4484.         lsopt.wildcard = ngx_inet_wildcard(lsopt.sockaddr);

  4486.         if (ngx_http_add_listen(cf, cscf, &lsopt) != NGX_OK) {
  4487.             return NGX_CONF_ERROR;
  4488.         }

  4490.     next:
  4491.         continue;
  4492.     }

  4494.     return NGX_CONF_OK;
  4495. }


  4498. static char *
  4499. ‌ngx_http_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4500. {
  4501.     ngx_http_core_srv_conf_t *cscf = conf;

  4503.     u_char                   ch;
  4504.     ngx_str_t               *value;
  4505.     ngx_uint_t               i;
  4506.     ngx_http_server_name_t  *sn;

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

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

  4512.         ch = value[i].data[0];

  4514.         if ((ch == '*' && (value[i].len < 3 || value[i].data[1] != '.'))
  4515.             || (ch == '.' && value[i].len < 2))
  4516.         {
  4517.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4518.                                "server name \"%V\" is invalid", &value[i]);
  4519.             return NGX_CONF_ERROR;
  4520.         }

  4522.         if (ngx_strchr(value[i].data, '/')) {
  4523.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  4524.                                "server name \"%V\" has suspicious symbols",
  4525.                                &value[i]);
  4526.         }

  4528.         sn = ngx_array_push(&cscf->server_names);
  4529.         if (sn == NULL) {
  4530.             return NGX_CONF_ERROR;
  4531.         }

  4533. #if (NGX_PCRE)
  4534.         sn->regex = NULL;
  4535. #endif
  4536.         sn->server = cscf;

  4538.         if (ngx_strcasecmp(value[i].data, (u_char *) "$hostname") == 0) {
  4539.             sn->name = cf->cycle->hostname;

  4541.         } else {
  4542.             sn->name = value[i];
  4543.         }

  4545.         if (value[i].data[0] != '~') {
  4546.             ngx_strlow(sn->name.data, sn->name.data, sn->name.len);
  4547.             continue;
  4548.         }

  4550. #if (NGX_PCRE)
  4551.         {
  4552.         u_char               *p;
  4553.         ngx_regex_compile_t   rc;
  4554.         u_char                errstr[NGX_MAX_CONF_ERRSTR];

  4556.         if (value[i].len == 1) {
  4557.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4558.                                "empty regex in server name \"%V\"", &value[i]);
  4559.             return NGX_CONF_ERROR;
  4560.         }

  4562.         value[i].len--;
  4563.         value[i].data++;

  4565.         ngx_memzero(&rc, sizeof(ngx_regex_compile_t));

  4567.         rc.pattern = value[i];
  4568.         rc.err.len = NGX_MAX_CONF_ERRSTR;
  4569.         rc.err.data = errstr;

  4571.         for (p = value[i].data; p < value[i].data + value[i].len; p++) {
  4572.             if (*p >= 'A' && *p <= 'Z') {
  4573.                 rc.options = NGX_REGEX_CASELESS;
  4574.                 break;
  4575.             }
  4576.         }

  4578.         sn->regex = ngx_http_regex_compile(cf, &rc);
  4579.         if (sn->regex == NULL) {
  4580.             return NGX_CONF_ERROR;
  4581.         }

  4583.         sn->name = value[i];
  4584.         cscf->captures = (rc.captures > 0);
  4585.         }
  4586. #else
  4587.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4588.                            "using regex \"%V\" "
  4589.                            "requires PCRE library", &value[i]);

  4591.         return NGX_CONF_ERROR;
  4592. #endif
  4593.     }

  4595.     return NGX_CONF_OK;
  4596. }


  4599. static char *
  4600. ‌ngx_http_core_root(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4601. {
  4602.     ngx_http_core_loc_conf_t *clcf = conf;

  4604.     ngx_str_t                  *value;
  4605.     ngx_int_t                   alias;
  4606.     ngx_uint_t                  n;
  4607.     ngx_http_script_compile_t   sc;

  4609.     alias = (cmd->name.len == sizeof("alias") - 1) ? 1 : 0;

  4611.     if (clcf->root.data) {

  4613.         if ((clcf->alias != 0) == alias) {
  4614.             return "is duplicate";
  4615.         }

  4617.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4618.                            "\"%V\" directive is duplicate, "
  4619.                            "\"%s\" directive was specified earlier",
  4620.                            &cmd->name, clcf->alias ? "alias" : "root");

  4622.         return NGX_CONF_ERROR;
  4623.     }

  4625.     if (clcf->named && alias) {
  4626.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4627.                            "the \"alias\" directive cannot be used "
  4628.                            "inside the named location");

  4630.         return NGX_CONF_ERROR;
  4631.     }

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

  4635.     if (ngx_strstr(value[1].data, "$document_root")
  4636.         || ngx_strstr(value[1].data, "${document_root}"))
  4637.     {
  4638.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4639.                            "the $document_root variable cannot be used "
  4640.                            "in the \"%V\" directive",
  4641.                            &cmd->name);

  4643.         return NGX_CONF_ERROR;
  4644.     }

  4646.     if (ngx_strstr(value[1].data, "$realpath_root")
  4647.         || ngx_strstr(value[1].data, "${realpath_root}"))
  4648.     {
  4649.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4650.                            "the $realpath_root variable cannot be used "
  4651.                            "in the \"%V\" directive",
  4652.                            &cmd->name);

  4654.         return NGX_CONF_ERROR;
  4655.     }

  4657.     clcf->alias = alias ? clcf->name.len : 0;
  4658.     clcf->root = value[1];

  4660.     if (!alias && clcf->root.len > 0
  4661.         && clcf->root.data[clcf->root.len - 1] == '/')
  4662.     {
  4663.         clcf->root.len--;
  4664.     }

  4666.     if (clcf->root.data[0] != '$') {
  4667.         if (ngx_conf_full_name(cf->cycle, &clcf->root, 0) != NGX_OK) {
  4668.             return NGX_CONF_ERROR;
  4669.         }
  4670.     }

  4672.     n = ngx_http_script_variables_count(&clcf->root);

  4674.     ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
  4675.     sc.variables = n;

  4677. #if (NGX_PCRE)
  4678.     if (alias && clcf->regex) {
  4679.         clcf->alias = NGX_MAX_SIZE_T_VALUE;
  4680.         n = 1;
  4681.     }
  4682. #endif

  4684.     if (n) {
  4685.         sc.cf = cf;
  4686.         sc.source = &clcf->root;
  4687.         sc.lengths = &clcf->root_lengths;
  4688.         sc.values = &clcf->root_values;
  4689.         sc.complete_lengths = 1;
  4690.         sc.complete_values = 1;

  4692.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  4693.             return NGX_CONF_ERROR;
  4694.         }
  4695.     }

  4697.     return NGX_CONF_OK;
  4698. }


  4701. ‌static ngx_http_method_name_t  ngx_methods_names[] = {
  4702.     { (u_char *) "GET",       (uint32_t) ~NGX_HTTP_GET },
  4703.     { (u_char *) "HEAD",      (uint32_t) ~NGX_HTTP_HEAD },
  4704.     { (u_char *) "POST",      (uint32_t) ~NGX_HTTP_POST },
  4705.     { (u_char *) "PUT",       (uint32_t) ~NGX_HTTP_PUT },
  4706.     { (u_char *) "DELETE",    (uint32_t) ~NGX_HTTP_DELETE },
  4707.     { (u_char *) "MKCOL",     (uint32_t) ~NGX_HTTP_MKCOL },
  4708.     { (u_char *) "COPY",      (uint32_t) ~NGX_HTTP_COPY },
  4709.     { (u_char *) "MOVE",      (uint32_t) ~NGX_HTTP_MOVE },
  4710.     { (u_char *) "OPTIONS",   (uint32_t) ~NGX_HTTP_OPTIONS },
  4711.     { (u_char *) "PROPFIND",  (uint32_t) ~NGX_HTTP_PROPFIND },
  4712.     { (u_char *) "PROPPATCH", (uint32_t) ~NGX_HTTP_PROPPATCH },
  4713.     { (u_char *) "LOCK",      (uint32_t) ~NGX_HTTP_LOCK },
  4714.     { (u_char *) "UNLOCK",    (uint32_t) ~NGX_HTTP_UNLOCK },
  4715.     { (u_char *) "PATCH",     (uint32_t) ~NGX_HTTP_PATCH },
  4716.     { NULL, 0 }
  4717. };


  4720. static char *
  4721. ‌ngx_http_core_limit_except(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4722. {
  4723.     ngx_http_core_loc_conf_t *pclcf = conf;

  4725.     char                      *rv;
  4726.     void                      *mconf;
  4727.     ngx_str_t                 *value;
  4728.     ngx_uint_t                 i;
  4729.     ngx_conf_t                 save;
  4730.     ngx_http_module_t         *module;
  4731.     ngx_http_conf_ctx_t       *ctx, *pctx;
  4732.     ngx_http_method_name_t    *name;
  4733.     ngx_http_core_loc_conf_t  *clcf;

  4735.     if (pclcf->limit_except) {
  4736.         return "is duplicate";
  4737.     }

  4739.     pclcf->limit_except = 0xffffffff;

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

  4743.     for (i = 1; i < cf->args->nelts; i++) {
  4744.         for (name = ngx_methods_names; name->name; name++) {

  4746.             if (ngx_strcasecmp(value[i].data, name->name) == 0) {
  4747.                 pclcf->limit_except &= name->method;
  4748.                 goto next;
  4749.             }
  4750.         }

  4752.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4753.                            "invalid method \"%V\"", &value[i]);
  4754.         return NGX_CONF_ERROR;

  4756.     next:
  4757.         continue;
  4758.     }

  4760.     if (!(pclcf->limit_except & NGX_HTTP_GET)) {
  4761.         pclcf->limit_except &= (uint32_t) ~NGX_HTTP_HEAD;
  4762.     }

  4764.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  4765.     if (ctx == NULL) {
  4766.         return NGX_CONF_ERROR;
  4767.     }

  4769.     pctx = cf->ctx;
  4770.     ctx->main_conf = pctx->main_conf;
  4771.     ctx->srv_conf = pctx->srv_conf;

  4773.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  4774.     if (ctx->loc_conf == NULL) {
  4775.         return NGX_CONF_ERROR;
  4776.     }

  4778.     for (i = 0; cf->cycle->modules[i]; i++) {
  4779.         if (cf->cycle->modules[i]->type != NGX_HTTP_MODULE) {
  4780.             continue;
  4781.         }

  4783.         module = cf->cycle->modules[i]->ctx;

  4785.         if (module->create_loc_conf) {

  4787.             mconf = module->create_loc_conf(cf);
  4788.             if (mconf == NULL) {
  4789.                 return NGX_CONF_ERROR;
  4790.             }

  4792.             ctx->loc_conf[cf->cycle->modules[i]->ctx_index] = mconf;
  4793.         }
  4794.     }


  4797.     clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
  4798.     pclcf->limit_except_loc_conf = ctx->loc_conf;
  4799.     clcf->loc_conf = ctx->loc_conf;
  4800.     clcf->name = pclcf->name;
  4801.     clcf->noname = 1;
  4802.     clcf->lmt_excpt = 1;

  4804.     if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
  4805.         return NGX_CONF_ERROR;
  4806.     }

  4808.     save = *cf;
  4809.     cf->ctx = ctx;
  4810.     cf->cmd_type = NGX_HTTP_LMT_CONF;

  4812.     rv = ngx_conf_parse(cf, NULL);

  4814.     *cf = save;

  4816.     return rv;
  4817. }


  4820. static char *
  4821. ‌ngx_http_core_set_aio(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4822. {
  4823.     ngx_http_core_loc_conf_t *clcf = conf;

  4825.     ngx_str_t  *value;

  4827.     if (clcf->aio != NGX_CONF_UNSET) {
  4828.         return "is duplicate";
  4829.     }

  4831. #if (NGX_THREADS)
  4832.     clcf->thread_pool = NULL;
  4833.     clcf->thread_pool_value = NULL;
  4834. #endif

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

  4838.     if (ngx_strcmp(value[1].data, "off") == 0) {
  4839.         clcf->aio = NGX_HTTP_AIO_OFF;
  4840.         return NGX_CONF_OK;
  4841.     }

  4843.     if (ngx_strcmp(value[1].data, "on") == 0) {
  4844. #if (NGX_HAVE_FILE_AIO)
  4845.         clcf->aio = NGX_HTTP_AIO_ON;
  4846.         return NGX_CONF_OK;
  4847. #else
  4848.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4849.                            "\"aio on\" "
  4850.                            "is unsupported on this platform");
  4851.         return NGX_CONF_ERROR;
  4852. #endif
  4853.     }

  4855.     if (ngx_strncmp(value[1].data, "threads", 7) == 0
  4856.         && (value[1].len == 7 || value[1].data[7] == '='))
  4857.     {
  4858. #if (NGX_THREADS)
  4859.         ngx_str_t                          name;
  4860.         ngx_thread_pool_t                 *tp;
  4861.         ngx_http_complex_value_t           cv;
  4862.         ngx_http_compile_complex_value_t   ccv;

  4864.         clcf->aio = NGX_HTTP_AIO_THREADS;

  4866.         if (value[1].len >= 8) {
  4867.             name.len = value[1].len - 8;
  4868.             name.data = value[1].data + 8;

  4870.             ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  4872.             ccv.cf = cf;
  4873.             ccv.value = &name;
  4874.             ccv.complex_value = &cv;

  4876.             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  4877.                 return NGX_CONF_ERROR;
  4878.             }

  4880.             if (cv.lengths != NULL) {
  4881.                 clcf->thread_pool_value = ngx_palloc(cf->pool,
  4882.                                     sizeof(ngx_http_complex_value_t));
  4883.                 if (clcf->thread_pool_value == NULL) {
  4884.                     return NGX_CONF_ERROR;
  4885.                 }

  4887.                 *clcf->thread_pool_value = cv;

  4889.                 return NGX_CONF_OK;
  4890.             }

  4892.             tp = ngx_thread_pool_add(cf, &name);

  4894.         } else {
  4895.             tp = ngx_thread_pool_add(cf, NULL);
  4896.         }

  4898.         if (tp == NULL) {
  4899.             return NGX_CONF_ERROR;
  4900.         }

  4902.         clcf->thread_pool = tp;

  4904.         return NGX_CONF_OK;
  4905. #else
  4906.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4907.                            "\"aio threads\" "
  4908.                            "is unsupported on this platform");
  4909.         return NGX_CONF_ERROR;
  4910. #endif
  4911.     }

  4913.     return "invalid value";
  4914. }


  4917. static char *
  4918. ‌ngx_http_core_directio(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4919. {
  4920.     ngx_http_core_loc_conf_t *clcf = conf;

  4922.     ngx_str_t  *value;

  4924.     if (clcf->directio != NGX_CONF_UNSET) {
  4925.         return "is duplicate";
  4926.     }

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

  4930.     if (ngx_strcmp(value[1].data, "off") == 0) {
  4931.         clcf->directio = NGX_OPEN_FILE_DIRECTIO_OFF;
  4932.         return NGX_CONF_OK;
  4933.     }

  4935.     clcf->directio = ngx_parse_offset(&value[1]);
  4936.     if (clcf->directio == (off_t) NGX_ERROR) {
  4937.         return "invalid value";
  4938.     }

  4940.     return NGX_CONF_OK;
  4941. }


  4944. static char *
  4945. ‌ngx_http_core_error_page(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4946. {
  4947.     ngx_http_core_loc_conf_t *clcf = conf;

  4949.     u_char                            *p;
  4950.     ngx_int_t                          overwrite;
  4951.     ngx_str_t                         *value, uri, args;
  4952.     ngx_uint_t                         i, n;
  4953.     ngx_http_err_page_t               *err;
  4954.     ngx_http_complex_value_t           cv;
  4955.     ngx_http_compile_complex_value_t   ccv;

  4957.     if (clcf->error_pages == NULL) {
  4958.         clcf->error_pages = ngx_array_create(cf->pool, 4,
  4959.                                              sizeof(ngx_http_err_page_t));
  4960.         if (clcf->error_pages == NULL) {
  4961.             return NGX_CONF_ERROR;
  4962.         }
  4963.     }

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

  4967.     i = cf->args->nelts - 2;

  4969.     if (value[i].data[0] == '=') {
  4970.         if (i == 1) {
  4971.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4972.                                "invalid value \"%V\"", &value[i]);
  4973.             return NGX_CONF_ERROR;
  4974.         }

  4976.         if (value[i].len > 1) {
  4977.             overwrite = ngx_atoi(&value[i].data[1], value[i].len - 1);

  4979.             if (overwrite == NGX_ERROR) {
  4980.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4981.                                    "invalid value \"%V\"", &value[i]);
  4982.                 return NGX_CONF_ERROR;
  4983.             }

  4985.         } else {
  4986.             overwrite = 0;
  4987.         }

  4989.         n = 2;

  4991.     } else {
  4992.         overwrite = -1;
  4993.         n = 1;
  4994.     }

  4996.     uri = value[cf->args->nelts - 1];

  4998.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  5000.     ccv.cf = cf;
  5001.     ccv.value = &uri;
  5002.     ccv.complex_value = &cv;

  5004.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  5005.         return NGX_CONF_ERROR;
  5006.     }

  5008.     ngx_str_null(&args);

  5010.     if (cv.lengths == NULL && uri.len && uri.data[0] == '/') {
  5011.         p = (u_char *) ngx_strchr(uri.data, '?');

  5013.         if (p) {
  5014.             cv.value.len = p - uri.data;
  5015.             cv.value.data = uri.data;
  5016.             p++;
  5017.             args.len = (uri.data + uri.len) - p;
  5018.             args.data = p;
  5019.         }
  5020.     }

  5022.     for (i = 1; i < cf->args->nelts - n; i++) {
  5023.         err = ngx_array_push(clcf->error_pages);
  5024.         if (err == NULL) {
  5025.             return NGX_CONF_ERROR;
  5026.         }

  5028.         err->status = ngx_atoi(value[i].data, value[i].len);

  5030.         if (err->status == NGX_ERROR || err->status == 499) {
  5031.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5032.                                "invalid value \"%V\"", &value[i]);
  5033.             return NGX_CONF_ERROR;
  5034.         }

  5036.         if (err->status < 300 || err->status > 599) {
  5037.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5038.                                "value \"%V\" must be between 300 and 599",
  5039.                                &value[i]);
  5040.             return NGX_CONF_ERROR;
  5041.         }

  5043.         err->overwrite = overwrite;

  5045.         if (overwrite == -1) {
  5046.             switch (err->status) {
  5047.                 case NGX_HTTP_TO_HTTPS:
  5048.                 case NGX_HTTPS_CERT_ERROR:
  5049.                 case NGX_HTTPS_NO_CERT:
  5050.                 case NGX_HTTP_REQUEST_HEADER_TOO_LARGE:
  5051.                     err->overwrite = NGX_HTTP_BAD_REQUEST;
  5052.             }
  5053.         }

  5055.         err->value = cv;
  5056.         err->args = args;
  5057.     }

  5059.     return NGX_CONF_OK;
  5060. }


  5063. static char *
  5064. ‌ngx_http_core_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5065. {
  5066.     ngx_http_core_loc_conf_t *clcf = conf;

  5068.     time_t       inactive;
  5069.     ngx_str_t   *value, s;
  5070.     ngx_int_t    max;
  5071.     ngx_uint_t   i;

  5073.     if (clcf->open_file_cache != NGX_CONF_UNSET_PTR) {
  5074.         return "is duplicate";
  5075.     }

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

  5079.     max = 0;
  5080.     inactive = 60;

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

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

  5086.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  5087.             if (max <= 0) {
  5088.                 goto failed;
  5089.             }

  5091.             continue;
  5092.         }

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

  5096.             s.len = value[i].len - 9;
  5097.             s.data = value[i].data + 9;

  5099.             inactive = ngx_parse_time(&s, 1);
  5100.             if (inactive == (time_t) NGX_ERROR) {
  5101.                 goto failed;
  5102.             }

  5104.             continue;
  5105.         }

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

  5109.             clcf->open_file_cache = NULL;

  5111.             continue;
  5112.         }

  5114.     failed:

  5116.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5117.                            "invalid \"open_file_cache\" parameter \"%V\"",
  5118.                            &value[i]);
  5119.         return NGX_CONF_ERROR;
  5120.     }

  5122.     if (clcf->open_file_cache == NULL) {
  5123.         return NGX_CONF_OK;
  5124.     }

  5126.     if (max == 0) {
  5127.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5128.                         "\"open_file_cache\" must have the \"max\" parameter");
  5129.         return NGX_CONF_ERROR;
  5130.     }

  5132.     clcf->open_file_cache = ngx_open_file_cache_init(cf->pool, max, inactive);
  5133.     if (clcf->open_file_cache) {
  5134.         return NGX_CONF_OK;
  5135.     }

  5137.     return NGX_CONF_ERROR;
  5138. }


  5141. static char *
  5142. ‌ngx_http_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5143. {
  5144.     ngx_http_core_loc_conf_t *clcf = conf;

  5146.     return ngx_log_set_log(cf, &clcf->error_log);
  5147. }


  5150. static char *
  5151. ‌ngx_http_core_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5152. {
  5153.     ngx_http_core_loc_conf_t *clcf = conf;

  5155.     ngx_str_t  *value;

  5157.     if (clcf->keepalive_timeout != NGX_CONF_UNSET_MSEC) {
  5158.         return "is duplicate";
  5159.     }

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

  5163.     clcf->keepalive_timeout = ngx_parse_time(&value[1], 0);

  5165.     if (clcf->keepalive_timeout == (ngx_msec_t) NGX_ERROR) {
  5166.         return "invalid value";
  5167.     }

  5169.     if (cf->args->nelts == 2) {
  5170.         return NGX_CONF_OK;
  5171.     }

  5173.     clcf->keepalive_header = ngx_parse_time(&value[2], 1);

  5175.     if (clcf->keepalive_header == (time_t) NGX_ERROR) {
  5176.         return "invalid value";
  5177.     }

  5179.     return NGX_CONF_OK;
  5180. }


  5183. static char *
  5184. ‌ngx_http_core_internal(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5185. {
  5186.     ngx_http_core_loc_conf_t *clcf = conf;

  5188.     if (clcf->internal != NGX_CONF_UNSET) {
  5189.         return "is duplicate";
  5190.     }

  5192.     clcf->internal = 1;

  5194.     return NGX_CONF_OK;
  5195. }


  5198. static char *
  5199. ‌ngx_http_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5200. {
  5201.     ngx_http_core_loc_conf_t  *clcf = conf;

  5203.     ngx_str_t  *value;

  5205.     if (clcf->resolver) {
  5206.         return "is duplicate";
  5207.     }

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

  5211.     clcf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  5212.     if (clcf->resolver == NULL) {
  5213.         return NGX_CONF_ERROR;
  5214.     }

  5216.     return NGX_CONF_OK;
  5217. }


  5220. #if (NGX_HTTP_GZIP)

  5222. static char *
  5223. ‌ngx_http_gzip_disable(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5224. {
  5225.     ngx_http_core_loc_conf_t  *clcf = conf;

  5227. #if (NGX_PCRE)

  5229.     ngx_str_t            *value;
  5230.     ngx_uint_t            i;
  5231.     ngx_regex_elt_t      *re;
  5232.     ngx_regex_compile_t   rc;
  5233.     u_char                errstr[NGX_MAX_CONF_ERRSTR];

  5235.     if (clcf->gzip_disable == NGX_CONF_UNSET_PTR) {
  5236.         clcf->gzip_disable = ngx_array_create(cf->pool, 2,
  5237.                                               sizeof(ngx_regex_elt_t));
  5238.         if (clcf->gzip_disable == NULL) {
  5239.             return NGX_CONF_ERROR;
  5240.         }
  5241.     }

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

  5245.     ngx_memzero(&rc, sizeof(ngx_regex_compile_t));

  5247.     rc.pool = cf->pool;
  5248.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  5249.     rc.err.data = errstr;

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

  5253.         if (ngx_strcmp(value[i].data, "msie6") == 0) {
  5254.             clcf->gzip_disable_msie6 = 1;
  5255.             continue;
  5256.         }

  5258. #if (NGX_HTTP_DEGRADATION)

  5260.         if (ngx_strcmp(value[i].data, "degradation") == 0) {
  5261.             clcf->gzip_disable_degradation = 1;
  5262.             continue;
  5263.         }

  5265. #endif

  5267.         re = ngx_array_push(clcf->gzip_disable);
  5268.         if (re == NULL) {
  5269.             return NGX_CONF_ERROR;
  5270.         }

  5272.         rc.pattern = value[i];
  5273.         rc.options = NGX_REGEX_CASELESS;

  5275.         if (ngx_regex_compile(&rc) != NGX_OK) {
  5276.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc.err);
  5277.             return NGX_CONF_ERROR;
  5278.         }

  5280.         re->regex = rc.regex;
  5281.         re->name = value[i].data;
  5282.     }

  5284.     return NGX_CONF_OK;

  5286. #else
  5287.     ngx_str_t   *value;
  5288.     ngx_uint_t   i;

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

  5292.     for (i = 1; i < cf->args->nelts; i++) {
  5293.         if (ngx_strcmp(value[i].data, "msie6") == 0) {
  5294.             clcf->gzip_disable_msie6 = 1;
  5295.             continue;
  5296.         }

  5298. #if (NGX_HTTP_DEGRADATION)

  5300.         if (ngx_strcmp(value[i].data, "degradation") == 0) {
  5301.             clcf->gzip_disable_degradation = 1;
  5302.             continue;
  5303.         }

  5305. #endif

  5307.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5308.                            "without PCRE library \"gzip_disable\" supports "
  5309.                            "builtin \"msie6\" and \"degradation\" mask only");

  5311.         return NGX_CONF_ERROR;
  5312.     }

  5314.     return NGX_CONF_OK;

  5316. #endif
  5317. }

  5319. #endif


  5322. #if (NGX_HAVE_OPENAT)

  5324. static char *
  5325. ‌ngx_http_disable_symlinks(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5326. {
  5327.     ngx_http_core_loc_conf_t *clcf = conf;

  5329.     ngx_str_t                         *value;
  5330.     ngx_uint_t                         i;
  5331.     ngx_http_compile_complex_value_t   ccv;

  5333.     if (clcf->disable_symlinks != NGX_CONF_UNSET_UINT) {
  5334.         return "is duplicate";
  5335.     }

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

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

  5341.         if (ngx_strcmp(value[i].data, "off") == 0) {
  5342.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_OFF;
  5343.             continue;
  5344.         }

  5346.         if (ngx_strcmp(value[i].data, "if_not_owner") == 0) {
  5347.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_NOTOWNER;
  5348.             continue;
  5349.         }

  5351.         if (ngx_strcmp(value[i].data, "on") == 0) {
  5352.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_ON;
  5353.             continue;
  5354.         }

  5356.         if (ngx_strncmp(value[i].data, "from=", 5) == 0) {
  5357.             value[i].len -= 5;
  5358.             value[i].data += 5;

  5360.             ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  5362.             ccv.cf = cf;
  5363.             ccv.value = &value[i];
  5364.             ccv.complex_value = ngx_palloc(cf->pool,
  5365.                                            sizeof(ngx_http_complex_value_t));
  5366.             if (ccv.complex_value == NULL) {
  5367.                 return NGX_CONF_ERROR;
  5368.             }

  5370.             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  5371.                 return NGX_CONF_ERROR;
  5372.             }

  5374.             clcf->disable_symlinks_from = ccv.complex_value;

  5376.             continue;
  5377.         }

  5379.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5380.                            "invalid parameter \"%V\"", &value[i]);
  5381.         return NGX_CONF_ERROR;
  5382.     }

  5384.     if (clcf->disable_symlinks == NGX_CONF_UNSET_UINT) {
  5385.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5386.                            "\"%V\" must have \"off\", \"on\" "
  5387.                            "or \"if_not_owner\" parameter",
  5388.                            &cmd->name);
  5389.         return NGX_CONF_ERROR;
  5390.     }

  5392.     if (cf->args->nelts == 2) {
  5393.         clcf->disable_symlinks_from = NULL;
  5394.         return NGX_CONF_OK;
  5395.     }

  5397.     if (clcf->disable_symlinks_from == NGX_CONF_UNSET_PTR) {
  5398.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5399.                            "duplicate parameters \"%V %V\"",
  5400.                            &value[1], &value[2]);
  5401.         return NGX_CONF_ERROR;
  5402.     }

  5404.     if (clcf->disable_symlinks == NGX_DISABLE_SYMLINKS_OFF) {
  5405.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5406.                            "\"from=\" cannot be used with \"off\" parameter");
  5407.         return NGX_CONF_ERROR;
  5408.     }

  5410.     return NGX_CONF_OK;
  5411. }

  5413. #endif


  5416. static char *
  5417. ‌ngx_http_core_lowat_check(ngx_conf_t *cf, void *post, void *data)
  5418. {
  5419. #if (NGX_FREEBSD)
  5420.     ssize_t *np = data;

  5422.     if ((u_long) *np >= ngx_freebsd_net_inet_tcp_sendspace) {
  5423.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5424.                            "\"send_lowat\" must be less than %d "
  5425.                            "(sysctl net.inet.tcp.sendspace)",
  5426.                            ngx_freebsd_net_inet_tcp_sendspace);

  5428.         return NGX_CONF_ERROR;
  5429.     }

  5431. #elif !(NGX_HAVE_SO_SNDLOWAT)
  5432.     ssize_t *np = data;

  5434.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  5435.                        "\"send_lowat\" is not supported, ignored");

  5437.     *np = 0;

  5439. #endif

  5441.     return NGX_CONF_OK;
  5442. }


  5445. static char *
  5446. ‌ngx_http_core_pool_size(ngx_conf_t *cf, void *post, void *data)
  5447. {
  5448.     size_t *sp = data;

  5450.     if (*sp < NGX_MIN_POOL_SIZE) {
  5451.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5452.                            "the pool size must be no less than %uz",
  5453.                            NGX_MIN_POOL_SIZE);
  5454.         return NGX_CONF_ERROR;
  5455.     }

  5457.     if (*sp % NGX_POOL_ALIGNMENT) {
  5458.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5459.                            "the pool size must be a multiple of %d",
  5460.                            NGX_POOL_ALIGNMENT);
  5461.         return NGX_CONF_ERROR;
  5462.     }

  5464.     return NGX_CONF_OK;
  5465. }

One Level Up Top Level