One Level Up Top Level

src/http/ngx_http_core_module.c - nginx source code

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("ignore_invalid_headers"),
  256.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
  257.       ngx_conf_set_flag_slot,
  258.       NGX_HTTP_SRV_CONF_OFFSET,
  259.       offsetof(ngx_http_core_srv_conf_t, ignore_invalid_headers),
  260.       NULL },

  262.     { ngx_string("merge_slashes"),
  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, merge_slashes),
  267.       NULL },

  269.     { ngx_string("underscores_in_headers"),
  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, underscores_in_headers),
  274.       NULL },

  276.     { ngx_string("location"),
  277.       NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12,
  278.       ngx_http_core_location,
  279.       NGX_HTTP_SRV_CONF_OFFSET,
  280.       0,
  281.       NULL },

  283.     { ngx_string("listen"),
  284.       NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
  285.       ngx_http_core_listen,
  286.       NGX_HTTP_SRV_CONF_OFFSET,
  287.       0,
  288.       NULL },

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

  297.     { ngx_string("types_hash_max_size"),
  298.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  299.       ngx_conf_set_num_slot,
  300.       NGX_HTTP_LOC_CONF_OFFSET,
  301.       offsetof(ngx_http_core_loc_conf_t, types_hash_max_size),
  302.       NULL },

  304.     { ngx_string("types_hash_bucket_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_bucket_size),
  309.       NULL },

  311.     { ngx_string("types"),
  312.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF
  313.                                           |NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  314.       ngx_http_core_types,
  315.       NGX_HTTP_LOC_CONF_OFFSET,
  316.       0,
  317.       NULL },

  319.     { ngx_string("default_type"),
  320.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  321.       ngx_conf_set_str_slot,
  322.       NGX_HTTP_LOC_CONF_OFFSET,
  323.       offsetof(ngx_http_core_loc_conf_t, default_type),
  324.       NULL },

  326.     { ngx_string("root"),
  327.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  328.                         |NGX_CONF_TAKE1,
  329.       ngx_http_core_root,
  330.       NGX_HTTP_LOC_CONF_OFFSET,
  331.       0,
  332.       NULL },

  334.     { ngx_string("alias"),
  335.       NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  336.       ngx_http_core_root,
  337.       NGX_HTTP_LOC_CONF_OFFSET,
  338.       0,
  339.       NULL },

  341.     { ngx_string("limit_except"),
  342.       NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_1MORE,
  343.       ngx_http_core_limit_except,
  344.       NGX_HTTP_LOC_CONF_OFFSET,
  345.       0,
  346.       NULL },

  348.     { ngx_string("client_max_body_size"),
  349.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  350.       ngx_conf_set_off_slot,
  351.       NGX_HTTP_LOC_CONF_OFFSET,
  352.       offsetof(ngx_http_core_loc_conf_t, client_max_body_size),
  353.       NULL },

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

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

  369.     { ngx_string("client_body_temp_path"),
  370.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  371.       ngx_conf_set_path_slot,
  372.       NGX_HTTP_LOC_CONF_OFFSET,
  373.       offsetof(ngx_http_core_loc_conf_t, client_body_temp_path),
  374.       NULL },

  376.     { ngx_string("client_body_in_file_only"),
  377.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  378.       ngx_conf_set_enum_slot,
  379.       NGX_HTTP_LOC_CONF_OFFSET,
  380.       offsetof(ngx_http_core_loc_conf_t, client_body_in_file_only),
  381.       &ngx_http_core_request_body_in_file },

  383.     { ngx_string("client_body_in_single_buffer"),
  384.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  385.       ngx_conf_set_flag_slot,
  386.       NGX_HTTP_LOC_CONF_OFFSET,
  387.       offsetof(ngx_http_core_loc_conf_t, client_body_in_single_buffer),
  388.       NULL },

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

  398.     { ngx_string("sendfile_max_chunk"),
  399.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  400.       ngx_conf_set_size_slot,
  401.       NGX_HTTP_LOC_CONF_OFFSET,
  402.       offsetof(ngx_http_core_loc_conf_t, sendfile_max_chunk),
  403.       NULL },

  405.     { ngx_string("subrequest_output_buffer_size"),
  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, subrequest_output_buffer_size),
  410.       NULL },

  412.     { ngx_string("aio"),
  413.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  414.       ngx_http_core_set_aio,
  415.       NGX_HTTP_LOC_CONF_OFFSET,
  416.       0,
  417.       NULL },

  419.     { ngx_string("aio_write"),
  420.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  421.       ngx_conf_set_flag_slot,
  422.       NGX_HTTP_LOC_CONF_OFFSET,
  423.       offsetof(ngx_http_core_loc_conf_t, aio_write),
  424.       NULL },

  426.     { ngx_string("read_ahead"),
  427.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  428.       ngx_conf_set_size_slot,
  429.       NGX_HTTP_LOC_CONF_OFFSET,
  430.       offsetof(ngx_http_core_loc_conf_t, read_ahead),
  431.       NULL },

  433.     { ngx_string("directio"),
  434.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  435.       ngx_http_core_directio,
  436.       NGX_HTTP_LOC_CONF_OFFSET,
  437.       0,
  438.       NULL },

  440.     { ngx_string("directio_alignment"),
  441.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  442.       ngx_conf_set_off_slot,
  443.       NGX_HTTP_LOC_CONF_OFFSET,
  444.       offsetof(ngx_http_core_loc_conf_t, directio_alignment),
  445.       NULL },

  447.     { ngx_string("tcp_nopush"),
  448.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  449.       ngx_conf_set_flag_slot,
  450.       NGX_HTTP_LOC_CONF_OFFSET,
  451.       offsetof(ngx_http_core_loc_conf_t, tcp_nopush),
  452.       NULL },

  454.     { ngx_string("tcp_nodelay"),
  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_nodelay),
  459.       NULL },

  461.     { ngx_string("send_timeout"),
  462.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  463.       ngx_conf_set_msec_slot,
  464.       NGX_HTTP_LOC_CONF_OFFSET,
  465.       offsetof(ngx_http_core_loc_conf_t, send_timeout),
  466.       NULL },

  468.     { ngx_string("send_lowat"),
  469.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  470.       ngx_conf_set_size_slot,
  471.       NGX_HTTP_LOC_CONF_OFFSET,
  472.       offsetof(ngx_http_core_loc_conf_t, send_lowat),
  473.       &ngx_http_core_lowat_post },

  475.     { ngx_string("postpone_output"),
  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, postpone_output),
  480.       NULL },

  482.     { ngx_string("limit_rate"),
  483.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  484.                         |NGX_CONF_TAKE1,
  485.       ngx_http_set_complex_value_size_slot,
  486.       NGX_HTTP_LOC_CONF_OFFSET,
  487.       offsetof(ngx_http_core_loc_conf_t, limit_rate),
  488.       NULL },

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

  498.     { ngx_string("keepalive_time"),
  499.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  500.       ngx_conf_set_msec_slot,
  501.       NGX_HTTP_LOC_CONF_OFFSET,
  502.       offsetof(ngx_http_core_loc_conf_t, keepalive_time),
  503.       NULL },

  505.     { ngx_string("keepalive_timeout"),
  506.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  507.       ngx_http_core_keepalive,
  508.       NGX_HTTP_LOC_CONF_OFFSET,
  509.       0,
  510.       NULL },

  512.     { ngx_string("keepalive_requests"),
  513.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  514.       ngx_conf_set_num_slot,
  515.       NGX_HTTP_LOC_CONF_OFFSET,
  516.       offsetof(ngx_http_core_loc_conf_t, keepalive_requests),
  517.       NULL },

  519.     { ngx_string("keepalive_disable"),
  520.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  521.       ngx_conf_set_bitmask_slot,
  522.       NGX_HTTP_LOC_CONF_OFFSET,
  523.       offsetof(ngx_http_core_loc_conf_t, keepalive_disable),
  524.       &ngx_http_core_keepalive_disable },

  526.     { ngx_string("satisfy"),
  527.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  528.       ngx_conf_set_enum_slot,
  529.       NGX_HTTP_LOC_CONF_OFFSET,
  530.       offsetof(ngx_http_core_loc_conf_t, satisfy),
  531.       &ngx_http_core_satisfy },

  533.     { ngx_string("auth_delay"),
  534.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  535.       ngx_conf_set_msec_slot,
  536.       NGX_HTTP_LOC_CONF_OFFSET,
  537.       offsetof(ngx_http_core_loc_conf_t, auth_delay),
  538.       NULL },

  540.     { ngx_string("internal"),
  541.       NGX_HTTP_LOC_CONF|NGX_CONF_NOARGS,
  542.       ngx_http_core_internal,
  543.       NGX_HTTP_LOC_CONF_OFFSET,
  544.       0,
  545.       NULL },

  547.     { ngx_string("lingering_close"),
  548.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  549.       ngx_conf_set_enum_slot,
  550.       NGX_HTTP_LOC_CONF_OFFSET,
  551.       offsetof(ngx_http_core_loc_conf_t, lingering_close),
  552.       &ngx_http_core_lingering_close },

  554.     { ngx_string("lingering_time"),
  555.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  556.       ngx_conf_set_msec_slot,
  557.       NGX_HTTP_LOC_CONF_OFFSET,
  558.       offsetof(ngx_http_core_loc_conf_t, lingering_time),
  559.       NULL },

  561.     { ngx_string("lingering_timeout"),
  562.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  563.       ngx_conf_set_msec_slot,
  564.       NGX_HTTP_LOC_CONF_OFFSET,
  565.       offsetof(ngx_http_core_loc_conf_t, lingering_timeout),
  566.       NULL },

  568.     { ngx_string("reset_timedout_connection"),
  569.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  570.       ngx_conf_set_flag_slot,
  571.       NGX_HTTP_LOC_CONF_OFFSET,
  572.       offsetof(ngx_http_core_loc_conf_t, reset_timedout_connection),
  573.       NULL },

  575.     { ngx_string("absolute_redirect"),
  576.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  577.       ngx_conf_set_flag_slot,
  578.       NGX_HTTP_LOC_CONF_OFFSET,
  579.       offsetof(ngx_http_core_loc_conf_t, absolute_redirect),
  580.       NULL },

  582.     { ngx_string("server_name_in_redirect"),
  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, server_name_in_redirect),
  587.       NULL },

  589.     { ngx_string("port_in_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, port_in_redirect),
  594.       NULL },

  596.     { ngx_string("msie_padding"),
  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, msie_padding),
  601.       NULL },

  603.     { ngx_string("msie_refresh"),
  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, msie_refresh),
  608.       NULL },

  610.     { ngx_string("log_not_found"),
  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, log_not_found),
  615.       NULL },

  617.     { ngx_string("log_subrequest"),
  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, log_subrequest),
  622.       NULL },

  624.     { ngx_string("recursive_error_pages"),
  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, recursive_error_pages),
  629.       NULL },

  631.     { ngx_string("server_tokens"),
  632.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  633.       ngx_conf_set_enum_slot,
  634.       NGX_HTTP_LOC_CONF_OFFSET,
  635.       offsetof(ngx_http_core_loc_conf_t, server_tokens),
  636.       &ngx_http_core_server_tokens },

  638.     { ngx_string("if_modified_since"),
  639.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  640.       ngx_conf_set_enum_slot,
  641.       NGX_HTTP_LOC_CONF_OFFSET,
  642.       offsetof(ngx_http_core_loc_conf_t, if_modified_since),
  643.       &ngx_http_core_if_modified_since },

  645.     { ngx_string("max_ranges"),
  646.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  647.       ngx_conf_set_num_slot,
  648.       NGX_HTTP_LOC_CONF_OFFSET,
  649.       offsetof(ngx_http_core_loc_conf_t, max_ranges),
  650.       NULL },

  652.     { ngx_string("chunked_transfer_encoding"),
  653.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  654.       ngx_conf_set_flag_slot,
  655.       NGX_HTTP_LOC_CONF_OFFSET,
  656.       offsetof(ngx_http_core_loc_conf_t, chunked_transfer_encoding),
  657.       NULL },

  659.     { ngx_string("etag"),
  660.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  661.       ngx_conf_set_flag_slot,
  662.       NGX_HTTP_LOC_CONF_OFFSET,
  663.       offsetof(ngx_http_core_loc_conf_t, etag),
  664.       NULL },

  666.     { ngx_string("error_page"),
  667.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  668.                         |NGX_CONF_2MORE,
  669.       ngx_http_core_error_page,
  670.       NGX_HTTP_LOC_CONF_OFFSET,
  671.       0,
  672.       NULL },

  674.     { ngx_string("post_action"),
  675.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  676.                         |NGX_CONF_TAKE1,
  677.       ngx_conf_set_str_slot,
  678.       NGX_HTTP_LOC_CONF_OFFSET,
  679.       offsetof(ngx_http_core_loc_conf_t, post_action),
  680.       NULL },

  682.     { ngx_string("error_log"),
  683.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  684.       ngx_http_core_error_log,
  685.       NGX_HTTP_LOC_CONF_OFFSET,
  686.       0,
  687.       NULL },

  689.     { ngx_string("open_file_cache"),
  690.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  691.       ngx_http_core_open_file_cache,
  692.       NGX_HTTP_LOC_CONF_OFFSET,
  693.       offsetof(ngx_http_core_loc_conf_t, open_file_cache),
  694.       NULL },

  696.     { ngx_string("open_file_cache_valid"),
  697.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  698.       ngx_conf_set_sec_slot,
  699.       NGX_HTTP_LOC_CONF_OFFSET,
  700.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_valid),
  701.       NULL },

  703.     { ngx_string("open_file_cache_min_uses"),
  704.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  705.       ngx_conf_set_num_slot,
  706.       NGX_HTTP_LOC_CONF_OFFSET,
  707.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_min_uses),
  708.       NULL },

  710.     { ngx_string("open_file_cache_errors"),
  711.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  712.       ngx_conf_set_flag_slot,
  713.       NGX_HTTP_LOC_CONF_OFFSET,
  714.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_errors),
  715.       NULL },

  717.     { ngx_string("open_file_cache_events"),
  718.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  719.       ngx_conf_set_flag_slot,
  720.       NGX_HTTP_LOC_CONF_OFFSET,
  721.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_events),
  722.       NULL },

  724.     { ngx_string("resolver"),
  725.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  726.       ngx_http_core_resolver,
  727.       NGX_HTTP_LOC_CONF_OFFSET,
  728.       0,
  729.       NULL },

  731.     { ngx_string("resolver_timeout"),
  732.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  733.       ngx_conf_set_msec_slot,
  734.       NGX_HTTP_LOC_CONF_OFFSET,
  735.       offsetof(ngx_http_core_loc_conf_t, resolver_timeout),
  736.       NULL },

  738. #if (NGX_HTTP_GZIP)

  740.     { ngx_string("gzip_vary"),
  741.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  742.       ngx_conf_set_flag_slot,
  743.       NGX_HTTP_LOC_CONF_OFFSET,
  744.       offsetof(ngx_http_core_loc_conf_t, gzip_vary),
  745.       NULL },

  747.     { ngx_string("gzip_http_version"),
  748.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  749.       ngx_conf_set_enum_slot,
  750.       NGX_HTTP_LOC_CONF_OFFSET,
  751.       offsetof(ngx_http_core_loc_conf_t, gzip_http_version),
  752.       &ngx_http_gzip_http_version },

  754.     { ngx_string("gzip_proxied"),
  755.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  756.       ngx_conf_set_bitmask_slot,
  757.       NGX_HTTP_LOC_CONF_OFFSET,
  758.       offsetof(ngx_http_core_loc_conf_t, gzip_proxied),
  759.       &ngx_http_gzip_proxied_mask },

  761.     { ngx_string("gzip_disable"),
  762.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  763.       ngx_http_gzip_disable,
  764.       NGX_HTTP_LOC_CONF_OFFSET,
  765.       0,
  766.       NULL },

  768. #endif

  770. #if (NGX_HAVE_OPENAT)

  772.     { ngx_string("disable_symlinks"),
  773.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  774.       ngx_http_disable_symlinks,
  775.       NGX_HTTP_LOC_CONF_OFFSET,
  776.       0,
  777.       NULL },

  779. #endif

  781.       ngx_null_command
  782. };


  785. ‌static ngx_http_module_t  ngx_http_core_module_ctx = {
  786.     ngx_http_core_preconfiguration,        /* preconfiguration */
  787.     ngx_http_core_postconfiguration,       /* postconfiguration */

  789.     ngx_http_core_create_main_conf,        /* create main configuration */
  790.     ngx_http_core_init_main_conf,          /* init main configuration */

  792.     ngx_http_core_create_srv_conf,         /* create server configuration */
  793.     ngx_http_core_merge_srv_conf,          /* merge server configuration */

  795.     ngx_http_core_create_loc_conf,         /* create location configuration */
  796.     ngx_http_core_merge_loc_conf           /* merge location configuration */
  797. };


  800. ‌ngx_module_t  ngx_http_core_module = {
  801.     NGX_MODULE_V1,
  802.     &ngx_http_core_module_ctx,             /* module context */
  803.     ngx_http_core_commands,                /* module directives */
  804.     NGX_HTTP_MODULE,                       /* module type */
  805.     NULL,                                  /* init master */
  806.     NULL,                                  /* init module */
  807.     NULL,                                  /* init process */
  808.     NULL,                                  /* init thread */
  809.     NULL,                                  /* exit thread */
  810.     NULL,                                  /* exit process */
  811.     NULL,                                  /* exit master */
  812.     NGX_MODULE_V1_PADDING
  813. };


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


  819. void
  820. ‌ngx_http_handler(ngx_http_request_t *r)
  821. {
  822.     ngx_http_core_main_conf_t  *cmcf;

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

  826.     if (!r->internal) {
  827.         switch (r->headers_in.connection_type) {
  828.         case 0:
  829.             r->keepalive = (r->http_version > NGX_HTTP_VERSION_10);
  830.             break;

  832.         case NGX_HTTP_CONNECTION_CLOSE:
  833.             r->keepalive = 0;
  834.             break;

  836.         case NGX_HTTP_CONNECTION_KEEP_ALIVE:
  837.             r->keepalive = 1;
  838.             break;
  839.         }

  841.         r->lingering_close = (r->headers_in.content_length_n > 0
  842.                               || r->headers_in.chunked);
  843.         r->phase_handler = 0;

  845.     } else {
  846.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
  847.         r->phase_handler = cmcf->phase_engine.server_rewrite_index;
  848.     }

  850.     r->valid_location = 1;
  851. #if (NGX_HTTP_GZIP)
  852.     r->gzip_tested = 0;
  853.     r->gzip_ok = 0;
  854.     r->gzip_vary = 0;
  855. #endif

  857.     r->write_event_handler = ngx_http_core_run_phases;
  858.     ngx_http_core_run_phases(r);
  859. }


  862. void
  863. ‌ngx_http_core_run_phases(ngx_http_request_t *r)
  864. {
  865.     ngx_int_t                   rc;
  866.     ngx_http_phase_handler_t   *ph;
  867.     ngx_http_core_main_conf_t  *cmcf;

  869.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  871.     ph = cmcf->phase_engine.handlers;

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

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

  877.         if (rc == NGX_OK) {
  878.             return;
  879.         }
  880.     }
  881. }


  884. ngx_int_t
  885. ‌ngx_http_core_generic_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  886. {
  887.     ngx_int_t  rc;

  889.     /*
  890.      * generic phase checker,
  891.      * used by the post read and pre-access phases
  892.      */

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

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

  899.     if (rc == NGX_OK) {
  900.         r->phase_handler = ph->next;
  901.         return NGX_AGAIN;
  902.     }

  904.     if (rc == NGX_DECLINED) {
  905.         r->phase_handler++;
  906.         return NGX_AGAIN;
  907.     }

  909.     if (rc == NGX_AGAIN || rc == NGX_DONE) {
  910.         return NGX_OK;
  911.     }

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

  915.     ngx_http_finalize_request(r, rc);

  917.     return NGX_OK;
  918. }


  921. ngx_int_t
  922. ‌ngx_http_core_rewrite_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  923. {
  924.     ngx_int_t  rc;

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

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

  931.     if (rc == NGX_DECLINED) {
  932.         r->phase_handler++;
  933.         return NGX_AGAIN;
  934.     }

  936.     if (rc == NGX_DONE) {
  937.         return NGX_OK;
  938.     }

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

  942.     ngx_http_finalize_request(r, rc);

  944.     return NGX_OK;
  945. }


  948. ngx_int_t
  949. ‌ngx_http_core_find_config_phase(ngx_http_request_t *r,
  950.     ngx_http_phase_handler_t *ph)
  951. {
  952.     u_char                    *p;
  953.     size_t                     len;
  954.     ngx_int_t                  rc;
  955.     ngx_http_core_loc_conf_t  *clcf;

  957.     r->content_handler = NULL;
  958.     r->uri_changed = 0;

  960.     rc = ngx_http_core_find_location(r);

  962.     if (rc == NGX_ERROR) {
  963.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  964.         return NGX_OK;
  965.     }

  967.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  969.     if (!r->internal && clcf->internal) {
  970.         ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  971.         return NGX_OK;
  972.     }

  974.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  975.                    "using configuration \"%s%V\"",
  976.                    (clcf->noname ? "*" : (clcf->exact_match ? "=" : "")),
  977.                    &clcf->name);

  979.     ngx_http_update_location_config(r);

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

  985.     if (r->headers_in.content_length_n != -1
  986.         && !r->discard_body
  987.         && clcf->client_max_body_size
  988.         && clcf->client_max_body_size < r->headers_in.content_length_n)
  989.     {
  990.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  991.                       "client intended to send too large body: %O bytes",
  992.                       r->headers_in.content_length_n);

  994.         r->expect_tested = 1;
  995.         (void) ngx_http_discard_request_body(r);
  996.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_ENTITY_TOO_LARGE);
  997.         return NGX_OK;
  998.     }

  1000.     if (rc == NGX_DONE) {
  1001.         ngx_http_clear_location(r);

  1003.         r->headers_out.location = ngx_list_push(&r->headers_out.headers);
  1004.         if (r->headers_out.location == NULL) {
  1005.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1006.             return NGX_OK;
  1007.         }

  1009.         r->headers_out.location->hash = 1;
  1010.         r->headers_out.location->next = NULL;
  1011.         ngx_str_set(&r->headers_out.location->key, "Location");

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

  1016.         } else {
  1017.             len = clcf->escaped_name.len + 1 + r->args.len;
  1018.             p = ngx_pnalloc(r->pool, len);

  1020.             if (p == NULL) {
  1021.                 ngx_http_clear_location(r);
  1022.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1023.                 return NGX_OK;
  1024.             }

  1026.             r->headers_out.location->value.len = len;
  1027.             r->headers_out.location->value.data = p;

  1029.             p = ngx_cpymem(p, clcf->escaped_name.data, clcf->escaped_name.len);
  1030.             *p++ = '?';
  1031.             ngx_memcpy(p, r->args.data, r->args.len);
  1032.         }

  1034.         ngx_http_finalize_request(r, NGX_HTTP_MOVED_PERMANENTLY);
  1035.         return NGX_OK;
  1036.     }

  1038.     r->phase_handler++;
  1039.     return NGX_AGAIN;
  1040. }


  1043. ngx_int_t
  1044. ‌ngx_http_core_post_rewrite_phase(ngx_http_request_t *r,
  1045.     ngx_http_phase_handler_t *ph)
  1046. {
  1047.     ngx_http_core_srv_conf_t  *cscf;

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

  1052.     if (!r->uri_changed) {
  1053.         r->phase_handler++;
  1054.         return NGX_AGAIN;
  1055.     }

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

  1060.     /*
  1061.      * gcc before 3.3 compiles the broken code for
  1062.      *     if (r->uri_changes-- == 0)
  1063.      * if the r->uri_changes is defined as
  1064.      *     unsigned  uri_changes:4
  1065.      */

  1067.     r->uri_changes--;

  1069.     if (r->uri_changes == 0) {
  1070.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1071.                       "rewrite or internal redirection cycle "
  1072.                       "while processing \"%V\"", &r->uri);

  1074.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1075.         return NGX_OK;
  1076.     }

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

  1080.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  1081.     r->loc_conf = cscf->ctx->loc_conf;

  1083.     return NGX_AGAIN;
  1084. }


  1087. ngx_int_t
  1088. ‌ngx_http_core_access_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  1089. {
  1090.     ngx_int_t                  rc;
  1091.     ngx_table_elt_t           *h;
  1092.     ngx_http_core_loc_conf_t  *clcf;

  1094.     if (r != r->main) {
  1095.         r->phase_handler = ph->next;
  1096.         return NGX_AGAIN;
  1097.     }

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

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

  1104.     if (rc == NGX_DECLINED) {
  1105.         r->phase_handler++;
  1106.         return NGX_AGAIN;
  1107.     }

  1109.     if (rc == NGX_AGAIN || rc == NGX_DONE) {
  1110.         return NGX_OK;
  1111.     }

  1113.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  1117.         if (rc == NGX_OK) {
  1118.             r->phase_handler++;
  1119.             return NGX_AGAIN;
  1120.         }

  1122.     } else {
  1123.         if (rc == NGX_OK) {
  1124.             r->access_code = 0;

  1126.             for (h = r->headers_out.www_authenticate; h; h = h->next) {
  1127.                 h->hash = 0;
  1128.             }

  1130.             r->phase_handler = ph->next;
  1131.             return NGX_AGAIN;
  1132.         }

  1134.         if (rc == NGX_HTTP_FORBIDDEN || rc == NGX_HTTP_UNAUTHORIZED) {
  1135.             if (r->access_code != NGX_HTTP_UNAUTHORIZED) {
  1136.                 r->access_code = rc;
  1137.             }

  1139.             r->phase_handler++;
  1140.             return NGX_AGAIN;
  1141.         }
  1142.     }

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

  1146.     if (rc == NGX_HTTP_UNAUTHORIZED) {
  1147.         return ngx_http_core_auth_delay(r);
  1148.     }

  1150.     ngx_http_finalize_request(r, rc);
  1151.     return NGX_OK;
  1152. }


  1155. ngx_int_t
  1156. ‌ngx_http_core_post_access_phase(ngx_http_request_t *r,
  1157.     ngx_http_phase_handler_t *ph)
  1158. {
  1159.     ngx_int_t  access_code;

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

  1164.     access_code = r->access_code;

  1166.     if (access_code) {
  1167.         r->access_code = 0;

  1169.         if (access_code == NGX_HTTP_FORBIDDEN) {
  1170.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1171.                           "access forbidden by rule");
  1172.         }

  1174.         if (access_code == NGX_HTTP_UNAUTHORIZED) {
  1175.             return ngx_http_core_auth_delay(r);
  1176.         }

  1178.         ngx_http_finalize_request(r, access_code);
  1179.         return NGX_OK;
  1180.     }

  1182.     r->phase_handler++;
  1183.     return NGX_AGAIN;
  1184. }


  1187. static ngx_int_t
  1188. ‌ngx_http_core_auth_delay(ngx_http_request_t *r)
  1189. {
  1190.     ngx_http_core_loc_conf_t  *clcf;

  1192.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1194.     if (clcf->auth_delay == 0) {
  1195.         ngx_http_finalize_request(r, NGX_HTTP_UNAUTHORIZED);
  1196.         return NGX_OK;
  1197.     }

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

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

  1205.     } else {
  1206.         if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
  1207.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1208.         }
  1209.     }

  1211.     r->read_event_handler = ngx_http_test_reading;
  1212.     r->write_event_handler = ngx_http_core_auth_delay_handler;

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

  1217.     /*
  1218.      * trigger an additional event loop iteration
  1219.      * to ensure constant-time processing
  1220.      */

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

  1224.     return NGX_OK;
  1225. }


  1228. static void
  1229. ‌ngx_http_core_auth_delay_handler(ngx_http_request_t *r)
  1230. {
  1231.     ngx_event_t  *wev;

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

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

  1238.     if (wev->delayed) {

  1240.         if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  1241.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1242.         }

  1244.         return;
  1245.     }

  1247.     ngx_http_finalize_request(r, NGX_HTTP_UNAUTHORIZED);
  1248. }


  1251. ngx_int_t
  1252. ‌ngx_http_core_content_phase(ngx_http_request_t *r,
  1253.     ngx_http_phase_handler_t *ph)
  1254. {
  1255.     size_t     root;
  1256.     ngx_int_t  rc;
  1257.     ngx_str_t  path;

  1259.     if (r->content_handler) {
  1260.         r->write_event_handler = ngx_http_request_empty_handler;
  1261.         ngx_http_finalize_request(r, r->content_handler(r));
  1262.         return NGX_OK;
  1263.     }

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

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

  1270.     if (rc != NGX_DECLINED) {
  1271.         ngx_http_finalize_request(r, rc);
  1272.         return NGX_OK;
  1273.     }

  1275.     /* rc == NGX_DECLINED */

  1277.     ph++;

  1279.     if (ph->checker) {
  1280.         r->phase_handler++;
  1281.         return NGX_AGAIN;
  1282.     }

  1284.     /* no content handler was found */

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

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

  1293.         ngx_http_finalize_request(r, NGX_HTTP_FORBIDDEN);
  1294.         return NGX_OK;
  1295.     }

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

  1299.     ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  1300.     return NGX_OK;
  1301. }


  1304. void
  1305. ‌ngx_http_update_location_config(ngx_http_request_t *r)
  1306. {
  1307.     ngx_http_core_loc_conf_t  *clcf;

  1309.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1311.     if (r->method & clcf->limit_except) {
  1312.         r->loc_conf = clcf->limit_except_loc_conf;
  1313.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  1314.     }

  1316.     if (r == r->main) {
  1317.         ngx_set_connection_log(r->connection, clcf->error_log);
  1318.     }

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

  1323.     } else {
  1324.         r->connection->sendfile = 0;
  1325.     }

  1327.     if (clcf->client_body_in_file_only) {
  1328.         r->request_body_in_file_only = 1;
  1329.         r->request_body_in_persistent_file = 1;
  1330.         r->request_body_in_clean_file =
  1331.             clcf->client_body_in_file_only == NGX_HTTP_REQUEST_BODY_FILE_CLEAN;
  1332.         r->request_body_file_log_level = NGX_LOG_NOTICE;

  1334.     } else {
  1335.         r->request_body_file_log_level = NGX_LOG_WARN;
  1336.     }

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

  1340.     if (r->keepalive) {
  1341.         if (clcf->keepalive_timeout == 0) {
  1342.             r->keepalive = 0;

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

  1347.         } else if (ngx_current_msec - r->connection->start_time
  1348.                    > clcf->keepalive_time)
  1349.         {
  1350.             r->keepalive = 0;

  1352.         } else if (r->headers_in.msie6
  1353.                    && r->method == NGX_HTTP_POST
  1354.                    && (clcf->keepalive_disable
  1355.                        & NGX_HTTP_KEEPALIVE_DISABLE_MSIE6))
  1356.         {
  1357.             /*
  1358.              * MSIE may wait for some time if an response for
  1359.              * a POST request was sent over a keepalive connection
  1360.              */
  1361.             r->keepalive = 0;

  1363.         } else if (r->headers_in.safari
  1364.                    && (clcf->keepalive_disable
  1365.                        & NGX_HTTP_KEEPALIVE_DISABLE_SAFARI))
  1366.         {
  1367.             /*
  1368.              * Safari may send a POST request to a closed keepalive
  1369.              * connection and may stall for some time, see
  1370.              *     https://bugs.webkit.org/show_bug.cgi?id=5760
  1371.              */
  1372.             r->keepalive = 0;
  1373.         }
  1374.     }

  1376.     if (!clcf->tcp_nopush) {
  1377.         /* disable TCP_NOPUSH/TCP_CORK use */
  1378.         r->connection->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  1379.     }

  1381.     if (clcf->handler) {
  1382.         r->content_handler = clcf->handler;
  1383.     }
  1384. }


  1387. /*
  1388. * NGX_OK       - exact or regex match
  1389. * NGX_DONE     - auto redirect
  1390. * NGX_AGAIN    - inclusive match
  1391. * NGX_ERROR    - regex error
  1392. * NGX_DECLINED - no match
  1393. */

  1395. static ngx_int_t
  1396. ‌ngx_http_core_find_location(ngx_http_request_t *r)
  1397. {
  1398.     ngx_int_t                  rc;
  1399.     ngx_http_core_loc_conf_t  *pclcf;
  1400. #if (NGX_PCRE)
  1401.     ngx_int_t                  n;
  1402.     ngx_uint_t                 noregex;
  1403.     ngx_http_core_loc_conf_t  *clcf, **clcfp;

  1405.     noregex = 0;
  1406. #endif

  1408.     pclcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  1412.     if (rc == NGX_AGAIN) {

  1414. #if (NGX_PCRE)
  1415.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1417.         noregex = clcf->noregex;
  1418. #endif

  1420.         /* look up nested locations */

  1422.         rc = ngx_http_core_find_location(r);
  1423.     }

  1425.     if (rc == NGX_OK || rc == NGX_DONE) {
  1426.         return rc;
  1427.     }

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

  1431. #if (NGX_PCRE)

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

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

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

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

  1442.             if (n == NGX_OK) {
  1443.                 r->loc_conf = (*clcfp)->loc_conf;

  1445.                 /* look up nested locations */

  1447.                 rc = ngx_http_core_find_location(r);

  1449.                 return (rc == NGX_ERROR) ? rc : NGX_OK;
  1450.             }

  1452.             if (n == NGX_DECLINED) {
  1453.                 continue;
  1454.             }

  1456.             return NGX_ERROR;
  1457.         }
  1458.     }
  1459. #endif

  1461.     return rc;
  1462. }


  1465. /*
  1466. * NGX_OK       - exact match
  1467. * NGX_DONE     - auto redirect
  1468. * NGX_AGAIN    - inclusive match
  1469. * NGX_DECLINED - no match
  1470. */

  1472. static ngx_int_t
  1473. ‌ngx_http_core_find_static_location(ngx_http_request_t *r,
  1474.     ngx_http_location_tree_node_t *node)
  1475. {
  1476.     u_char     *uri;
  1477.     size_t      len, n;
  1478.     ngx_int_t   rc, rv;

  1480.     len = r->uri.len;
  1481.     uri = r->uri.data;

  1483.     rv = NGX_DECLINED;

  1485.     for ( ;; ) {

  1487.         if (node == NULL) {
  1488.             return rv;
  1489.         }

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

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

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

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

  1502.             continue;
  1503.         }

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

  1507.             if (node->inclusive) {

  1509.                 r->loc_conf = node->inclusive->loc_conf;
  1510.                 rv = NGX_AGAIN;

  1512.                 node = node->tree;
  1513.                 uri += n;
  1514.                 len -= n;

  1516.                 continue;
  1517.             }

  1519.             /* exact only */

  1521.             node = node->right;

  1523.             continue;
  1524.         }

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

  1528.             if (node->exact) {
  1529.                 r->loc_conf = node->exact->loc_conf;
  1530.                 return NGX_OK;

  1532.             } else {
  1533.                 r->loc_conf = node->inclusive->loc_conf;
  1534.                 return NGX_AGAIN;
  1535.             }
  1536.         }

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

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

  1542.             r->loc_conf = (node->exact) ? node->exact->loc_conf:
  1543.                                           node->inclusive->loc_conf;
  1544.             rv = NGX_DONE;
  1545.         }

  1547.         node = node->left;
  1548.     }
  1549. }


  1552. void *
  1553. ‌ngx_http_test_content_type(ngx_http_request_t *r, ngx_hash_t *types_hash)
  1554. {
  1555.     u_char      c, *lowcase;
  1556.     size_t      len;
  1557.     ngx_uint_t  i, hash;

  1559.     if (types_hash->size == 0) {
  1560.         return (void *) 4;
  1561.     }

  1563.     if (r->headers_out.content_type.len == 0) {
  1564.         return NULL;
  1565.     }

  1567.     len = r->headers_out.content_type_len;

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

  1571.         lowcase = ngx_pnalloc(r->pool, len);
  1572.         if (lowcase == NULL) {
  1573.             return NULL;
  1574.         }

  1576.         r->headers_out.content_type_lowcase = lowcase;

  1578.         hash = 0;

  1580.         for (i = 0; i < len; i++) {
  1581.             c = ngx_tolower(r->headers_out.content_type.data[i]);
  1582.             hash = ngx_hash(hash, c);
  1583.             lowcase[i] = c;
  1584.         }

  1586.         r->headers_out.content_type_hash = hash;
  1587.     }

  1589.     return ngx_hash_find(types_hash, r->headers_out.content_type_hash,
  1590.                          r->headers_out.content_type_lowcase, len);
  1591. }


  1594. ngx_int_t
  1595. ‌ngx_http_set_content_type(ngx_http_request_t *r)
  1596. {
  1597.     u_char                     c, *exten;
  1598.     ngx_str_t                 *type;
  1599.     ngx_uint_t                 i, hash;
  1600.     ngx_http_core_loc_conf_t  *clcf;

  1602.     if (r->headers_out.content_type.len) {
  1603.         return NGX_OK;
  1604.     }

  1606.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  1610.         hash = 0;

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

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

  1617.                 exten = ngx_pnalloc(r->pool, r->exten.len);
  1618.                 if (exten == NULL) {
  1619.                     return NGX_ERROR;
  1620.                 }

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

  1624.                 r->exten.data = exten;

  1626.                 break;
  1627.             }

  1629.             hash = ngx_hash(hash, c);
  1630.         }

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

  1635.         if (type) {
  1636.             r->headers_out.content_type_len = type->len;
  1637.             r->headers_out.content_type = *type;

  1639.             return NGX_OK;
  1640.         }
  1641.     }

  1643.     r->headers_out.content_type_len = clcf->default_type.len;
  1644.     r->headers_out.content_type = clcf->default_type;

  1646.     return NGX_OK;
  1647. }


  1650. void
  1651. ‌ngx_http_set_exten(ngx_http_request_t *r)
  1652. {
  1653.     ngx_int_t  i;

  1655.     ngx_str_null(&r->exten);

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

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

  1663.             return;

  1665.         } else if (r->uri.data[i] == '/') {
  1666.             return;
  1667.         }
  1668.     }

  1670.     return;
  1671. }


  1674. ngx_int_t
  1675. ‌ngx_http_set_etag(ngx_http_request_t *r)
  1676. {
  1677.     ngx_table_elt_t           *etag;
  1678.     ngx_http_core_loc_conf_t  *clcf;

  1680.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1682.     if (!clcf->etag) {
  1683.         return NGX_OK;
  1684.     }

  1686.     etag = ngx_list_push(&r->headers_out.headers);
  1687.     if (etag == NULL) {
  1688.         return NGX_ERROR;
  1689.     }

  1691.     etag->hash = 1;
  1692.     etag->next = NULL;
  1693.     ngx_str_set(&etag->key, "ETag");

  1695.     etag->value.data = ngx_pnalloc(r->pool, NGX_OFF_T_LEN + NGX_TIME_T_LEN + 3);
  1696.     if (etag->value.data == NULL) {
  1697.         etag->hash = 0;
  1698.         return NGX_ERROR;
  1699.     }

  1701.     etag->value.len = ngx_sprintf(etag->value.data, "\"%xT-%xO\"",
  1702.                                   r->headers_out.last_modified_time,
  1703.                                   r->headers_out.content_length_n)
  1704.                       - etag->value.data;

  1706.     r->headers_out.etag = etag;

  1708.     return NGX_OK;
  1709. }


  1712. void
  1713. ‌ngx_http_weak_etag(ngx_http_request_t *r)
  1714. {
  1715.     size_t            len;
  1716.     u_char           *p;
  1717.     ngx_table_elt_t  *etag;

  1719.     etag = r->headers_out.etag;

  1721.     if (etag == NULL) {
  1722.         return;
  1723.     }

  1725.     if (etag->value.len > 2
  1726.         && etag->value.data[0] == 'W'
  1727.         && etag->value.data[1] == '/')
  1728.     {
  1729.         return;
  1730.     }

  1732.     if (etag->value.len < 1 || etag->value.data[0] != '"') {
  1733.         r->headers_out.etag->hash = 0;
  1734.         r->headers_out.etag = NULL;
  1735.         return;
  1736.     }

  1738.     p = ngx_pnalloc(r->pool, etag->value.len + 2);
  1739.     if (p == NULL) {
  1740.         r->headers_out.etag->hash = 0;
  1741.         r->headers_out.etag = NULL;
  1742.         return;
  1743.     }

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

  1747.     etag->value.data = p;
  1748.     etag->value.len = len;
  1749. }


  1752. ngx_int_t
  1753. ‌ngx_http_send_response(ngx_http_request_t *r, ngx_uint_t status,
  1754.     ngx_str_t *ct, ngx_http_complex_value_t *cv)
  1755. {
  1756.     ngx_int_t     rc;
  1757.     ngx_str_t     val;
  1758.     ngx_buf_t    *b;
  1759.     ngx_chain_t   out;

  1761.     rc = ngx_http_discard_request_body(r);

  1763.     if (rc != NGX_OK) {
  1764.         return rc;
  1765.     }

  1767.     r->headers_out.status = status;

  1769.     if (ngx_http_complex_value(r, cv, &val) != NGX_OK) {
  1770.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1771.     }

  1773.     if (status == NGX_HTTP_MOVED_PERMANENTLY
  1774.         || status == NGX_HTTP_MOVED_TEMPORARILY
  1775.         || status == NGX_HTTP_SEE_OTHER
  1776.         || status == NGX_HTTP_TEMPORARY_REDIRECT
  1777.         || status == NGX_HTTP_PERMANENT_REDIRECT)
  1778.     {
  1779.         ngx_http_clear_location(r);

  1781.         r->headers_out.location = ngx_list_push(&r->headers_out.headers);
  1782.         if (r->headers_out.location == NULL) {
  1783.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1784.         }

  1786.         r->headers_out.location->hash = 1;
  1787.         r->headers_out.location->next = NULL;
  1788.         ngx_str_set(&r->headers_out.location->key, "Location");
  1789.         r->headers_out.location->value = val;

  1791.         return status;
  1792.     }

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

  1796.     if (ct) {
  1797.         r->headers_out.content_type_len = ct->len;
  1798.         r->headers_out.content_type = *ct;

  1800.     } else {
  1801.         if (ngx_http_set_content_type(r) != NGX_OK) {
  1802.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1803.         }
  1804.     }

  1806.     b = ngx_calloc_buf(r->pool);
  1807.     if (b == NULL) {
  1808.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1809.     }

  1811.     b->pos = val.data;
  1812.     b->last = val.data + val.len;
  1813.     b->memory = val.len ? 1 : 0;
  1814.     b->last_buf = (r == r->main) ? 1 : 0;
  1815.     b->last_in_chain = 1;
  1816.     b->sync = (b->last_buf || b->memory) ? 0 : 1;

  1818.     out.buf = b;
  1819.     out.next = NULL;

  1821.     rc = ngx_http_send_header(r);

  1823.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  1824.         return rc;
  1825.     }

  1827.     return ngx_http_output_filter(r, &out);
  1828. }


  1831. ngx_int_t
  1832. ‌ngx_http_send_header(ngx_http_request_t *r)
  1833. {
  1834.     if (r->post_action) {
  1835.         return NGX_OK;
  1836.     }

  1838.     if (r->header_sent) {
  1839.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1840.                       "header already sent");
  1841.         return NGX_ERROR;
  1842.     }

  1844.     if (r->err_status) {
  1845.         r->headers_out.status = r->err_status;
  1846.         r->headers_out.status_line.len = 0;
  1847.     }

  1849.     return ngx_http_top_header_filter(r);
  1850. }


  1853. ngx_int_t
  1854. ‌ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1855. {
  1856.     ngx_int_t          rc;
  1857.     ngx_connection_t  *c;

  1859.     c = r->connection;

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

  1864.     rc = ngx_http_top_body_filter(r, in);

  1866.     if (rc == NGX_ERROR) {
  1867.         /* NGX_ERROR may be returned by any filter */
  1868.         c->error = 1;
  1869.     }

  1871.     return rc;
  1872. }


  1875. u_char *
  1876. ‌ngx_http_map_uri_to_path(ngx_http_request_t *r, ngx_str_t *path,
  1877.     size_t *root_length, size_t reserved)
  1878. {
  1879.     u_char                    *last;
  1880.     size_t                     alias;
  1881.     ngx_http_core_loc_conf_t  *clcf;

  1883.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1885.     alias = clcf->alias;

  1887.     if (alias && !r->valid_location) {
  1888.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1889.                       "\"alias\" cannot be used in location \"%V\" "
  1890.                       "where URI was rewritten", &clcf->name);
  1891.         return NULL;
  1892.     }

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

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

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

  1900.         path->data = ngx_pnalloc(r->pool, path->len);
  1901.         if (path->data == NULL) {
  1902.             return NULL;
  1903.         }

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

  1907.     } else {

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

  1912.         } else {
  1913.             reserved += r->uri.len - alias + 1;
  1914.         }

  1916.         if (ngx_http_script_run(r, path, clcf->root_lengths->elts, reserved,
  1917.                                 clcf->root_values->elts)
  1918.             == NULL)
  1919.         {
  1920.             return NULL;
  1921.         }

  1923.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, path)
  1924.             != NGX_OK)
  1925.         {
  1926.             return NULL;
  1927.         }

  1929.         *root_length = path->len - reserved;
  1930.         last = path->data + *root_length;

  1932.         if (alias == NGX_MAX_SIZE_T_VALUE) {
  1933.             if (!r->add_uri_to_alias) {
  1934.                 *last = '\0';
  1935.                 return last;
  1936.             }

  1938.             alias = 0;
  1939.         }
  1940.     }

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

  1945.     return last;
  1946. }


  1949. ngx_int_t
  1950. ‌ngx_http_auth_basic_user(ngx_http_request_t *r)
  1951. {
  1952.     ngx_str_t   auth, encoded;
  1953.     ngx_uint_t  len;

  1955.     if (r->headers_in.user.len == 0 && r->headers_in.user.data != NULL) {
  1956.         return NGX_DECLINED;
  1957.     }

  1959.     if (r->headers_in.authorization == NULL) {
  1960.         r->headers_in.user.data = (u_char *) "";
  1961.         return NGX_DECLINED;
  1962.     }

  1964.     encoded = r->headers_in.authorization->value;

  1966.     if (encoded.len < sizeof("Basic ") - 1
  1967.         || ngx_strncasecmp(encoded.data, (u_char *) "Basic ",
  1968.                            sizeof("Basic ") - 1)
  1969.            != 0)
  1970.     {
  1971.         r->headers_in.user.data = (u_char *) "";
  1972.         return NGX_DECLINED;
  1973.     }

  1975.     encoded.len -= sizeof("Basic ") - 1;
  1976.     encoded.data += sizeof("Basic ") - 1;

  1978.     while (encoded.len && encoded.data[0] == ' ') {
  1979.         encoded.len--;
  1980.         encoded.data++;
  1981.     }

  1983.     if (encoded.len == 0) {
  1984.         r->headers_in.user.data = (u_char *) "";
  1985.         return NGX_DECLINED;
  1986.     }

  1988.     auth.len = ngx_base64_decoded_length(encoded.len);
  1989.     auth.data = ngx_pnalloc(r->pool, auth.len + 1);
  1990.     if (auth.data == NULL) {
  1991.         return NGX_ERROR;
  1992.     }

  1994.     if (ngx_decode_base64(&auth, &encoded) != NGX_OK) {
  1995.         r->headers_in.user.data = (u_char *) "";
  1996.         return NGX_DECLINED;
  1997.     }

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

  2001.     for (len = 0; len < auth.len; len++) {
  2002.         if (auth.data[len] == ':') {
  2003.             break;
  2004.         }
  2005.     }

  2007.     if (len == 0 || len == auth.len) {
  2008.         r->headers_in.user.data = (u_char *) "";
  2009.         return NGX_DECLINED;
  2010.     }

  2012.     r->headers_in.user.len = len;
  2013.     r->headers_in.user.data = auth.data;
  2014.     r->headers_in.passwd.len = auth.len - len - 1;
  2015.     r->headers_in.passwd.data = &auth.data[len + 1];

  2017.     return NGX_OK;
  2018. }


  2021. #if (NGX_HTTP_GZIP)

  2023. ngx_int_t
  2024. ‌ngx_http_gzip_ok(ngx_http_request_t *r)
  2025. {
  2026.     time_t                     date, expires;
  2027.     ngx_uint_t                 p;
  2028.     ngx_table_elt_t           *e, *d, *ae, *cc;
  2029.     ngx_http_core_loc_conf_t  *clcf;

  2031.     r->gzip_tested = 1;

  2033.     if (r != r->main) {
  2034.         return NGX_DECLINED;
  2035.     }

  2037.     ae = r->headers_in.accept_encoding;
  2038.     if (ae == NULL) {
  2039.         return NGX_DECLINED;
  2040.     }

  2042.     if (ae->value.len < sizeof("gzip") - 1) {
  2043.         return NGX_DECLINED;
  2044.     }

  2046.     /*
  2047.      * test first for the most common case "gzip,...":
  2048.      *   MSIE:    "gzip, deflate"
  2049.      *   Firefox: "gzip,deflate"
  2050.      *   Chrome:  "gzip,deflate,sdch"
  2051.      *   Safari:  "gzip, deflate"
  2052.      *   Opera:   "gzip, deflate"
  2053.      */

  2055.     if (ngx_memcmp(ae->value.data, "gzip,", 5) != 0
  2056.         && ngx_http_gzip_accept_encoding(&ae->value) != NGX_OK)
  2057.     {
  2058.         return NGX_DECLINED;
  2059.     }

  2061.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2063.     if (r->headers_in.msie6 && clcf->gzip_disable_msie6) {
  2064.         return NGX_DECLINED;
  2065.     }

  2067.     if (r->http_version < clcf->gzip_http_version) {
  2068.         return NGX_DECLINED;
  2069.     }

  2071.     if (r->headers_in.via == NULL) {
  2072.         goto ok;
  2073.     }

  2075.     p = clcf->gzip_proxied;

  2077.     if (p & NGX_HTTP_GZIP_PROXIED_OFF) {
  2078.         return NGX_DECLINED;
  2079.     }

  2081.     if (p & NGX_HTTP_GZIP_PROXIED_ANY) {
  2082.         goto ok;
  2083.     }

  2085.     if (r->headers_in.authorization && (p & NGX_HTTP_GZIP_PROXIED_AUTH)) {
  2086.         goto ok;
  2087.     }

  2089.     e = r->headers_out.expires;

  2091.     if (e) {

  2093.         if (!(p & NGX_HTTP_GZIP_PROXIED_EXPIRED)) {
  2094.             return NGX_DECLINED;
  2095.         }

  2097.         expires = ngx_parse_http_time(e->value.data, e->value.len);
  2098.         if (expires == NGX_ERROR) {
  2099.             return NGX_DECLINED;
  2100.         }

  2102.         d = r->headers_out.date;

  2104.         if (d) {
  2105.             date = ngx_parse_http_time(d->value.data, d->value.len);
  2106.             if (date == NGX_ERROR) {
  2107.                 return NGX_DECLINED;
  2108.             }

  2110.         } else {
  2111.             date = ngx_time();
  2112.         }

  2114.         if (expires < date) {
  2115.             goto ok;
  2116.         }

  2118.         return NGX_DECLINED;
  2119.     }

  2121.     cc = r->headers_out.cache_control;

  2123.     if (cc) {

  2125.         if ((p & NGX_HTTP_GZIP_PROXIED_NO_CACHE)
  2126.             && ngx_http_parse_multi_header_lines(r, cc, &ngx_http_gzip_no_cache,
  2127.                                                  NULL)
  2128.                != NULL)
  2129.         {
  2130.             goto ok;
  2131.         }

  2133.         if ((p & NGX_HTTP_GZIP_PROXIED_NO_STORE)
  2134.             && ngx_http_parse_multi_header_lines(r, cc, &ngx_http_gzip_no_store,
  2135.                                                  NULL)
  2136.                != NULL)
  2137.         {
  2138.             goto ok;
  2139.         }

  2141.         if ((p & NGX_HTTP_GZIP_PROXIED_PRIVATE)
  2142.             && ngx_http_parse_multi_header_lines(r, cc, &ngx_http_gzip_private,
  2143.                                                  NULL)
  2144.                != NULL)
  2145.         {
  2146.             goto ok;
  2147.         }

  2149.         return NGX_DECLINED;
  2150.     }

  2152.     if ((p & NGX_HTTP_GZIP_PROXIED_NO_LM) && r->headers_out.last_modified) {
  2153.         return NGX_DECLINED;
  2154.     }

  2156.     if ((p & NGX_HTTP_GZIP_PROXIED_NO_ETAG) && r->headers_out.etag) {
  2157.         return NGX_DECLINED;
  2158.     }

  2160. ok:

  2162. #if (NGX_PCRE)

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

  2166.         if (ngx_regex_exec_array(clcf->gzip_disable,
  2167.                                  &r->headers_in.user_agent->value,
  2168.                                  r->connection->log)
  2169.             != NGX_DECLINED)
  2170.         {
  2171.             return NGX_DECLINED;
  2172.         }
  2173.     }

  2175. #endif

  2177.     r->gzip_ok = 1;

  2179.     return NGX_OK;
  2180. }


  2183. /*
  2184. * gzip is enabled for the following quantities:
  2185. *     "gzip; q=0.001" ... "gzip; q=1.000"
  2186. * gzip is disabled for the following quantities:
  2187. *     "gzip; q=0" ... "gzip; q=0.000", and for any invalid cases
  2188. */

  2190. static ngx_int_t
  2191. ‌ngx_http_gzip_accept_encoding(ngx_str_t *ae)
  2192. {
  2193.     u_char  *p, *start, *last;

  2195.     start = ae->data;
  2196.     last = start + ae->len;

  2198.     for ( ;; ) {
  2199.         p = ngx_strcasestrn(start, "gzip", 4 - 1);
  2200.         if (p == NULL) {
  2201.             return NGX_DECLINED;
  2202.         }

  2204.         if (p == start || (*(p - 1) == ',' || *(p - 1) == ' ')) {
  2205.             break;
  2206.         }

  2208.         start = p + 4;
  2209.     }

  2211.     p += 4;

  2213.     while (p < last) {
  2214.         switch (*p++) {
  2215.         case ',':
  2216.             return NGX_OK;
  2217.         case ';':
  2218.             goto quantity;
  2219.         case ' ':
  2220.             continue;
  2221.         default:
  2222.             return NGX_DECLINED;
  2223.         }
  2224.     }

  2226.     return NGX_OK;

  2228. quantity:

  2230.     while (p < last) {
  2231.         switch (*p++) {
  2232.         case 'q':
  2233.         case 'Q':
  2234.             goto equal;
  2235.         case ' ':
  2236.             continue;
  2237.         default:
  2238.             return NGX_DECLINED;
  2239.         }
  2240.     }

  2242.     return NGX_OK;

  2244. equal:

  2246.     if (p + 2 > last || *p++ != '=') {
  2247.         return NGX_DECLINED;
  2248.     }

  2250.     if (ngx_http_gzip_quantity(p, last) == 0) {
  2251.         return NGX_DECLINED;
  2252.     }

  2254.     return NGX_OK;
  2255. }


  2258. static ngx_uint_t
  2259. ‌ngx_http_gzip_quantity(u_char *p, u_char *last)
  2260. {
  2261.     u_char      c;
  2262.     ngx_uint_t  n, q;

  2264.     c = *p++;

  2266.     if (c != '0' && c != '1') {
  2267.         return 0;
  2268.     }

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

  2272.     if (p == last) {
  2273.         return q;
  2274.     }

  2276.     c = *p++;

  2278.     if (c == ',' || c == ' ') {
  2279.         return q;
  2280.     }

  2282.     if (c != '.') {
  2283.         return 0;
  2284.     }

  2286.     n = 0;

  2288.     while (p < last) {
  2289.         c = *p++;

  2291.         if (c == ',' || c == ' ') {
  2292.             break;
  2293.         }

  2295.         if (c >= '0' && c <= '9') {
  2296.             q += c - '0';
  2297.             n++;
  2298.             continue;
  2299.         }

  2301.         return 0;
  2302.     }

  2304.     if (q > 100 || n > 3) {
  2305.         return 0;
  2306.     }

  2308.     return q;
  2309. }

  2311. #endif


  2314. ngx_int_t
  2315. ‌ngx_http_subrequest(ngx_http_request_t *r,
  2316.     ngx_str_t *uri, ngx_str_t *args, ngx_http_request_t **psr,
  2317.     ngx_http_post_subrequest_t *ps, ngx_uint_t flags)
  2318. {
  2319.     ngx_time_t                    *tp;
  2320.     ngx_connection_t              *c;
  2321.     ngx_http_request_t            *sr;
  2322.     ngx_http_core_srv_conf_t      *cscf;
  2323.     ngx_http_postponed_request_t  *pr, *p;

  2325.     if (r->subrequests == 0) {
  2326.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2327.                       "subrequests cycle while processing \"%V\"", uri);
  2328.         return NGX_ERROR;
  2329.     }

  2331.     /*
  2332.      * 1000 is reserved for other purposes.
  2333.      */
  2334.     if (r->main->count >= 65535 - 1000) {
  2335.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  2336.                       "request reference counter overflow "
  2337.                       "while processing \"%V\"", uri);
  2338.         return NGX_ERROR;
  2339.     }

  2341.     if (r->subrequest_in_memory) {
  2342.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2343.                       "nested in-memory subrequest \"%V\"", uri);
  2344.         return NGX_ERROR;
  2345.     }

  2347.     sr = ngx_pcalloc(r->pool, sizeof(ngx_http_request_t));
  2348.     if (sr == NULL) {
  2349.         return NGX_ERROR;
  2350.     }

  2352.     sr->signature = NGX_HTTP_MODULE;

  2354.     c = r->connection;
  2355.     sr->connection = c;

  2357.     sr->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);
  2358.     if (sr->ctx == NULL) {
  2359.         return NGX_ERROR;
  2360.     }

  2362.     if (ngx_list_init(&sr->headers_out.headers, r->pool, 20,
  2363.                       sizeof(ngx_table_elt_t))
  2364.         != NGX_OK)
  2365.     {
  2366.         return NGX_ERROR;
  2367.     }

  2369.     if (ngx_list_init(&sr->headers_out.trailers, r->pool, 4,
  2370.                       sizeof(ngx_table_elt_t))
  2371.         != NGX_OK)
  2372.     {
  2373.         return NGX_ERROR;
  2374.     }

  2376.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2377.     sr->main_conf = cscf->ctx->main_conf;
  2378.     sr->srv_conf = cscf->ctx->srv_conf;
  2379.     sr->loc_conf = cscf->ctx->loc_conf;

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

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

  2385.     ngx_http_clear_content_length(sr);
  2386.     ngx_http_clear_accept_ranges(sr);
  2387.     ngx_http_clear_last_modified(sr);

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

  2391. #if (NGX_HTTP_V2)
  2392.     sr->stream = r->stream;
  2393. #endif

  2395.     sr->method = NGX_HTTP_GET;
  2396.     sr->http_version = r->http_version;

  2398.     sr->request_line = r->request_line;
  2399.     sr->uri = *uri;

  2401.     if (args) {
  2402.         sr->args = *args;
  2403.     }

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

  2408.     sr->subrequest_in_memory = (flags & NGX_HTTP_SUBREQUEST_IN_MEMORY) != 0;
  2409.     sr->waited = (flags & NGX_HTTP_SUBREQUEST_WAITED) != 0;
  2410.     sr->background = (flags & NGX_HTTP_SUBREQUEST_BACKGROUND) != 0;

  2412.     sr->unparsed_uri = r->unparsed_uri;
  2413.     sr->method_name = ngx_http_core_get_method;
  2414.     sr->http_protocol = r->http_protocol;
  2415.     sr->schema = r->schema;

  2417.     ngx_http_set_exten(sr);

  2419.     sr->main = r->main;
  2420.     sr->parent = r;
  2421.     sr->post_subrequest = ps;
  2422.     sr->read_event_handler = ngx_http_request_empty_handler;
  2423.     sr->write_event_handler = ngx_http_handler;

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

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

  2429.     if (sr->subrequest_in_memory) {
  2430.         sr->filter_need_in_memory = 1;
  2431.     }

  2433.     if (!sr->background) {
  2434.         if (c->data == r && r->postponed == NULL) {
  2435.             c->data = sr;
  2436.         }

  2438.         pr = ngx_palloc(r->pool, sizeof(ngx_http_postponed_request_t));
  2439.         if (pr == NULL) {
  2440.             return NGX_ERROR;
  2441.         }

  2443.         pr->request = sr;
  2444.         pr->out = NULL;
  2445.         pr->next = NULL;

  2447.         if (r->postponed) {
  2448.             for (p = r->postponed; p->next; p = p->next) { /* void */ }
  2449.             p->next = pr;

  2451.         } else {
  2452.             r->postponed = pr;
  2453.         }
  2454.     }

  2456.     sr->internal = 1;

  2458.     sr->discard_body = r->discard_body;
  2459.     sr->expect_tested = 1;
  2460.     sr->main_filter_need_in_memory = r->main_filter_need_in_memory;

  2462.     sr->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;
  2463.     sr->subrequests = r->subrequests - 1;

  2465.     tp = ngx_timeofday();
  2466.     sr->start_sec = tp->sec;
  2467.     sr->start_msec = tp->msec;

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

  2471.     *psr = sr;

  2473.     if (flags & NGX_HTTP_SUBREQUEST_CLONE) {
  2474.         sr->method = r->method;
  2475.         sr->method_name = r->method_name;
  2476.         sr->loc_conf = r->loc_conf;
  2477.         sr->valid_location = r->valid_location;
  2478.         sr->valid_unparsed_uri = r->valid_unparsed_uri;
  2479.         sr->content_handler = r->content_handler;
  2480.         sr->phase_handler = r->phase_handler;
  2481.         sr->write_event_handler = ngx_http_core_run_phases;

  2483. #if (NGX_PCRE)
  2484.         sr->ncaptures = r->ncaptures;
  2485.         sr->captures = r->captures;
  2486.         sr->captures_data = r->captures_data;
  2487.         sr->realloc_captures = 1;
  2488.         r->realloc_captures = 1;
  2489. #endif

  2491.         ngx_http_update_location_config(sr);
  2492.     }

  2494.     return ngx_http_post_request(sr, NULL);
  2495. }


  2498. ngx_int_t
  2499. ‌ngx_http_internal_redirect(ngx_http_request_t *r,
  2500.     ngx_str_t *uri, ngx_str_t *args)
  2501. {
  2502.     ngx_http_core_srv_conf_t  *cscf;

  2504.     r->uri_changes--;

  2506.     if (r->uri_changes == 0) {
  2507.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2508.                       "rewrite or internal redirection cycle "
  2509.                       "while internally redirecting to \"%V\"", uri);

  2511.         r->main->count++;
  2512.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2513.         return NGX_DONE;
  2514.     }

  2516.     r->uri = *uri;

  2518.     if (args) {
  2519.         r->args = *args;

  2521.     } else {
  2522.         ngx_str_null(&r->args);
  2523.     }

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

  2528.     ngx_http_set_exten(r);

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

  2533.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2534.     r->loc_conf = cscf->ctx->loc_conf;

  2536.     ngx_http_update_location_config(r);

  2538. #if (NGX_HTTP_CACHE)
  2539.     r->cache = NULL;
  2540. #endif

  2542.     r->internal = 1;
  2543.     r->valid_unparsed_uri = 0;
  2544.     r->add_uri_to_alias = 0;
  2545.     r->main->count++;

  2547.     ngx_http_handler(r);

  2549.     return NGX_DONE;
  2550. }


  2553. ngx_int_t
  2554. ‌ngx_http_named_location(ngx_http_request_t *r, ngx_str_t *name)
  2555. {
  2556.     ngx_http_core_srv_conf_t    *cscf;
  2557.     ngx_http_core_loc_conf_t   **clcfp;
  2558.     ngx_http_core_main_conf_t   *cmcf;

  2560.     r->main->count++;
  2561.     r->uri_changes--;

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

  2568.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2569.         return NGX_DONE;
  2570.     }

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

  2576.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2577.         return NGX_DONE;
  2578.     }

  2580.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  2582.     if (cscf->named_locations) {

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

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

  2589.             if (name->len != (*clcfp)->name.len
  2590.                 || ngx_strncmp(name->data, (*clcfp)->name.data, name->len) != 0)
  2591.             {
  2592.                 continue;
  2593.             }

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

  2599.             r->internal = 1;
  2600.             r->content_handler = NULL;
  2601.             r->uri_changed = 0;
  2602.             r->loc_conf = (*clcfp)->loc_conf;

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

  2607.             ngx_http_update_location_config(r);

  2609.             cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  2613.             r->write_event_handler = ngx_http_core_run_phases;
  2614.             ngx_http_core_run_phases(r);

  2616.             return NGX_DONE;
  2617.         }
  2618.     }

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

  2623.     ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);

  2625.     return NGX_DONE;
  2626. }


  2629. ngx_http_cleanup_t *
  2630. ‌ngx_http_cleanup_add(ngx_http_request_t *r, size_t size)
  2631. {
  2632.     ngx_http_cleanup_t  *cln;

  2634.     r = r->main;

  2636.     cln = ngx_palloc(r->pool, sizeof(ngx_http_cleanup_t));
  2637.     if (cln == NULL) {
  2638.         return NULL;
  2639.     }

  2641.     if (size) {
  2642.         cln->data = ngx_palloc(r->pool, size);
  2643.         if (cln->data == NULL) {
  2644.             return NULL;
  2645.         }

  2647.     } else {
  2648.         cln->data = NULL;
  2649.     }

  2651.     cln->handler = NULL;
  2652.     cln->next = r->cleanup;

  2654.     r->cleanup = cln;

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

  2659.     return cln;
  2660. }


  2663. ngx_int_t
  2664. ‌ngx_http_set_disable_symlinks(ngx_http_request_t *r,
  2665.     ngx_http_core_loc_conf_t *clcf, ngx_str_t *path, ngx_open_file_info_t *of)
  2666. {
  2667. #if (NGX_HAVE_OPENAT)
  2668.     u_char     *p;
  2669.     ngx_str_t   from;

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

  2673.     if (clcf->disable_symlinks_from == NULL) {
  2674.         return NGX_OK;
  2675.     }

  2677.     if (ngx_http_complex_value(r, clcf->disable_symlinks_from, &from)
  2678.         != NGX_OK)
  2679.     {
  2680.         return NGX_ERROR;
  2681.     }

  2683.     if (from.len == 0
  2684.         || from.len > path->len
  2685.         || ngx_memcmp(path->data, from.data, from.len) != 0)
  2686.     {
  2687.         return NGX_OK;
  2688.     }

  2690.     if (from.len == path->len) {
  2691.         of->disable_symlinks = NGX_DISABLE_SYMLINKS_OFF;
  2692.         return NGX_OK;
  2693.     }

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

  2697.     if (*p == '/') {
  2698.         of->disable_symlinks_from = from.len;
  2699.         return NGX_OK;
  2700.     }

  2702.     p--;

  2704.     if (*p == '/') {
  2705.         of->disable_symlinks_from = from.len - 1;
  2706.     }
  2707. #endif

  2709.     return NGX_OK;
  2710. }


  2713. ngx_int_t
  2714. ‌ngx_http_get_forwarded_addr(ngx_http_request_t *r, ngx_addr_t *addr,
  2715.     ngx_table_elt_t *headers, ngx_str_t *value, ngx_array_t *proxies,
  2716.     int recursive)
  2717. {
  2718.     ngx_int_t         rc;
  2719.     ngx_uint_t        found;
  2720.     ngx_table_elt_t  *h, *next;

  2722.     if (headers == NULL) {
  2723.         return ngx_http_get_forwarded_addr_internal(r, addr, value->data,
  2724.                                                     value->len, proxies,
  2725.                                                     recursive);
  2726.     }

  2728.     /* revert headers order */

  2730.     for (h = headers, headers = NULL; h; h = next) {
  2731.         next = h->next;
  2732.         h->next = headers;
  2733.         headers = h;
  2734.     }

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

  2738.     rc = NGX_DECLINED;

  2740.     found = 0;

  2742.     for (h = headers; h; h = h->next) {
  2743.         rc = ngx_http_get_forwarded_addr_internal(r, addr, h->value.data,
  2744.                                                   h->value.len, proxies,
  2745.                                                   recursive);

  2747.         if (!recursive) {
  2748.             break;
  2749.         }

  2751.         if (rc == NGX_DECLINED && found) {
  2752.             rc = NGX_DONE;
  2753.             break;
  2754.         }

  2756.         if (rc != NGX_OK) {
  2757.             break;
  2758.         }

  2760.         found = 1;
  2761.     }

  2763.     /* restore headers order */

  2765.     for (h = headers, headers = NULL; h; h = next) {
  2766.         next = h->next;
  2767.         h->next = headers;
  2768.         headers = h;
  2769.     }

  2771.     return rc;
  2772. }


  2775. static ngx_int_t
  2776. ‌ngx_http_get_forwarded_addr_internal(ngx_http_request_t *r, ngx_addr_t *addr,
  2777.     u_char *xff, size_t xfflen, ngx_array_t *proxies, int recursive)
  2778. {
  2779.     u_char      *p;
  2780.     ngx_addr_t   paddr;
  2781.     ngx_uint_t   found;

  2783.     found = 0;

  2785.     do {

  2787.         if (ngx_cidr_match(addr->sockaddr, proxies) != NGX_OK) {
  2788.             return found ? NGX_DONE : NGX_DECLINED;
  2789.         }

  2791.         for (p = xff + xfflen - 1; p > xff; p--, xfflen--) {
  2792.             if (*p != ' ' && *p != ',') {
  2793.                 break;
  2794.             }
  2795.         }

  2797.         for ( /* void */ ; p > xff; p--) {
  2798.             if (*p == ' ' || *p == ',') {
  2799.                 p++;
  2800.                 break;
  2801.             }
  2802.         }

  2804.         if (ngx_parse_addr_port(r->pool, &paddr, p, xfflen - (p - xff))
  2805.             != NGX_OK)
  2806.         {
  2807.             return found ? NGX_DONE : NGX_DECLINED;
  2808.         }

  2810.         *addr = paddr;
  2811.         found = 1;
  2812.         xfflen = p - 1 - xff;

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

  2816.     return NGX_OK;
  2817. }


  2820. ngx_int_t
  2821. ‌ngx_http_link_multi_headers(ngx_http_request_t *r)
  2822. {
  2823.     ngx_uint_t        i, j;
  2824.     ngx_list_part_t  *part, *ppart;
  2825.     ngx_table_elt_t  *header, *pheader, **ph;

  2827.     if (r->headers_in.multi_linked) {
  2828.         return NGX_OK;
  2829.     }

  2831.     r->headers_in.multi_linked = 1;

  2833.     part = &r->headers_in.headers.part;
  2834.     header = part->elts;

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

  2838.         if (i >= part->nelts) {
  2839.             if (part->next == NULL) {
  2840.                 break;
  2841.             }

  2843.             part = part->next;
  2844.             header = part->elts;
  2845.             i = 0;
  2846.         }

  2848.         header[i].next = NULL;

  2850.         /*
  2851.          * search for previous headers with the same name;
  2852.          * if there are any, link to them
  2853.          */

  2855.         ppart = &r->headers_in.headers.part;
  2856.         pheader = ppart->elts;

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

  2860.             if (j >= ppart->nelts) {
  2861.                 if (ppart->next == NULL) {
  2862.                     break;
  2863.                 }

  2865.                 ppart = ppart->next;
  2866.                 pheader = ppart->elts;
  2867.                 j = 0;
  2868.             }

  2870.             if (part == ppart && i == j) {
  2871.                 break;
  2872.             }

  2874.             if (header[i].key.len == pheader[j].key.len
  2875.                 && ngx_strncasecmp(header[i].key.data, pheader[j].key.data,
  2876.                                    header[i].key.len)
  2877.                    == 0)
  2878.             {
  2879.                 ph = &pheader[j].next;
  2880.                 while (*ph) { ph = &(*ph)->next; }
  2881.                 *ph = &header[i];

  2883.                 r->headers_in.multi = 1;

  2885.                 break;
  2886.             }
  2887.         }
  2888.     }

  2890.     return NGX_OK;
  2891. }


  2894. static char *
  2895. ‌ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  2896. {
  2897.     char                        *rv;
  2898.     void                        *mconf;
  2899.     size_t                       len;
  2900.     u_char                      *p;
  2901.     ngx_uint_t                   i;
  2902.     ngx_conf_t                   pcf;
  2903.     ngx_http_module_t           *module;
  2904.     struct sockaddr_in          *sin;
  2905.     ngx_http_conf_ctx_t         *ctx, *http_ctx;
  2906.     ngx_http_listen_opt_t        lsopt;
  2907.     ngx_http_core_srv_conf_t    *cscf, **cscfp;
  2908.     ngx_http_core_main_conf_t   *cmcf;

  2910.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  2911.     if (ctx == NULL) {
  2912.         return NGX_CONF_ERROR;
  2913.     }

  2915.     http_ctx = cf->ctx;
  2916.     ctx->main_conf = http_ctx->main_conf;

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

  2920.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  2921.     if (ctx->srv_conf == NULL) {
  2922.         return NGX_CONF_ERROR;
  2923.     }

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

  2927.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  2928.     if (ctx->loc_conf == NULL) {
  2929.         return NGX_CONF_ERROR;
  2930.     }

  2932.     for (i = 0; cf->cycle->modules[i]; i++) {
  2933.         if (cf->cycle->modules[i]->type != NGX_HTTP_MODULE) {
  2934.             continue;
  2935.         }

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

  2939.         if (module->create_srv_conf) {
  2940.             mconf = module->create_srv_conf(cf);
  2941.             if (mconf == NULL) {
  2942.                 return NGX_CONF_ERROR;
  2943.             }

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

  2948.         if (module->create_loc_conf) {
  2949.             mconf = module->create_loc_conf(cf);
  2950.             if (mconf == NULL) {
  2951.                 return NGX_CONF_ERROR;
  2952.             }

  2954.             ctx->loc_conf[cf->cycle->modules[i]->ctx_index] = mconf;
  2955.         }
  2956.     }


  2959.     /* the server configuration context */

  2961.     cscf = ctx->srv_conf[ngx_http_core_module.ctx_index];
  2962.     cscf->ctx = ctx;


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

  2967.     cscfp = ngx_array_push(&cmcf->servers);
  2968.     if (cscfp == NULL) {
  2969.         return NGX_CONF_ERROR;
  2970.     }

  2972.     *cscfp = cscf;


  2975.     /* parse inside server{} */

  2977.     pcf = *cf;
  2978.     cf->ctx = ctx;
  2979.     cf->cmd_type = NGX_HTTP_SRV_CONF;

  2981.     rv = ngx_conf_parse(cf, NULL);

  2983.     *cf = pcf;

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

  2988.         p = ngx_pcalloc(cf->pool, sizeof(struct sockaddr_in));
  2989.         if (p == NULL) {
  2990.             return NGX_CONF_ERROR;
  2991.         }

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

  2995.         sin = (struct sockaddr_in *) p;

  2997.         sin->sin_family = AF_INET;
  2998. #if (NGX_WIN32)
  2999.         sin->sin_port = htons(80);
  3000. #else
  3001.         sin->sin_port = htons((getuid() == 0) ? 80 : 8000);
  3002. #endif
  3003.         sin->sin_addr.s_addr = INADDR_ANY;

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

  3007.         lsopt.backlog = NGX_LISTEN_BACKLOG;
  3008.         lsopt.type = SOCK_STREAM;
  3009.         lsopt.rcvbuf = -1;
  3010.         lsopt.sndbuf = -1;
  3011. #if (NGX_HAVE_SETFIB)
  3012.         lsopt.setfib = -1;
  3013. #endif
  3014. #if (NGX_HAVE_TCP_FASTOPEN)
  3015.         lsopt.fastopen = -1;
  3016. #endif
  3017.         lsopt.wildcard = 1;

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

  3021.         p = ngx_pnalloc(cf->pool, len);
  3022.         if (p == NULL) {
  3023.             return NGX_CONF_ERROR;
  3024.         }

  3026.         lsopt.addr_text.data = p;
  3027.         lsopt.addr_text.len = ngx_sock_ntop(lsopt.sockaddr, lsopt.socklen, p,
  3028.                                             len, 1);

  3030.         if (ngx_http_add_listen(cf, cscf, &lsopt) != NGX_OK) {
  3031.             return NGX_CONF_ERROR;
  3032.         }
  3033.     }

  3035.     return rv;
  3036. }


  3039. static char *
  3040. ‌ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  3041. {
  3042.     char                      *rv;
  3043.     u_char                    *mod;
  3044.     size_t                     len;
  3045.     ngx_str_t                 *value, *name;
  3046.     ngx_uint_t                 i;
  3047.     ngx_conf_t                 save;
  3048.     ngx_http_module_t         *module;
  3049.     ngx_http_conf_ctx_t       *ctx, *pctx;
  3050.     ngx_http_core_loc_conf_t  *clcf, *pclcf;

  3052.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  3053.     if (ctx == NULL) {
  3054.         return NGX_CONF_ERROR;
  3055.     }

  3057.     pctx = cf->ctx;
  3058.     ctx->main_conf = pctx->main_conf;
  3059.     ctx->srv_conf = pctx->srv_conf;

  3061.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  3062.     if (ctx->loc_conf == NULL) {
  3063.         return NGX_CONF_ERROR;
  3064.     }

  3066.     for (i = 0; cf->cycle->modules[i]; i++) {
  3067.         if (cf->cycle->modules[i]->type != NGX_HTTP_MODULE) {
  3068.             continue;
  3069.         }

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

  3073.         if (module->create_loc_conf) {
  3074.             ctx->loc_conf[cf->cycle->modules[i]->ctx_index] =
  3075.                                                    module->create_loc_conf(cf);
  3076.             if (ctx->loc_conf[cf->cycle->modules[i]->ctx_index] == NULL) {
  3077.                 return NGX_CONF_ERROR;
  3078.             }
  3079.         }
  3080.     }

  3082.     clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
  3083.     clcf->loc_conf = ctx->loc_conf;

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

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

  3089.         len = value[1].len;
  3090.         mod = value[1].data;
  3091.         name = &value[2];

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

  3095.             clcf->name = *name;
  3096.             clcf->exact_match = 1;

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

  3100.             clcf->name = *name;
  3101.             clcf->noregex = 1;

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

  3105.             if (ngx_http_core_regex_location(cf, clcf, name, 0) != NGX_OK) {
  3106.                 return NGX_CONF_ERROR;
  3107.             }

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

  3111.             if (ngx_http_core_regex_location(cf, clcf, name, 1) != NGX_OK) {
  3112.                 return NGX_CONF_ERROR;
  3113.             }

  3115.         } else {
  3116.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3117.                                "invalid location modifier \"%V\"", &value[1]);
  3118.             return NGX_CONF_ERROR;
  3119.         }

  3121.     } else {

  3123.         name = &value[1];

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

  3127.             clcf->name.len = name->len - 1;
  3128.             clcf->name.data = name->data + 1;
  3129.             clcf->exact_match = 1;

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

  3133.             clcf->name.len = name->len - 2;
  3134.             clcf->name.data = name->data + 2;
  3135.             clcf->noregex = 1;

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

  3139.             name->len--;
  3140.             name->data++;

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

  3144.                 name->len--;
  3145.                 name->data++;

  3147.                 if (ngx_http_core_regex_location(cf, clcf, name, 1) != NGX_OK) {
  3148.                     return NGX_CONF_ERROR;
  3149.                 }

  3151.             } else {
  3152.                 if (ngx_http_core_regex_location(cf, clcf, name, 0) != NGX_OK) {
  3153.                     return NGX_CONF_ERROR;
  3154.                 }
  3155.             }

  3157.         } else {

  3159.             clcf->name = *name;

  3161.             if (name->data[0] == '@') {
  3162.                 clcf->named = 1;
  3163.             }
  3164.         }
  3165.     }

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

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

  3171.         /* nested location */

  3173. #if 0
  3174.         clcf->prev_location = pclcf;
  3175. #endif

  3177.         if (pclcf->exact_match) {
  3178.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3179.                                "location \"%V\" cannot be inside "
  3180.                                "the exact location \"%V\"",
  3181.                                &clcf->name, &pclcf->name);
  3182.             return NGX_CONF_ERROR;
  3183.         }

  3185.         if (pclcf->named) {
  3186.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3187.                                "location \"%V\" cannot be inside "
  3188.                                "the named location \"%V\"",
  3189.                                &clcf->name, &pclcf->name);
  3190.             return NGX_CONF_ERROR;
  3191.         }

  3193.         if (clcf->named) {
  3194.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3195.                                "named location \"%V\" can be "
  3196.                                "on the server level only",
  3197.                                &clcf->name);
  3198.             return NGX_CONF_ERROR;
  3199.         }

  3201.         len = pclcf->name.len;

  3203. #if (NGX_PCRE)
  3204.         if (clcf->regex == NULL
  3205.             && ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
  3206. #else
  3207.         if (ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
  3208. #endif
  3209.         {
  3210.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3211.                                "location \"%V\" is outside location \"%V\"",
  3212.                                &clcf->name, &pclcf->name);
  3213.             return NGX_CONF_ERROR;
  3214.         }
  3215.     }

  3217.     if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
  3218.         return NGX_CONF_ERROR;
  3219.     }

  3221.     save = *cf;
  3222.     cf->ctx = ctx;
  3223.     cf->cmd_type = NGX_HTTP_LOC_CONF;

  3225.     rv = ngx_conf_parse(cf, NULL);

  3227.     *cf = save;

  3229.     return rv;
  3230. }


  3233. static ngx_int_t
  3234. ‌ngx_http_core_regex_location(ngx_conf_t *cf, ngx_http_core_loc_conf_t *clcf,
  3235.     ngx_str_t *regex, ngx_uint_t caseless)
  3236. {
  3237. #if (NGX_PCRE)
  3238.     ngx_regex_compile_t  rc;
  3239.     u_char               errstr[NGX_MAX_CONF_ERRSTR];

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

  3243.     rc.pattern = *regex;
  3244.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  3245.     rc.err.data = errstr;

  3247. #if (NGX_HAVE_CASELESS_FILESYSTEM)
  3248.     rc.options = NGX_REGEX_CASELESS;
  3249. #else
  3250.     rc.options = caseless ? NGX_REGEX_CASELESS : 0;
  3251. #endif

  3253.     clcf->regex = ngx_http_regex_compile(cf, &rc);
  3254.     if (clcf->regex == NULL) {
  3255.         return NGX_ERROR;
  3256.     }

  3258.     clcf->name = *regex;

  3260.     return NGX_OK;

  3262. #else

  3264.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3265.                        "using regex \"%V\" requires PCRE library",
  3266.                        regex);
  3267.     return NGX_ERROR;

  3269. #endif
  3270. }


  3273. static char *
  3274. ‌ngx_http_core_types(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3275. {
  3276.     ngx_http_core_loc_conf_t *clcf = conf;

  3278.     char        *rv;
  3279.     ngx_conf_t   save;

  3281.     if (clcf->types == NULL) {
  3282.         clcf->types = ngx_array_create(cf->pool, 64, sizeof(ngx_hash_key_t));
  3283.         if (clcf->types == NULL) {
  3284.             return NGX_CONF_ERROR;
  3285.         }
  3286.     }

  3288.     save = *cf;
  3289.     cf->handler = ngx_http_core_type;
  3290.     cf->handler_conf = conf;

  3292.     rv = ngx_conf_parse(cf, NULL);

  3294.     *cf = save;

  3296.     return rv;
  3297. }


  3300. static char *
  3301. ‌ngx_http_core_type(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
  3302. {
  3303.     ngx_http_core_loc_conf_t *clcf = conf;

  3305.     ngx_str_t       *value, *content_type, *old;
  3306.     ngx_uint_t       i, n, hash;
  3307.     ngx_hash_key_t  *type;

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

  3311.     if (ngx_strcmp(value[0].data, "include") == 0) {
  3312.         if (cf->args->nelts != 2) {
  3313.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3314.                                "invalid number of arguments"
  3315.                                " in \"include\" directive");
  3316.             return NGX_CONF_ERROR;
  3317.         }

  3319.         return ngx_conf_include(cf, dummy, conf);
  3320.     }

  3322.     content_type = ngx_palloc(cf->pool, sizeof(ngx_str_t));
  3323.     if (content_type == NULL) {
  3324.         return NGX_CONF_ERROR;
  3325.     }

  3327.     *content_type = value[0];

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

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

  3333.         type = clcf->types->elts;
  3334.         for (n = 0; n < clcf->types->nelts; n++) {
  3335.             if (ngx_strcmp(value[i].data, type[n].key.data) == 0) {
  3336.                 old = type[n].value;
  3337.                 type[n].value = content_type;

  3339.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  3340.                                    "duplicate extension \"%V\", "
  3341.                                    "content type: \"%V\", "
  3342.                                    "previous content type: \"%V\"",
  3343.                                    &value[i], content_type, old);
  3344.                 goto next;
  3345.             }
  3346.         }


  3349.         type = ngx_array_push(clcf->types);
  3350.         if (type == NULL) {
  3351.             return NGX_CONF_ERROR;
  3352.         }

  3354.         type->key = value[i];
  3355.         type->key_hash = hash;
  3356.         type->value = content_type;

  3358.     next:
  3359.         continue;
  3360.     }

  3362.     return NGX_CONF_OK;
  3363. }


  3366. static ngx_int_t
  3367. ‌ngx_http_core_preconfiguration(ngx_conf_t *cf)
  3368. {
  3369.     return ngx_http_variables_add_core_vars(cf);
  3370. }


  3373. static ngx_int_t
  3374. ‌ngx_http_core_postconfiguration(ngx_conf_t *cf)
  3375. {
  3376.     ngx_http_top_request_body_filter = ngx_http_request_body_save_filter;

  3378.     return NGX_OK;
  3379. }


  3382. static void *
  3383. ‌ngx_http_core_create_main_conf(ngx_conf_t *cf)
  3384. {
  3385.     ngx_http_core_main_conf_t  *cmcf;

  3387.     cmcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_main_conf_t));
  3388.     if (cmcf == NULL) {
  3389.         return NULL;
  3390.     }

  3392.     if (ngx_array_init(&cmcf->servers, cf->pool, 4,
  3393.                        sizeof(ngx_http_core_srv_conf_t *))
  3394.         != NGX_OK)
  3395.     {
  3396.         return NULL;
  3397.     }

  3399.     cmcf->server_names_hash_max_size = NGX_CONF_UNSET_UINT;
  3400.     cmcf->server_names_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3402.     cmcf->variables_hash_max_size = NGX_CONF_UNSET_UINT;
  3403.     cmcf->variables_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3405.     return cmcf;
  3406. }


  3409. static char *
  3410. ‌ngx_http_core_init_main_conf(ngx_conf_t *cf, void *conf)
  3411. {
  3412.     ngx_http_core_main_conf_t *cmcf = conf;

  3414.     ngx_conf_init_uint_value(cmcf->server_names_hash_max_size, 512);
  3415.     ngx_conf_init_uint_value(cmcf->server_names_hash_bucket_size,
  3416.                              ngx_cacheline_size);

  3418.     cmcf->server_names_hash_bucket_size =
  3419.             ngx_align(cmcf->server_names_hash_bucket_size, ngx_cacheline_size);


  3422.     ngx_conf_init_uint_value(cmcf->variables_hash_max_size, 1024);
  3423.     ngx_conf_init_uint_value(cmcf->variables_hash_bucket_size, 64);

  3425.     cmcf->variables_hash_bucket_size =
  3426.                ngx_align(cmcf->variables_hash_bucket_size, ngx_cacheline_size);

  3428.     if (cmcf->ncaptures) {
  3429.         cmcf->ncaptures = (cmcf->ncaptures + 1) * 3;
  3430.     }

  3432.     return NGX_CONF_OK;
  3433. }


  3436. static void *
  3437. ‌ngx_http_core_create_srv_conf(ngx_conf_t *cf)
  3438. {
  3439.     ngx_http_core_srv_conf_t  *cscf;

  3441.     cscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_srv_conf_t));
  3442.     if (cscf == NULL) {
  3443.         return NULL;
  3444.     }

  3446.     /*
  3447.      * set by ngx_pcalloc():
  3448.      *
  3449.      *     conf->client_large_buffers.num = 0;
  3450.      */

  3452.     if (ngx_array_init(&cscf->server_names, cf->temp_pool, 4,
  3453.                        sizeof(ngx_http_server_name_t))
  3454.         != NGX_OK)
  3455.     {
  3456.         return NULL;
  3457.     }

  3459.     cscf->connection_pool_size = NGX_CONF_UNSET_SIZE;
  3460.     cscf->request_pool_size = NGX_CONF_UNSET_SIZE;
  3461.     cscf->client_header_timeout = NGX_CONF_UNSET_MSEC;
  3462.     cscf->client_header_buffer_size = NGX_CONF_UNSET_SIZE;
  3463.     cscf->ignore_invalid_headers = NGX_CONF_UNSET;
  3464.     cscf->merge_slashes = NGX_CONF_UNSET;
  3465.     cscf->underscores_in_headers = NGX_CONF_UNSET;

  3467.     cscf->file_name = cf->conf_file->file.name.data;
  3468.     cscf->line = cf->conf_file->line;

  3470.     return cscf;
  3471. }


  3474. static char *
  3475. ‌ngx_http_core_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  3476. {
  3477.     ngx_http_core_srv_conf_t *prev = parent;
  3478.     ngx_http_core_srv_conf_t *conf = child;

  3480.     ngx_str_t                name;
  3481.     ngx_http_server_name_t  *sn;

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

  3485.     ngx_conf_merge_size_value(conf->connection_pool_size,
  3486.                               prev->connection_pool_size, 64 * sizeof(void *));
  3487.     ngx_conf_merge_size_value(conf->request_pool_size,
  3488.                               prev->request_pool_size, 4096);
  3489.     ngx_conf_merge_msec_value(conf->client_header_timeout,
  3490.                               prev->client_header_timeout, 60000);
  3491.     ngx_conf_merge_size_value(conf->client_header_buffer_size,
  3492.                               prev->client_header_buffer_size, 1024);
  3493.     ngx_conf_merge_bufs_value(conf->large_client_header_buffers,
  3494.                               prev->large_client_header_buffers,
  3495.                               4, 8192);

  3497.     if (conf->large_client_header_buffers.size < conf->connection_pool_size) {
  3498.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3499.                            "the \"large_client_header_buffers\" size must be "
  3500.                            "equal to or greater than \"connection_pool_size\"");
  3501.         return NGX_CONF_ERROR;
  3502.     }

  3504.     ngx_conf_merge_value(conf->ignore_invalid_headers,
  3505.                               prev->ignore_invalid_headers, 1);

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

  3509.     ngx_conf_merge_value(conf->underscores_in_headers,
  3510.                               prev->underscores_in_headers, 0);

  3512.     if (conf->server_names.nelts == 0) {
  3513.         /* the array has 4 empty preallocated elements, so push cannot fail */
  3514.         sn = ngx_array_push(&conf->server_names);
  3515. #if (NGX_PCRE)
  3516.         sn->regex = NULL;
  3517. #endif
  3518.         sn->server = conf;
  3519.         ngx_str_set(&sn->name, "");
  3520.     }

  3522.     sn = conf->server_names.elts;
  3523.     name = sn[0].name;

  3525. #if (NGX_PCRE)
  3526.     if (sn->regex) {
  3527.         name.len++;
  3528.         name.data--;
  3529.     } else
  3530. #endif

  3532.     if (name.data[0] == '.') {
  3533.         name.len--;
  3534.         name.data++;
  3535.     }

  3537.     conf->server_name.len = name.len;
  3538.     conf->server_name.data = ngx_pstrdup(cf->pool, &name);
  3539.     if (conf->server_name.data == NULL) {
  3540.         return NGX_CONF_ERROR;
  3541.     }

  3543.     return NGX_CONF_OK;
  3544. }


  3547. static void *
  3548. ‌ngx_http_core_create_loc_conf(ngx_conf_t *cf)
  3549. {
  3550.     ngx_http_core_loc_conf_t  *clcf;

  3552.     clcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_loc_conf_t));
  3553.     if (clcf == NULL) {
  3554.         return NULL;
  3555.     }

  3557.     /*
  3558.      * set by ngx_pcalloc():
  3559.      *
  3560.      *     clcf->escaped_name = { 0, NULL };
  3561.      *     clcf->root = { 0, NULL };
  3562.      *     clcf->limit_except = 0;
  3563.      *     clcf->post_action = { 0, NULL };
  3564.      *     clcf->types = NULL;
  3565.      *     clcf->default_type = { 0, NULL };
  3566.      *     clcf->error_log = NULL;
  3567.      *     clcf->error_pages = NULL;
  3568.      *     clcf->client_body_path = NULL;
  3569.      *     clcf->regex = NULL;
  3570.      *     clcf->exact_match = 0;
  3571.      *     clcf->auto_redirect = 0;
  3572.      *     clcf->alias = 0;
  3573.      *     clcf->gzip_proxied = 0;
  3574.      *     clcf->keepalive_disable = 0;
  3575.      */

  3577.     clcf->client_max_body_size = NGX_CONF_UNSET;
  3578.     clcf->client_body_buffer_size = NGX_CONF_UNSET_SIZE;
  3579.     clcf->client_body_timeout = NGX_CONF_UNSET_MSEC;
  3580.     clcf->satisfy = NGX_CONF_UNSET_UINT;
  3581.     clcf->auth_delay = NGX_CONF_UNSET_MSEC;
  3582.     clcf->if_modified_since = NGX_CONF_UNSET_UINT;
  3583.     clcf->max_ranges = NGX_CONF_UNSET_UINT;
  3584.     clcf->client_body_in_file_only = NGX_CONF_UNSET_UINT;
  3585.     clcf->client_body_in_single_buffer = NGX_CONF_UNSET;
  3586.     clcf->internal = NGX_CONF_UNSET;
  3587.     clcf->sendfile = NGX_CONF_UNSET;
  3588.     clcf->sendfile_max_chunk = NGX_CONF_UNSET_SIZE;
  3589.     clcf->subrequest_output_buffer_size = NGX_CONF_UNSET_SIZE;
  3590.     clcf->aio = NGX_CONF_UNSET;
  3591.     clcf->aio_write = NGX_CONF_UNSET;
  3592. #if (NGX_THREADS)
  3593.     clcf->thread_pool = NGX_CONF_UNSET_PTR;
  3594.     clcf->thread_pool_value = NGX_CONF_UNSET_PTR;
  3595. #endif
  3596.     clcf->read_ahead = NGX_CONF_UNSET_SIZE;
  3597.     clcf->directio = NGX_CONF_UNSET;
  3598.     clcf->directio_alignment = NGX_CONF_UNSET;
  3599.     clcf->tcp_nopush = NGX_CONF_UNSET;
  3600.     clcf->tcp_nodelay = NGX_CONF_UNSET;
  3601.     clcf->send_timeout = NGX_CONF_UNSET_MSEC;
  3602.     clcf->send_lowat = NGX_CONF_UNSET_SIZE;
  3603.     clcf->postpone_output = NGX_CONF_UNSET_SIZE;
  3604.     clcf->limit_rate = NGX_CONF_UNSET_PTR;
  3605.     clcf->limit_rate_after = NGX_CONF_UNSET_PTR;
  3606.     clcf->keepalive_time = NGX_CONF_UNSET_MSEC;
  3607.     clcf->keepalive_timeout = NGX_CONF_UNSET_MSEC;
  3608.     clcf->keepalive_header = NGX_CONF_UNSET;
  3609.     clcf->keepalive_requests = NGX_CONF_UNSET_UINT;
  3610.     clcf->lingering_close = NGX_CONF_UNSET_UINT;
  3611.     clcf->lingering_time = NGX_CONF_UNSET_MSEC;
  3612.     clcf->lingering_timeout = NGX_CONF_UNSET_MSEC;
  3613.     clcf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  3614.     clcf->reset_timedout_connection = NGX_CONF_UNSET;
  3615.     clcf->absolute_redirect = NGX_CONF_UNSET;
  3616.     clcf->server_name_in_redirect = NGX_CONF_UNSET;
  3617.     clcf->port_in_redirect = NGX_CONF_UNSET;
  3618.     clcf->msie_padding = NGX_CONF_UNSET;
  3619.     clcf->msie_refresh = NGX_CONF_UNSET;
  3620.     clcf->log_not_found = NGX_CONF_UNSET;
  3621.     clcf->log_subrequest = NGX_CONF_UNSET;
  3622.     clcf->recursive_error_pages = NGX_CONF_UNSET;
  3623.     clcf->chunked_transfer_encoding = NGX_CONF_UNSET;
  3624.     clcf->etag = NGX_CONF_UNSET;
  3625.     clcf->server_tokens = NGX_CONF_UNSET_UINT;
  3626.     clcf->types_hash_max_size = NGX_CONF_UNSET_UINT;
  3627.     clcf->types_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3629.     clcf->open_file_cache = NGX_CONF_UNSET_PTR;
  3630.     clcf->open_file_cache_valid = NGX_CONF_UNSET;
  3631.     clcf->open_file_cache_min_uses = NGX_CONF_UNSET_UINT;
  3632.     clcf->open_file_cache_errors = NGX_CONF_UNSET;
  3633.     clcf->open_file_cache_events = NGX_CONF_UNSET;

  3635. #if (NGX_HTTP_GZIP)
  3636.     clcf->gzip_vary = NGX_CONF_UNSET;
  3637.     clcf->gzip_http_version = NGX_CONF_UNSET_UINT;
  3638. #if (NGX_PCRE)
  3639.     clcf->gzip_disable = NGX_CONF_UNSET_PTR;
  3640. #endif
  3641.     clcf->gzip_disable_msie6 = 3;
  3642. #if (NGX_HTTP_DEGRADATION)
  3643.     clcf->gzip_disable_degradation = 3;
  3644. #endif
  3645. #endif

  3647. #if (NGX_HAVE_OPENAT)
  3648.     clcf->disable_symlinks = NGX_CONF_UNSET_UINT;
  3649.     clcf->disable_symlinks_from = NGX_CONF_UNSET_PTR;
  3650. #endif

  3652.     return clcf;
  3653. }


  3656. ‌static ngx_str_t  ngx_http_core_text_html_type = ngx_string("text/html");
  3657. ‌static ngx_str_t  ngx_http_core_image_gif_type = ngx_string("image/gif");
  3658. ‌static ngx_str_t  ngx_http_core_image_jpeg_type = ngx_string("image/jpeg");

  3660. ‌static ngx_hash_key_t  ngx_http_core_default_types[] = {
  3661.     { ngx_string("html"), 0, &ngx_http_core_text_html_type },
  3662.     { ngx_string("gif"), 0, &ngx_http_core_image_gif_type },
  3663.     { ngx_string("jpg"), 0, &ngx_http_core_image_jpeg_type },
  3664.     { ngx_null_string, 0, NULL }
  3665. };


  3668. static char *
  3669. ‌ngx_http_core_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  3670. {
  3671.     ngx_http_core_loc_conf_t *prev = parent;
  3672.     ngx_http_core_loc_conf_t *conf = child;

  3674.     ngx_uint_t        i;
  3675.     ngx_hash_key_t   *type;
  3676.     ngx_hash_init_t   types_hash;

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

  3680.         conf->alias = prev->alias;
  3681.         conf->root = prev->root;
  3682.         conf->root_lengths = prev->root_lengths;
  3683.         conf->root_values = prev->root_values;

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

  3688.             if (ngx_conf_full_name(cf->cycle, &conf->root, 0) != NGX_OK) {
  3689.                 return NGX_CONF_ERROR;
  3690.             }
  3691.         }
  3692.     }

  3694.     if (conf->post_action.data == NULL) {
  3695.         conf->post_action = prev->post_action;
  3696.     }

  3698.     ngx_conf_merge_uint_value(conf->types_hash_max_size,
  3699.                               prev->types_hash_max_size, 1024);

  3701.     ngx_conf_merge_uint_value(conf->types_hash_bucket_size,
  3702.                               prev->types_hash_bucket_size, 64);

  3704.     conf->types_hash_bucket_size = ngx_align(conf->types_hash_bucket_size,
  3705.                                              ngx_cacheline_size);

  3707.     /*
  3708.      * the special handling of the "types" directive in the "http" section
  3709.      * to inherit the http's conf->types_hash to all servers
  3710.      */

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

  3714.         types_hash.hash = &prev->types_hash;
  3715.         types_hash.key = ngx_hash_key_lc;
  3716.         types_hash.max_size = conf->types_hash_max_size;
  3717.         types_hash.bucket_size = conf->types_hash_bucket_size;
  3718.         types_hash.name = "types_hash";
  3719.         types_hash.pool = cf->pool;
  3720.         types_hash.temp_pool = NULL;

  3722.         if (ngx_hash_init(&types_hash, prev->types->elts, prev->types->nelts)
  3723.             != NGX_OK)
  3724.         {
  3725.             return NGX_CONF_ERROR;
  3726.         }
  3727.     }

  3729.     if (conf->types == NULL) {
  3730.         conf->types = prev->types;
  3731.         conf->types_hash = prev->types_hash;
  3732.     }

  3734.     if (conf->types == NULL) {
  3735.         conf->types = ngx_array_create(cf->pool, 3, sizeof(ngx_hash_key_t));
  3736.         if (conf->types == NULL) {
  3737.             return NGX_CONF_ERROR;
  3738.         }

  3740.         for (i = 0; ngx_http_core_default_types[i].key.len; i++) {
  3741.             type = ngx_array_push(conf->types);
  3742.             if (type == NULL) {
  3743.                 return NGX_CONF_ERROR;
  3744.             }

  3746.             type->key = ngx_http_core_default_types[i].key;
  3747.             type->key_hash =
  3748.                        ngx_hash_key_lc(ngx_http_core_default_types[i].key.data,
  3749.                                        ngx_http_core_default_types[i].key.len);
  3750.             type->value = ngx_http_core_default_types[i].value;
  3751.         }
  3752.     }

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

  3756.         types_hash.hash = &conf->types_hash;
  3757.         types_hash.key = ngx_hash_key_lc;
  3758.         types_hash.max_size = conf->types_hash_max_size;
  3759.         types_hash.bucket_size = conf->types_hash_bucket_size;
  3760.         types_hash.name = "types_hash";
  3761.         types_hash.pool = cf->pool;
  3762.         types_hash.temp_pool = NULL;

  3764.         if (ngx_hash_init(&types_hash, conf->types->elts, conf->types->nelts)
  3765.             != NGX_OK)
  3766.         {
  3767.             return NGX_CONF_ERROR;
  3768.         }
  3769.     }

  3771.     if (conf->error_log == NULL) {
  3772.         if (prev->error_log) {
  3773.             conf->error_log = prev->error_log;
  3774.         } else {
  3775.             conf->error_log = &cf->cycle->new_log;
  3776.         }
  3777.     }

  3779.     if (conf->error_pages == NULL && prev->error_pages) {
  3780.         conf->error_pages = prev->error_pages;
  3781.     }

  3783.     ngx_conf_merge_str_value(conf->default_type,
  3784.                               prev->default_type, "text/plain");

  3786.     ngx_conf_merge_off_value(conf->client_max_body_size,
  3787.                               prev->client_max_body_size, 1 * 1024 * 1024);
  3788.     ngx_conf_merge_size_value(conf->client_body_buffer_size,
  3789.                               prev->client_body_buffer_size,
  3790.                               (size_t) 2 * ngx_pagesize);
  3791.     ngx_conf_merge_msec_value(conf->client_body_timeout,
  3792.                               prev->client_body_timeout, 60000);

  3794.     ngx_conf_merge_bitmask_value(conf->keepalive_disable,
  3795.                               prev->keepalive_disable,
  3796.                               (NGX_CONF_BITMASK_SET
  3797.                                |NGX_HTTP_KEEPALIVE_DISABLE_MSIE6));
  3798.     ngx_conf_merge_uint_value(conf->satisfy, prev->satisfy,
  3799.                               NGX_HTTP_SATISFY_ALL);
  3800.     ngx_conf_merge_msec_value(conf->auth_delay, prev->auth_delay, 0);
  3801.     ngx_conf_merge_uint_value(conf->if_modified_since, prev->if_modified_since,
  3802.                               NGX_HTTP_IMS_EXACT);
  3803.     ngx_conf_merge_uint_value(conf->max_ranges, prev->max_ranges,
  3804.                               NGX_MAX_INT32_VALUE);
  3805.     ngx_conf_merge_uint_value(conf->client_body_in_file_only,
  3806.                               prev->client_body_in_file_only,
  3807.                               NGX_HTTP_REQUEST_BODY_FILE_OFF);
  3808.     ngx_conf_merge_value(conf->client_body_in_single_buffer,
  3809.                               prev->client_body_in_single_buffer, 0);
  3810.     ngx_conf_merge_value(conf->internal, prev->internal, 0);
  3811.     ngx_conf_merge_value(conf->sendfile, prev->sendfile, 0);
  3812.     ngx_conf_merge_size_value(conf->sendfile_max_chunk,
  3813.                               prev->sendfile_max_chunk, 2 * 1024 * 1024);
  3814.     ngx_conf_merge_size_value(conf->subrequest_output_buffer_size,
  3815.                               prev->subrequest_output_buffer_size,
  3816.                               (size_t) ngx_pagesize);
  3817.     ngx_conf_merge_value(conf->aio, prev->aio, NGX_HTTP_AIO_OFF);
  3818.     ngx_conf_merge_value(conf->aio_write, prev->aio_write, 0);
  3819. #if (NGX_THREADS)
  3820.     ngx_conf_merge_ptr_value(conf->thread_pool, prev->thread_pool, NULL);
  3821.     ngx_conf_merge_ptr_value(conf->thread_pool_value, prev->thread_pool_value,
  3822.                              NULL);
  3823. #endif
  3824.     ngx_conf_merge_size_value(conf->read_ahead, prev->read_ahead, 0);
  3825.     ngx_conf_merge_off_value(conf->directio, prev->directio,
  3826.                               NGX_OPEN_FILE_DIRECTIO_OFF);
  3827.     ngx_conf_merge_off_value(conf->directio_alignment, prev->directio_alignment,
  3828.                               512);
  3829.     ngx_conf_merge_value(conf->tcp_nopush, prev->tcp_nopush, 0);
  3830.     ngx_conf_merge_value(conf->tcp_nodelay, prev->tcp_nodelay, 1);

  3832.     ngx_conf_merge_msec_value(conf->send_timeout, prev->send_timeout, 60000);
  3833.     ngx_conf_merge_size_value(conf->send_lowat, prev->send_lowat, 0);
  3834.     ngx_conf_merge_size_value(conf->postpone_output, prev->postpone_output,
  3835.                               1460);

  3837.     ngx_conf_merge_ptr_value(conf->limit_rate, prev->limit_rate, NULL);
  3838.     ngx_conf_merge_ptr_value(conf->limit_rate_after,
  3839.                               prev->limit_rate_after, NULL);

  3841.     ngx_conf_merge_msec_value(conf->keepalive_time,
  3842.                               prev->keepalive_time, 3600000);
  3843.     ngx_conf_merge_msec_value(conf->keepalive_timeout,
  3844.                               prev->keepalive_timeout, 75000);
  3845.     ngx_conf_merge_sec_value(conf->keepalive_header,
  3846.                               prev->keepalive_header, 0);
  3847.     ngx_conf_merge_uint_value(conf->keepalive_requests,
  3848.                               prev->keepalive_requests, 1000);
  3849.     ngx_conf_merge_uint_value(conf->lingering_close,
  3850.                               prev->lingering_close, NGX_HTTP_LINGERING_ON);
  3851.     ngx_conf_merge_msec_value(conf->lingering_time,
  3852.                               prev->lingering_time, 30000);
  3853.     ngx_conf_merge_msec_value(conf->lingering_timeout,
  3854.                               prev->lingering_timeout, 5000);
  3855.     ngx_conf_merge_msec_value(conf->resolver_timeout,
  3856.                               prev->resolver_timeout, 30000);

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

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

  3862.             /*
  3863.              * create dummy resolver in http {} context
  3864.              * to inherit it in all servers
  3865.              */

  3867.             prev->resolver = ngx_resolver_create(cf, NULL, 0);
  3868.             if (prev->resolver == NULL) {
  3869.                 return NGX_CONF_ERROR;
  3870.             }
  3871.         }

  3873.         conf->resolver = prev->resolver;
  3874.     }

  3876.     if (ngx_conf_merge_path_value(cf, &conf->client_body_temp_path,
  3877.                               prev->client_body_temp_path,
  3878.                               &ngx_http_client_temp_path)
  3879.         != NGX_OK)
  3880.     {
  3881.         return NGX_CONF_ERROR;
  3882.     }

  3884.     ngx_conf_merge_value(conf->reset_timedout_connection,
  3885.                               prev->reset_timedout_connection, 0);
  3886.     ngx_conf_merge_value(conf->absolute_redirect,
  3887.                               prev->absolute_redirect, 1);
  3888.     ngx_conf_merge_value(conf->server_name_in_redirect,
  3889.                               prev->server_name_in_redirect, 0);
  3890.     ngx_conf_merge_value(conf->port_in_redirect, prev->port_in_redirect, 1);
  3891.     ngx_conf_merge_value(conf->msie_padding, prev->msie_padding, 1);
  3892.     ngx_conf_merge_value(conf->msie_refresh, prev->msie_refresh, 0);
  3893.     ngx_conf_merge_value(conf->log_not_found, prev->log_not_found, 1);
  3894.     ngx_conf_merge_value(conf->log_subrequest, prev->log_subrequest, 0);
  3895.     ngx_conf_merge_value(conf->recursive_error_pages,
  3896.                               prev->recursive_error_pages, 0);
  3897.     ngx_conf_merge_value(conf->chunked_transfer_encoding,
  3898.                               prev->chunked_transfer_encoding, 1);
  3899.     ngx_conf_merge_value(conf->etag, prev->etag, 1);

  3901.     ngx_conf_merge_uint_value(conf->server_tokens, prev->server_tokens,
  3902.                               NGX_HTTP_SERVER_TOKENS_ON);

  3904.     ngx_conf_merge_ptr_value(conf->open_file_cache,
  3905.                               prev->open_file_cache, NULL);

  3907.     ngx_conf_merge_sec_value(conf->open_file_cache_valid,
  3908.                               prev->open_file_cache_valid, 60);

  3910.     ngx_conf_merge_uint_value(conf->open_file_cache_min_uses,
  3911.                               prev->open_file_cache_min_uses, 1);

  3913.     ngx_conf_merge_sec_value(conf->open_file_cache_errors,
  3914.                               prev->open_file_cache_errors, 0);

  3916.     ngx_conf_merge_sec_value(conf->open_file_cache_events,
  3917.                               prev->open_file_cache_events, 0);
  3918. #if (NGX_HTTP_GZIP)

  3920.     ngx_conf_merge_value(conf->gzip_vary, prev->gzip_vary, 0);
  3921.     ngx_conf_merge_uint_value(conf->gzip_http_version, prev->gzip_http_version,
  3922.                               NGX_HTTP_VERSION_11);
  3923.     ngx_conf_merge_bitmask_value(conf->gzip_proxied, prev->gzip_proxied,
  3924.                               (NGX_CONF_BITMASK_SET|NGX_HTTP_GZIP_PROXIED_OFF));

  3926. #if (NGX_PCRE)
  3927.     ngx_conf_merge_ptr_value(conf->gzip_disable, prev->gzip_disable, NULL);
  3928. #endif

  3930.     if (conf->gzip_disable_msie6 == 3) {
  3931.         conf->gzip_disable_msie6 =
  3932.             (prev->gzip_disable_msie6 == 3) ? 0 : prev->gzip_disable_msie6;
  3933.     }

  3935. #if (NGX_HTTP_DEGRADATION)

  3937.     if (conf->gzip_disable_degradation == 3) {
  3938.         conf->gzip_disable_degradation =
  3939.             (prev->gzip_disable_degradation == 3) ?
  3940.                  0 : prev->gzip_disable_degradation;
  3941.     }

  3943. #endif
  3944. #endif

  3946. #if (NGX_HAVE_OPENAT)
  3947.     ngx_conf_merge_uint_value(conf->disable_symlinks, prev->disable_symlinks,
  3948.                               NGX_DISABLE_SYMLINKS_OFF);
  3949.     ngx_conf_merge_ptr_value(conf->disable_symlinks_from,
  3950.                              prev->disable_symlinks_from, NULL);
  3951. #endif

  3953.     return NGX_CONF_OK;
  3954. }


  3957. static char *
  3958. ‌ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3959. {
  3960.     ngx_http_core_srv_conf_t *cscf = conf;

  3962.     ngx_str_t              *value, size;
  3963.     ngx_url_t               u;
  3964.     ngx_uint_t              n, i, backlog;
  3965.     ngx_http_listen_opt_t   lsopt;

  3967.     cscf->listen = 1;

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

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

  3973.     u.url = value[1];
  3974.     u.listen = 1;
  3975.     u.default_port = 80;

  3977.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  3978.         if (u.err) {
  3979.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3980.                                "%s in \"%V\" of the \"listen\" directive",
  3981.                                u.err, &u.url);
  3982.         }

  3984.         return NGX_CONF_ERROR;
  3985.     }

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

  3989.     lsopt.backlog = NGX_LISTEN_BACKLOG;
  3990.     lsopt.type = SOCK_STREAM;
  3991.     lsopt.rcvbuf = -1;
  3992.     lsopt.sndbuf = -1;
  3993. #if (NGX_HAVE_SETFIB)
  3994.     lsopt.setfib = -1;
  3995. #endif
  3996. #if (NGX_HAVE_TCP_FASTOPEN)
  3997.     lsopt.fastopen = -1;
  3998. #endif
  3999. #if (NGX_HAVE_INET6)
  4000.     lsopt.ipv6only = 1;
  4001. #endif

  4003.     backlog = 0;

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

  4007.         if (ngx_strcmp(value[n].data, "default_server") == 0
  4008.             || ngx_strcmp(value[n].data, "default") == 0)
  4009.         {
  4010.             lsopt.default_server = 1;
  4011.             continue;
  4012.         }

  4014.         if (ngx_strcmp(value[n].data, "bind") == 0) {
  4015.             lsopt.set = 1;
  4016.             lsopt.bind = 1;
  4017.             continue;
  4018.         }

  4020. #if (NGX_HAVE_SETFIB)
  4021.         if (ngx_strncmp(value[n].data, "setfib=", 7) == 0) {
  4022.             lsopt.setfib = ngx_atoi(value[n].data + 7, value[n].len - 7);
  4023.             lsopt.set = 1;
  4024.             lsopt.bind = 1;

  4026.             if (lsopt.setfib == NGX_ERROR) {
  4027.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4028.                                    "invalid setfib \"%V\"", &value[n]);
  4029.                 return NGX_CONF_ERROR;
  4030.             }

  4032.             continue;
  4033.         }
  4034. #endif

  4036. #if (NGX_HAVE_TCP_FASTOPEN)
  4037.         if (ngx_strncmp(value[n].data, "fastopen=", 9) == 0) {
  4038.             lsopt.fastopen = ngx_atoi(value[n].data + 9, value[n].len - 9);
  4039.             lsopt.set = 1;
  4040.             lsopt.bind = 1;

  4042.             if (lsopt.fastopen == NGX_ERROR) {
  4043.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4044.                                    "invalid fastopen \"%V\"", &value[n]);
  4045.                 return NGX_CONF_ERROR;
  4046.             }

  4048.             continue;
  4049.         }
  4050. #endif

  4052.         if (ngx_strncmp(value[n].data, "backlog=", 8) == 0) {
  4053.             lsopt.backlog = ngx_atoi(value[n].data + 8, value[n].len - 8);
  4054.             lsopt.set = 1;
  4055.             lsopt.bind = 1;

  4057.             if (lsopt.backlog == NGX_ERROR || lsopt.backlog == 0) {
  4058.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4059.                                    "invalid backlog \"%V\"", &value[n]);
  4060.                 return NGX_CONF_ERROR;
  4061.             }

  4063.             backlog = 1;

  4065.             continue;
  4066.         }

  4068.         if (ngx_strncmp(value[n].data, "rcvbuf=", 7) == 0) {
  4069.             size.len = value[n].len - 7;
  4070.             size.data = value[n].data + 7;

  4072.             lsopt.rcvbuf = ngx_parse_size(&size);
  4073.             lsopt.set = 1;
  4074.             lsopt.bind = 1;

  4076.             if (lsopt.rcvbuf == NGX_ERROR) {
  4077.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4078.                                    "invalid rcvbuf \"%V\"", &value[n]);
  4079.                 return NGX_CONF_ERROR;
  4080.             }

  4082.             continue;
  4083.         }

  4085.         if (ngx_strncmp(value[n].data, "sndbuf=", 7) == 0) {
  4086.             size.len = value[n].len - 7;
  4087.             size.data = value[n].data + 7;

  4089.             lsopt.sndbuf = ngx_parse_size(&size);
  4090.             lsopt.set = 1;
  4091.             lsopt.bind = 1;

  4093.             if (lsopt.sndbuf == NGX_ERROR) {
  4094.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4095.                                    "invalid sndbuf \"%V\"", &value[n]);
  4096.                 return NGX_CONF_ERROR;
  4097.             }

  4099.             continue;
  4100.         }

  4102.         if (ngx_strncmp(value[n].data, "accept_filter=", 14) == 0) {
  4103. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  4104.             lsopt.accept_filter = (char *) &value[n].data[14];
  4105.             lsopt.set = 1;
  4106.             lsopt.bind = 1;
  4107. #else
  4108.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4109.                                "accept filters \"%V\" are not supported "
  4110.                                "on this platform, ignored",
  4111.                                &value[n]);
  4112. #endif
  4113.             continue;
  4114.         }

  4116.         if (ngx_strcmp(value[n].data, "deferred") == 0) {
  4117. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  4118.             lsopt.deferred_accept = 1;
  4119.             lsopt.set = 1;
  4120.             lsopt.bind = 1;
  4121. #else
  4122.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4123.                                "the deferred accept is not supported "
  4124.                                "on this platform, ignored");
  4125. #endif
  4126.             continue;
  4127.         }

  4129.         if (ngx_strncmp(value[n].data, "ipv6only=o", 10) == 0) {
  4130. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  4131.             if (ngx_strcmp(&value[n].data[10], "n") == 0) {
  4132.                 lsopt.ipv6only = 1;

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

  4137.             } else {
  4138.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4139.                                    "invalid ipv6only flags \"%s\"",
  4140.                                    &value[n].data[9]);
  4141.                 return NGX_CONF_ERROR;
  4142.             }

  4144.             lsopt.set = 1;
  4145.             lsopt.bind = 1;

  4147.             continue;
  4148. #else
  4149.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4150.                                "ipv6only is not supported "
  4151.                                "on this platform");
  4152.             return NGX_CONF_ERROR;
  4153. #endif
  4154.         }

  4156.         if (ngx_strcmp(value[n].data, "reuseport") == 0) {
  4157. #if (NGX_HAVE_REUSEPORT)
  4158.             lsopt.reuseport = 1;
  4159.             lsopt.set = 1;
  4160.             lsopt.bind = 1;
  4161. #else
  4162.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4163.                                "reuseport is not supported "
  4164.                                "on this platform, ignored");
  4165. #endif
  4166.             continue;
  4167.         }

  4169.         if (ngx_strcmp(value[n].data, "ssl") == 0) {
  4170. #if (NGX_HTTP_SSL)
  4171.             lsopt.ssl = 1;
  4172.             continue;
  4173. #else
  4174.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4175.                                "the \"ssl\" parameter requires "
  4176.                                "ngx_http_ssl_module");
  4177.             return NGX_CONF_ERROR;
  4178. #endif
  4179.         }

  4181.         if (ngx_strcmp(value[n].data, "http2") == 0) {
  4182. #if (NGX_HTTP_V2)
  4183.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  4184.                                "the \"listen ... http2\" directive "
  4185.                                "is deprecated, use "
  4186.                                "the \"http2\" directive instead");

  4188.             lsopt.http2 = 1;
  4189.             continue;
  4190. #else
  4191.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4192.                                "the \"http2\" parameter requires "
  4193.                                "ngx_http_v2_module");
  4194.             return NGX_CONF_ERROR;
  4195. #endif
  4196.         }

  4198.         if (ngx_strcmp(value[n].data, "quic") == 0) {
  4199. #if (NGX_HTTP_V3)
  4200.             lsopt.quic = 1;
  4201.             lsopt.type = SOCK_DGRAM;
  4202.             continue;
  4203. #else
  4204.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4205.                                "the \"quic\" parameter requires "
  4206.                                "ngx_http_v3_module");
  4207.             return NGX_CONF_ERROR;
  4208. #endif
  4209.         }

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

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

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

  4219.             } else {

  4221. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  4222.                 u_char     *p, *end;
  4223.                 ngx_str_t   s;

  4225.                 end = value[n].data + value[n].len;
  4226.                 s.data = value[n].data + 13;

  4228.                 p = ngx_strlchr(s.data, end, ':');
  4229.                 if (p == NULL) {
  4230.                     p = end;
  4231.                 }

  4233.                 if (p > s.data) {
  4234.                     s.len = p - s.data;

  4236.                     lsopt.tcp_keepidle = ngx_parse_time(&s, 1);
  4237.                     if (lsopt.tcp_keepidle == (time_t) NGX_ERROR) {
  4238.                         goto invalid_so_keepalive;
  4239.                     }
  4240.                 }

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

  4244.                 p = ngx_strlchr(s.data, end, ':');
  4245.                 if (p == NULL) {
  4246.                     p = end;
  4247.                 }

  4249.                 if (p > s.data) {
  4250.                     s.len = p - s.data;

  4252.                     lsopt.tcp_keepintvl = ngx_parse_time(&s, 1);
  4253.                     if (lsopt.tcp_keepintvl == (time_t) NGX_ERROR) {
  4254.                         goto invalid_so_keepalive;
  4255.                     }
  4256.                 }

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

  4260.                 if (s.data < end) {
  4261.                     s.len = end - s.data;

  4263.                     lsopt.tcp_keepcnt = ngx_atoi(s.data, s.len);
  4264.                     if (lsopt.tcp_keepcnt == NGX_ERROR) {
  4265.                         goto invalid_so_keepalive;
  4266.                     }
  4267.                 }

  4269.                 if (lsopt.tcp_keepidle == 0 && lsopt.tcp_keepintvl == 0
  4270.                     && lsopt.tcp_keepcnt == 0)
  4271.                 {
  4272.                     goto invalid_so_keepalive;
  4273.                 }

  4275.                 lsopt.so_keepalive = 1;

  4277. #else

  4279.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4280.                                    "the \"so_keepalive\" parameter accepts "
  4281.                                    "only \"on\" or \"off\" on this platform");
  4282.                 return NGX_CONF_ERROR;

  4284. #endif
  4285.             }

  4287.             lsopt.set = 1;
  4288.             lsopt.bind = 1;

  4290.             continue;

  4292. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  4293.         invalid_so_keepalive:

  4295.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4296.                                "invalid so_keepalive value: \"%s\"",
  4297.                                &value[n].data[13]);
  4298.             return NGX_CONF_ERROR;
  4299. #endif
  4300.         }

  4302.         if (ngx_strcmp(value[n].data, "proxy_protocol") == 0) {
  4303.             lsopt.proxy_protocol = 1;
  4304.             continue;
  4305.         }

  4307.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4308.                            "invalid parameter \"%V\"", &value[n]);
  4309.         return NGX_CONF_ERROR;
  4310.     }

  4312.     if (lsopt.quic) {
  4313. #if (NGX_HAVE_TCP_FASTOPEN)
  4314.         if (lsopt.fastopen != -1) {
  4315.             return "\"fastopen\" parameter is incompatible with \"quic\"";
  4316.         }
  4317. #endif

  4319.         if (backlog) {
  4320.             return "\"backlog\" parameter is incompatible with \"quic\"";
  4321.         }

  4323. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  4324.         if (lsopt.accept_filter) {
  4325.             return "\"accept_filter\" parameter is incompatible with \"quic\"";
  4326.         }
  4327. #endif

  4329. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  4330.         if (lsopt.deferred_accept) {
  4331.             return "\"deferred\" parameter is incompatible with \"quic\"";
  4332.         }
  4333. #endif

  4335. #if (NGX_HTTP_SSL)
  4336.         if (lsopt.ssl) {
  4337.             return "\"ssl\" parameter is incompatible with \"quic\"";
  4338.         }
  4339. #endif

  4341. #if (NGX_HTTP_V2)
  4342.         if (lsopt.http2) {
  4343.             return "\"http2\" parameter is incompatible with \"quic\"";
  4344.         }
  4345. #endif

  4347.         if (lsopt.so_keepalive) {
  4348.             return "\"so_keepalive\" parameter is incompatible with \"quic\"";
  4349.         }

  4351.         if (lsopt.proxy_protocol) {
  4352.             return "\"proxy_protocol\" parameter is incompatible with \"quic\"";
  4353.         }
  4354.     }

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

  4358.         for (i = 0; i < n; i++) {
  4359.             if (ngx_cmp_sockaddr(u.addrs[n].sockaddr, u.addrs[n].socklen,
  4360.                                  u.addrs[i].sockaddr, u.addrs[i].socklen, 1)
  4361.                 == NGX_OK)
  4362.             {
  4363.                 goto next;
  4364.             }
  4365.         }

  4367.         lsopt.sockaddr = u.addrs[n].sockaddr;
  4368.         lsopt.socklen = u.addrs[n].socklen;
  4369.         lsopt.addr_text = u.addrs[n].name;
  4370.         lsopt.wildcard = ngx_inet_wildcard(lsopt.sockaddr);

  4372.         if (ngx_http_add_listen(cf, cscf, &lsopt) != NGX_OK) {
  4373.             return NGX_CONF_ERROR;
  4374.         }

  4376.     next:
  4377.         continue;
  4378.     }

  4380.     return NGX_CONF_OK;
  4381. }


  4384. static char *
  4385. ‌ngx_http_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4386. {
  4387.     ngx_http_core_srv_conf_t *cscf = conf;

  4389.     u_char                   ch;
  4390.     ngx_str_t               *value;
  4391.     ngx_uint_t               i;
  4392.     ngx_http_server_name_t  *sn;

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

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

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

  4400.         if ((ch == '*' && (value[i].len < 3 || value[i].data[1] != '.'))
  4401.             || (ch == '.' && value[i].len < 2))
  4402.         {
  4403.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4404.                                "server name \"%V\" is invalid", &value[i]);
  4405.             return NGX_CONF_ERROR;
  4406.         }

  4408.         if (ngx_strchr(value[i].data, '/')) {
  4409.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  4410.                                "server name \"%V\" has suspicious symbols",
  4411.                                &value[i]);
  4412.         }

  4414.         sn = ngx_array_push(&cscf->server_names);
  4415.         if (sn == NULL) {
  4416.             return NGX_CONF_ERROR;
  4417.         }

  4419. #if (NGX_PCRE)
  4420.         sn->regex = NULL;
  4421. #endif
  4422.         sn->server = cscf;

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

  4427.         } else {
  4428.             sn->name = value[i];
  4429.         }

  4431.         if (value[i].data[0] != '~') {
  4432.             ngx_strlow(sn->name.data, sn->name.data, sn->name.len);
  4433.             continue;
  4434.         }

  4436. #if (NGX_PCRE)
  4437.         {
  4438.         u_char               *p;
  4439.         ngx_regex_compile_t   rc;
  4440.         u_char                errstr[NGX_MAX_CONF_ERRSTR];

  4442.         if (value[i].len == 1) {
  4443.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4444.                                "empty regex in server name \"%V\"", &value[i]);
  4445.             return NGX_CONF_ERROR;
  4446.         }

  4448.         value[i].len--;
  4449.         value[i].data++;

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

  4453.         rc.pattern = value[i];
  4454.         rc.err.len = NGX_MAX_CONF_ERRSTR;
  4455.         rc.err.data = errstr;

  4457.         for (p = value[i].data; p < value[i].data + value[i].len; p++) {
  4458.             if (*p >= 'A' && *p <= 'Z') {
  4459.                 rc.options = NGX_REGEX_CASELESS;
  4460.                 break;
  4461.             }
  4462.         }

  4464.         sn->regex = ngx_http_regex_compile(cf, &rc);
  4465.         if (sn->regex == NULL) {
  4466.             return NGX_CONF_ERROR;
  4467.         }

  4469.         sn->name = value[i];
  4470.         cscf->captures = (rc.captures > 0);
  4471.         }
  4472. #else
  4473.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4474.                            "using regex \"%V\" "
  4475.                            "requires PCRE library", &value[i]);

  4477.         return NGX_CONF_ERROR;
  4478. #endif
  4479.     }

  4481.     return NGX_CONF_OK;
  4482. }


  4485. static char *
  4486. ‌ngx_http_core_root(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4487. {
  4488.     ngx_http_core_loc_conf_t *clcf = conf;

  4490.     ngx_str_t                  *value;
  4491.     ngx_int_t                   alias;
  4492.     ngx_uint_t                  n;
  4493.     ngx_http_script_compile_t   sc;

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

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

  4499.         if ((clcf->alias != 0) == alias) {
  4500.             return "is duplicate";
  4501.         }

  4503.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4504.                            "\"%V\" directive is duplicate, "
  4505.                            "\"%s\" directive was specified earlier",
  4506.                            &cmd->name, clcf->alias ? "alias" : "root");

  4508.         return NGX_CONF_ERROR;
  4509.     }

  4511.     if (clcf->named && alias) {
  4512.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4513.                            "the \"alias\" directive cannot be used "
  4514.                            "inside the named location");

  4516.         return NGX_CONF_ERROR;
  4517.     }

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

  4521.     if (ngx_strstr(value[1].data, "$document_root")
  4522.         || ngx_strstr(value[1].data, "${document_root}"))
  4523.     {
  4524.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4525.                            "the $document_root variable cannot be used "
  4526.                            "in the \"%V\" directive",
  4527.                            &cmd->name);

  4529.         return NGX_CONF_ERROR;
  4530.     }

  4532.     if (ngx_strstr(value[1].data, "$realpath_root")
  4533.         || ngx_strstr(value[1].data, "${realpath_root}"))
  4534.     {
  4535.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4536.                            "the $realpath_root variable cannot be used "
  4537.                            "in the \"%V\" directive",
  4538.                            &cmd->name);

  4540.         return NGX_CONF_ERROR;
  4541.     }

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

  4546.     if (!alias && clcf->root.len > 0
  4547.         && clcf->root.data[clcf->root.len - 1] == '/')
  4548.     {
  4549.         clcf->root.len--;
  4550.     }

  4552.     if (clcf->root.data[0] != '$') {
  4553.         if (ngx_conf_full_name(cf->cycle, &clcf->root, 0) != NGX_OK) {
  4554.             return NGX_CONF_ERROR;
  4555.         }
  4556.     }

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

  4560.     ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
  4561.     sc.variables = n;

  4563. #if (NGX_PCRE)
  4564.     if (alias && clcf->regex) {
  4565.         clcf->alias = NGX_MAX_SIZE_T_VALUE;
  4566.         n = 1;
  4567.     }
  4568. #endif

  4570.     if (n) {
  4571.         sc.cf = cf;
  4572.         sc.source = &clcf->root;
  4573.         sc.lengths = &clcf->root_lengths;
  4574.         sc.values = &clcf->root_values;
  4575.         sc.complete_lengths = 1;
  4576.         sc.complete_values = 1;

  4578.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  4579.             return NGX_CONF_ERROR;
  4580.         }
  4581.     }

  4583.     return NGX_CONF_OK;
  4584. }


  4587. ‌static ngx_http_method_name_t  ngx_methods_names[] = {
  4588.     { (u_char *) "GET",       (uint32_t) ~NGX_HTTP_GET },
  4589.     { (u_char *) "HEAD",      (uint32_t) ~NGX_HTTP_HEAD },
  4590.     { (u_char *) "POST",      (uint32_t) ~NGX_HTTP_POST },
  4591.     { (u_char *) "PUT",       (uint32_t) ~NGX_HTTP_PUT },
  4592.     { (u_char *) "DELETE",    (uint32_t) ~NGX_HTTP_DELETE },
  4593.     { (u_char *) "MKCOL",     (uint32_t) ~NGX_HTTP_MKCOL },
  4594.     { (u_char *) "COPY",      (uint32_t) ~NGX_HTTP_COPY },
  4595.     { (u_char *) "MOVE",      (uint32_t) ~NGX_HTTP_MOVE },
  4596.     { (u_char *) "OPTIONS",   (uint32_t) ~NGX_HTTP_OPTIONS },
  4597.     { (u_char *) "PROPFIND",  (uint32_t) ~NGX_HTTP_PROPFIND },
  4598.     { (u_char *) "PROPPATCH", (uint32_t) ~NGX_HTTP_PROPPATCH },
  4599.     { (u_char *) "LOCK",      (uint32_t) ~NGX_HTTP_LOCK },
  4600.     { (u_char *) "UNLOCK",    (uint32_t) ~NGX_HTTP_UNLOCK },
  4601.     { (u_char *) "PATCH",     (uint32_t) ~NGX_HTTP_PATCH },
  4602.     { NULL, 0 }
  4603. };


  4606. static char *
  4607. ‌ngx_http_core_limit_except(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4608. {
  4609.     ngx_http_core_loc_conf_t *pclcf = conf;

  4611.     char                      *rv;
  4612.     void                      *mconf;
  4613.     ngx_str_t                 *value;
  4614.     ngx_uint_t                 i;
  4615.     ngx_conf_t                 save;
  4616.     ngx_http_module_t         *module;
  4617.     ngx_http_conf_ctx_t       *ctx, *pctx;
  4618.     ngx_http_method_name_t    *name;
  4619.     ngx_http_core_loc_conf_t  *clcf;

  4621.     if (pclcf->limit_except) {
  4622.         return "is duplicate";
  4623.     }

  4625.     pclcf->limit_except = 0xffffffff;

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

  4629.     for (i = 1; i < cf->args->nelts; i++) {
  4630.         for (name = ngx_methods_names; name->name; name++) {

  4632.             if (ngx_strcasecmp(value[i].data, name->name) == 0) {
  4633.                 pclcf->limit_except &= name->method;
  4634.                 goto next;
  4635.             }
  4636.         }

  4638.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4639.                            "invalid method \"%V\"", &value[i]);
  4640.         return NGX_CONF_ERROR;

  4642.     next:
  4643.         continue;
  4644.     }

  4646.     if (!(pclcf->limit_except & NGX_HTTP_GET)) {
  4647.         pclcf->limit_except &= (uint32_t) ~NGX_HTTP_HEAD;
  4648.     }

  4650.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  4651.     if (ctx == NULL) {
  4652.         return NGX_CONF_ERROR;
  4653.     }

  4655.     pctx = cf->ctx;
  4656.     ctx->main_conf = pctx->main_conf;
  4657.     ctx->srv_conf = pctx->srv_conf;

  4659.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  4660.     if (ctx->loc_conf == NULL) {
  4661.         return NGX_CONF_ERROR;
  4662.     }

  4664.     for (i = 0; cf->cycle->modules[i]; i++) {
  4665.         if (cf->cycle->modules[i]->type != NGX_HTTP_MODULE) {
  4666.             continue;
  4667.         }

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

  4671.         if (module->create_loc_conf) {

  4673.             mconf = module->create_loc_conf(cf);
  4674.             if (mconf == NULL) {
  4675.                 return NGX_CONF_ERROR;
  4676.             }

  4678.             ctx->loc_conf[cf->cycle->modules[i]->ctx_index] = mconf;
  4679.         }
  4680.     }


  4683.     clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
  4684.     pclcf->limit_except_loc_conf = ctx->loc_conf;
  4685.     clcf->loc_conf = ctx->loc_conf;
  4686.     clcf->name = pclcf->name;
  4687.     clcf->noname = 1;
  4688.     clcf->lmt_excpt = 1;

  4690.     if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
  4691.         return NGX_CONF_ERROR;
  4692.     }

  4694.     save = *cf;
  4695.     cf->ctx = ctx;
  4696.     cf->cmd_type = NGX_HTTP_LMT_CONF;

  4698.     rv = ngx_conf_parse(cf, NULL);

  4700.     *cf = save;

  4702.     return rv;
  4703. }


  4706. static char *
  4707. ‌ngx_http_core_set_aio(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4708. {
  4709.     ngx_http_core_loc_conf_t *clcf = conf;

  4711.     ngx_str_t  *value;

  4713.     if (clcf->aio != NGX_CONF_UNSET) {
  4714.         return "is duplicate";
  4715.     }

  4717. #if (NGX_THREADS)
  4718.     clcf->thread_pool = NULL;
  4719.     clcf->thread_pool_value = NULL;
  4720. #endif

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

  4724.     if (ngx_strcmp(value[1].data, "off") == 0) {
  4725.         clcf->aio = NGX_HTTP_AIO_OFF;
  4726.         return NGX_CONF_OK;
  4727.     }

  4729.     if (ngx_strcmp(value[1].data, "on") == 0) {
  4730. #if (NGX_HAVE_FILE_AIO)
  4731.         clcf->aio = NGX_HTTP_AIO_ON;
  4732.         return NGX_CONF_OK;
  4733. #else
  4734.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4735.                            "\"aio on\" "
  4736.                            "is unsupported on this platform");
  4737.         return NGX_CONF_ERROR;
  4738. #endif
  4739.     }

  4741.     if (ngx_strncmp(value[1].data, "threads", 7) == 0
  4742.         && (value[1].len == 7 || value[1].data[7] == '='))
  4743.     {
  4744. #if (NGX_THREADS)
  4745.         ngx_str_t                          name;
  4746.         ngx_thread_pool_t                 *tp;
  4747.         ngx_http_complex_value_t           cv;
  4748.         ngx_http_compile_complex_value_t   ccv;

  4750.         clcf->aio = NGX_HTTP_AIO_THREADS;

  4752.         if (value[1].len >= 8) {
  4753.             name.len = value[1].len - 8;
  4754.             name.data = value[1].data + 8;

  4756.             ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  4758.             ccv.cf = cf;
  4759.             ccv.value = &name;
  4760.             ccv.complex_value = &cv;

  4762.             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  4763.                 return NGX_CONF_ERROR;
  4764.             }

  4766.             if (cv.lengths != NULL) {
  4767.                 clcf->thread_pool_value = ngx_palloc(cf->pool,
  4768.                                     sizeof(ngx_http_complex_value_t));
  4769.                 if (clcf->thread_pool_value == NULL) {
  4770.                     return NGX_CONF_ERROR;
  4771.                 }

  4773.                 *clcf->thread_pool_value = cv;

  4775.                 return NGX_CONF_OK;
  4776.             }

  4778.             tp = ngx_thread_pool_add(cf, &name);

  4780.         } else {
  4781.             tp = ngx_thread_pool_add(cf, NULL);
  4782.         }

  4784.         if (tp == NULL) {
  4785.             return NGX_CONF_ERROR;
  4786.         }

  4788.         clcf->thread_pool = tp;

  4790.         return NGX_CONF_OK;
  4791. #else
  4792.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4793.                            "\"aio threads\" "
  4794.                            "is unsupported on this platform");
  4795.         return NGX_CONF_ERROR;
  4796. #endif
  4797.     }

  4799.     return "invalid value";
  4800. }


  4803. static char *
  4804. ‌ngx_http_core_directio(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4805. {
  4806.     ngx_http_core_loc_conf_t *clcf = conf;

  4808.     ngx_str_t  *value;

  4810.     if (clcf->directio != NGX_CONF_UNSET) {
  4811.         return "is duplicate";
  4812.     }

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

  4816.     if (ngx_strcmp(value[1].data, "off") == 0) {
  4817.         clcf->directio = NGX_OPEN_FILE_DIRECTIO_OFF;
  4818.         return NGX_CONF_OK;
  4819.     }

  4821.     clcf->directio = ngx_parse_offset(&value[1]);
  4822.     if (clcf->directio == (off_t) NGX_ERROR) {
  4823.         return "invalid value";
  4824.     }

  4826.     return NGX_CONF_OK;
  4827. }


  4830. static char *
  4831. ‌ngx_http_core_error_page(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4832. {
  4833.     ngx_http_core_loc_conf_t *clcf = conf;

  4835.     u_char                            *p;
  4836.     ngx_int_t                          overwrite;
  4837.     ngx_str_t                         *value, uri, args;
  4838.     ngx_uint_t                         i, n;
  4839.     ngx_http_err_page_t               *err;
  4840.     ngx_http_complex_value_t           cv;
  4841.     ngx_http_compile_complex_value_t   ccv;

  4843.     if (clcf->error_pages == NULL) {
  4844.         clcf->error_pages = ngx_array_create(cf->pool, 4,
  4845.                                              sizeof(ngx_http_err_page_t));
  4846.         if (clcf->error_pages == NULL) {
  4847.             return NGX_CONF_ERROR;
  4848.         }
  4849.     }

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

  4853.     i = cf->args->nelts - 2;

  4855.     if (value[i].data[0] == '=') {
  4856.         if (i == 1) {
  4857.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4858.                                "invalid value \"%V\"", &value[i]);
  4859.             return NGX_CONF_ERROR;
  4860.         }

  4862.         if (value[i].len > 1) {
  4863.             overwrite = ngx_atoi(&value[i].data[1], value[i].len - 1);

  4865.             if (overwrite == NGX_ERROR) {
  4866.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4867.                                    "invalid value \"%V\"", &value[i]);
  4868.                 return NGX_CONF_ERROR;
  4869.             }

  4871.         } else {
  4872.             overwrite = 0;
  4873.         }

  4875.         n = 2;

  4877.     } else {
  4878.         overwrite = -1;
  4879.         n = 1;
  4880.     }

  4882.     uri = value[cf->args->nelts - 1];

  4884.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  4886.     ccv.cf = cf;
  4887.     ccv.value = &uri;
  4888.     ccv.complex_value = &cv;

  4890.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  4891.         return NGX_CONF_ERROR;
  4892.     }

  4894.     ngx_str_null(&args);

  4896.     if (cv.lengths == NULL && uri.len && uri.data[0] == '/') {
  4897.         p = (u_char *) ngx_strchr(uri.data, '?');

  4899.         if (p) {
  4900.             cv.value.len = p - uri.data;
  4901.             cv.value.data = uri.data;
  4902.             p++;
  4903.             args.len = (uri.data + uri.len) - p;
  4904.             args.data = p;
  4905.         }
  4906.     }

  4908.     for (i = 1; i < cf->args->nelts - n; i++) {
  4909.         err = ngx_array_push(clcf->error_pages);
  4910.         if (err == NULL) {
  4911.             return NGX_CONF_ERROR;
  4912.         }

  4914.         err->status = ngx_atoi(value[i].data, value[i].len);

  4916.         if (err->status == NGX_ERROR || err->status == 499) {
  4917.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4918.                                "invalid value \"%V\"", &value[i]);
  4919.             return NGX_CONF_ERROR;
  4920.         }

  4922.         if (err->status < 300 || err->status > 599) {
  4923.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4924.                                "value \"%V\" must be between 300 and 599",
  4925.                                &value[i]);
  4926.             return NGX_CONF_ERROR;
  4927.         }

  4929.         err->overwrite = overwrite;

  4931.         if (overwrite == -1) {
  4932.             switch (err->status) {
  4933.                 case NGX_HTTP_TO_HTTPS:
  4934.                 case NGX_HTTPS_CERT_ERROR:
  4935.                 case NGX_HTTPS_NO_CERT:
  4936.                 case NGX_HTTP_REQUEST_HEADER_TOO_LARGE:
  4937.                     err->overwrite = NGX_HTTP_BAD_REQUEST;
  4938.             }
  4939.         }

  4941.         err->value = cv;
  4942.         err->args = args;
  4943.     }

  4945.     return NGX_CONF_OK;
  4946. }


  4949. static char *
  4950. ‌ngx_http_core_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4951. {
  4952.     ngx_http_core_loc_conf_t *clcf = conf;

  4954.     time_t       inactive;
  4955.     ngx_str_t   *value, s;
  4956.     ngx_int_t    max;
  4957.     ngx_uint_t   i;

  4959.     if (clcf->open_file_cache != NGX_CONF_UNSET_PTR) {
  4960.         return "is duplicate";
  4961.     }

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

  4965.     max = 0;
  4966.     inactive = 60;

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

  4970.         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {

  4972.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  4973.             if (max <= 0) {
  4974.                 goto failed;
  4975.             }

  4977.             continue;
  4978.         }

  4980.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  4982.             s.len = value[i].len - 9;
  4983.             s.data = value[i].data + 9;

  4985.             inactive = ngx_parse_time(&s, 1);
  4986.             if (inactive == (time_t) NGX_ERROR) {
  4987.                 goto failed;
  4988.             }

  4990.             continue;
  4991.         }

  4993.         if (ngx_strcmp(value[i].data, "off") == 0) {

  4995.             clcf->open_file_cache = NULL;

  4997.             continue;
  4998.         }

  5000.     failed:

  5002.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5003.                            "invalid \"open_file_cache\" parameter \"%V\"",
  5004.                            &value[i]);
  5005.         return NGX_CONF_ERROR;
  5006.     }

  5008.     if (clcf->open_file_cache == NULL) {
  5009.         return NGX_CONF_OK;
  5010.     }

  5012.     if (max == 0) {
  5013.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5014.                         "\"open_file_cache\" must have the \"max\" parameter");
  5015.         return NGX_CONF_ERROR;
  5016.     }

  5018.     clcf->open_file_cache = ngx_open_file_cache_init(cf->pool, max, inactive);
  5019.     if (clcf->open_file_cache) {
  5020.         return NGX_CONF_OK;
  5021.     }

  5023.     return NGX_CONF_ERROR;
  5024. }


  5027. static char *
  5028. ‌ngx_http_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5029. {
  5030.     ngx_http_core_loc_conf_t *clcf = conf;

  5032.     return ngx_log_set_log(cf, &clcf->error_log);
  5033. }


  5036. static char *
  5037. ‌ngx_http_core_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5038. {
  5039.     ngx_http_core_loc_conf_t *clcf = conf;

  5041.     ngx_str_t  *value;

  5043.     if (clcf->keepalive_timeout != NGX_CONF_UNSET_MSEC) {
  5044.         return "is duplicate";
  5045.     }

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

  5049.     clcf->keepalive_timeout = ngx_parse_time(&value[1], 0);

  5051.     if (clcf->keepalive_timeout == (ngx_msec_t) NGX_ERROR) {
  5052.         return "invalid value";
  5053.     }

  5055.     if (cf->args->nelts == 2) {
  5056.         return NGX_CONF_OK;
  5057.     }

  5059.     clcf->keepalive_header = ngx_parse_time(&value[2], 1);

  5061.     if (clcf->keepalive_header == (time_t) NGX_ERROR) {
  5062.         return "invalid value";
  5063.     }

  5065.     return NGX_CONF_OK;
  5066. }


  5069. static char *
  5070. ‌ngx_http_core_internal(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5071. {
  5072.     ngx_http_core_loc_conf_t *clcf = conf;

  5074.     if (clcf->internal != NGX_CONF_UNSET) {
  5075.         return "is duplicate";
  5076.     }

  5078.     clcf->internal = 1;

  5080.     return NGX_CONF_OK;
  5081. }


  5084. static char *
  5085. ‌ngx_http_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5086. {
  5087.     ngx_http_core_loc_conf_t  *clcf = conf;

  5089.     ngx_str_t  *value;

  5091.     if (clcf->resolver) {
  5092.         return "is duplicate";
  5093.     }

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

  5097.     clcf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  5098.     if (clcf->resolver == NULL) {
  5099.         return NGX_CONF_ERROR;
  5100.     }

  5102.     return NGX_CONF_OK;
  5103. }


  5106. #if (NGX_HTTP_GZIP)

  5108. static char *
  5109. ‌ngx_http_gzip_disable(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5110. {
  5111.     ngx_http_core_loc_conf_t  *clcf = conf;

  5113. #if (NGX_PCRE)

  5115.     ngx_str_t            *value;
  5116.     ngx_uint_t            i;
  5117.     ngx_regex_elt_t      *re;
  5118.     ngx_regex_compile_t   rc;
  5119.     u_char                errstr[NGX_MAX_CONF_ERRSTR];

  5121.     if (clcf->gzip_disable == NGX_CONF_UNSET_PTR) {
  5122.         clcf->gzip_disable = ngx_array_create(cf->pool, 2,
  5123.                                               sizeof(ngx_regex_elt_t));
  5124.         if (clcf->gzip_disable == NULL) {
  5125.             return NGX_CONF_ERROR;
  5126.         }
  5127.     }

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

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

  5133.     rc.pool = cf->pool;
  5134.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  5135.     rc.err.data = errstr;

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

  5139.         if (ngx_strcmp(value[i].data, "msie6") == 0) {
  5140.             clcf->gzip_disable_msie6 = 1;
  5141.             continue;
  5142.         }

  5144. #if (NGX_HTTP_DEGRADATION)

  5146.         if (ngx_strcmp(value[i].data, "degradation") == 0) {
  5147.             clcf->gzip_disable_degradation = 1;
  5148.             continue;
  5149.         }

  5151. #endif

  5153.         re = ngx_array_push(clcf->gzip_disable);
  5154.         if (re == NULL) {
  5155.             return NGX_CONF_ERROR;
  5156.         }

  5158.         rc.pattern = value[i];
  5159.         rc.options = NGX_REGEX_CASELESS;

  5161.         if (ngx_regex_compile(&rc) != NGX_OK) {
  5162.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc.err);
  5163.             return NGX_CONF_ERROR;
  5164.         }

  5166.         re->regex = rc.regex;
  5167.         re->name = value[i].data;
  5168.     }

  5170.     return NGX_CONF_OK;

  5172. #else
  5173.     ngx_str_t   *value;
  5174.     ngx_uint_t   i;

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

  5178.     for (i = 1; i < cf->args->nelts; i++) {
  5179.         if (ngx_strcmp(value[i].data, "msie6") == 0) {
  5180.             clcf->gzip_disable_msie6 = 1;
  5181.             continue;
  5182.         }

  5184. #if (NGX_HTTP_DEGRADATION)

  5186.         if (ngx_strcmp(value[i].data, "degradation") == 0) {
  5187.             clcf->gzip_disable_degradation = 1;
  5188.             continue;
  5189.         }

  5191. #endif

  5193.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5194.                            "without PCRE library \"gzip_disable\" supports "
  5195.                            "builtin \"msie6\" and \"degradation\" mask only");

  5197.         return NGX_CONF_ERROR;
  5198.     }

  5200.     return NGX_CONF_OK;

  5202. #endif
  5203. }

  5205. #endif


  5208. #if (NGX_HAVE_OPENAT)

  5210. static char *
  5211. ‌ngx_http_disable_symlinks(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5212. {
  5213.     ngx_http_core_loc_conf_t *clcf = conf;

  5215.     ngx_str_t                         *value;
  5216.     ngx_uint_t                         i;
  5217.     ngx_http_compile_complex_value_t   ccv;

  5219.     if (clcf->disable_symlinks != NGX_CONF_UNSET_UINT) {
  5220.         return "is duplicate";
  5221.     }

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

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

  5227.         if (ngx_strcmp(value[i].data, "off") == 0) {
  5228.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_OFF;
  5229.             continue;
  5230.         }

  5232.         if (ngx_strcmp(value[i].data, "if_not_owner") == 0) {
  5233.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_NOTOWNER;
  5234.             continue;
  5235.         }

  5237.         if (ngx_strcmp(value[i].data, "on") == 0) {
  5238.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_ON;
  5239.             continue;
  5240.         }

  5242.         if (ngx_strncmp(value[i].data, "from=", 5) == 0) {
  5243.             value[i].len -= 5;
  5244.             value[i].data += 5;

  5246.             ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  5248.             ccv.cf = cf;
  5249.             ccv.value = &value[i];
  5250.             ccv.complex_value = ngx_palloc(cf->pool,
  5251.                                            sizeof(ngx_http_complex_value_t));
  5252.             if (ccv.complex_value == NULL) {
  5253.                 return NGX_CONF_ERROR;
  5254.             }

  5256.             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  5257.                 return NGX_CONF_ERROR;
  5258.             }

  5260.             clcf->disable_symlinks_from = ccv.complex_value;

  5262.             continue;
  5263.         }

  5265.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5266.                            "invalid parameter \"%V\"", &value[i]);
  5267.         return NGX_CONF_ERROR;
  5268.     }

  5270.     if (clcf->disable_symlinks == NGX_CONF_UNSET_UINT) {
  5271.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5272.                            "\"%V\" must have \"off\", \"on\" "
  5273.                            "or \"if_not_owner\" parameter",
  5274.                            &cmd->name);
  5275.         return NGX_CONF_ERROR;
  5276.     }

  5278.     if (cf->args->nelts == 2) {
  5279.         clcf->disable_symlinks_from = NULL;
  5280.         return NGX_CONF_OK;
  5281.     }

  5283.     if (clcf->disable_symlinks_from == NGX_CONF_UNSET_PTR) {
  5284.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5285.                            "duplicate parameters \"%V %V\"",
  5286.                            &value[1], &value[2]);
  5287.         return NGX_CONF_ERROR;
  5288.     }

  5290.     if (clcf->disable_symlinks == NGX_DISABLE_SYMLINKS_OFF) {
  5291.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5292.                            "\"from=\" cannot be used with \"off\" parameter");
  5293.         return NGX_CONF_ERROR;
  5294.     }

  5296.     return NGX_CONF_OK;
  5297. }

  5299. #endif


  5302. static char *
  5303. ‌ngx_http_core_lowat_check(ngx_conf_t *cf, void *post, void *data)
  5304. {
  5305. #if (NGX_FREEBSD)
  5306.     ssize_t *np = data;

  5308.     if ((u_long) *np >= ngx_freebsd_net_inet_tcp_sendspace) {
  5309.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5310.                            "\"send_lowat\" must be less than %d "
  5311.                            "(sysctl net.inet.tcp.sendspace)",
  5312.                            ngx_freebsd_net_inet_tcp_sendspace);

  5314.         return NGX_CONF_ERROR;
  5315.     }

  5317. #elif !(NGX_HAVE_SO_SNDLOWAT)
  5318.     ssize_t *np = data;

  5320.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  5321.                        "\"send_lowat\" is not supported, ignored");

  5323.     *np = 0;

  5325. #endif

  5327.     return NGX_CONF_OK;
  5328. }


  5331. static char *
  5332. ‌ngx_http_core_pool_size(ngx_conf_t *cf, void *post, void *data)
  5333. {
  5334.     size_t *sp = data;

  5336.     if (*sp < NGX_MIN_POOL_SIZE) {
  5337.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5338.                            "the pool size must be no less than %uz",
  5339.                            NGX_MIN_POOL_SIZE);
  5340.         return NGX_CONF_ERROR;
  5341.     }

  5343.     if (*sp % NGX_POOL_ALIGNMENT) {
  5344.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5345.                            "the pool size must be a multiple of %uz",
  5346.                            NGX_POOL_ALIGNMENT);
  5347.         return NGX_CONF_ERROR;
  5348.     }

  5350.     return NGX_CONF_OK;
  5351. }

One Level Up Top Level