One Level Up Top Level

src/http/ngx_http_core_module.c - nginx-1.7.10

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_find_location(ngx_http_request_t *r);
  25. static ngx_int_t ngx_http_core_find_static_location(ngx_http_request_t *r,
  26.     ngx_http_location_tree_node_t *node);

  28. static ngx_int_t ngx_http_core_preconfiguration(ngx_conf_t *cf);
  29. static void *ngx_http_core_create_main_conf(ngx_conf_t *cf);
  30. static char *ngx_http_core_init_main_conf(ngx_conf_t *cf, void *conf);
  31. static void *ngx_http_core_create_srv_conf(ngx_conf_t *cf);
  32. static char *ngx_http_core_merge_srv_conf(ngx_conf_t *cf,
  33.     void *parent, void *child);
  34. static void *ngx_http_core_create_loc_conf(ngx_conf_t *cf);
  35. static char *ngx_http_core_merge_loc_conf(ngx_conf_t *cf,
  36.     void *parent, void *child);

  38. static char *ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd,
  39.     void *dummy);
  40. static char *ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd,
  41.     void *dummy);
  42. static ngx_int_t ngx_http_core_regex_location(ngx_conf_t *cf,
  43.     ngx_http_core_loc_conf_t *clcf, ngx_str_t *regex, ngx_uint_t caseless);

  45. static char *ngx_http_core_types(ngx_conf_t *cf, ngx_command_t *cmd,
  46.     void *conf);
  47. static char *ngx_http_core_type(ngx_conf_t *cf, ngx_command_t *dummy,
  48.     void *conf);

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

  87. static char *ngx_http_core_lowat_check(ngx_conf_t *cf, void *post, void *data);
  88. static char *ngx_http_core_pool_size(ngx_conf_t *cf, void *post, void *data);

  90. ‌static ngx_conf_post_t  ngx_http_core_lowat_post =
  91.     { ngx_http_core_lowat_check };

  93. ‌static ngx_conf_post_handler_pt  ngx_http_core_pool_size_p =
  94.     ngx_http_core_pool_size;

  96. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_optimize_server_names = {
  97.     ngx_conf_deprecated, "optimize_server_names", "server_name_in_redirect"
  98. };

  100. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_open_file_cache_retest = {
  101.     ngx_conf_deprecated, "open_file_cache_retest", "open_file_cache_valid"
  102. };

  104. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_satisfy_any = {
  105.     ngx_conf_deprecated, "satisfy_any", "satisfy"
  106. };


  109. ‌static ngx_conf_enum_t  ngx_http_core_request_body_in_file[] = {
  110.     { ngx_string("off"), NGX_HTTP_REQUEST_BODY_FILE_OFF },
  111.     { ngx_string("on"), NGX_HTTP_REQUEST_BODY_FILE_ON },
  112.     { ngx_string("clean"), NGX_HTTP_REQUEST_BODY_FILE_CLEAN },
  113.     { ngx_null_string, 0 }
  114. };


  117. #if (NGX_HAVE_FILE_AIO)

  119. ‌static ngx_conf_enum_t  ngx_http_core_aio[] = {
  120.     { ngx_string("off"), NGX_HTTP_AIO_OFF  },
  121.     { ngx_string("on"), NGX_HTTP_AIO_ON },
  122. #if (NGX_HAVE_AIO_SENDFILE)
  123.     { ngx_string("sendfile"), NGX_HTTP_AIO_SENDFILE },
  124. #endif
  125.     { ngx_null_string, 0 }
  126. };

  128. #endif


  131. ‌static ngx_conf_enum_t  ngx_http_core_satisfy[] = {
  132.     { ngx_string("all"), NGX_HTTP_SATISFY_ALL },
  133.     { ngx_string("any"), NGX_HTTP_SATISFY_ANY },
  134.     { ngx_null_string, 0 }
  135. };


  138. ‌static ngx_conf_enum_t  ngx_http_core_lingering_close[] = {
  139.     { ngx_string("off"), NGX_HTTP_LINGERING_OFF },
  140.     { ngx_string("on"), NGX_HTTP_LINGERING_ON },
  141.     { ngx_string("always"), NGX_HTTP_LINGERING_ALWAYS },
  142.     { ngx_null_string, 0 }
  143. };


  146. ‌static ngx_conf_enum_t  ngx_http_core_if_modified_since[] = {
  147.     { ngx_string("off"), NGX_HTTP_IMS_OFF },
  148.     { ngx_string("exact"), NGX_HTTP_IMS_EXACT },
  149.     { ngx_string("before"), NGX_HTTP_IMS_BEFORE },
  150.     { ngx_null_string, 0 }
  151. };


  154. ‌static ngx_conf_bitmask_t  ngx_http_core_keepalive_disable[] = {
  155.     { ngx_string("none"), NGX_HTTP_KEEPALIVE_DISABLE_NONE },
  156.     { ngx_string("msie6"), NGX_HTTP_KEEPALIVE_DISABLE_MSIE6 },
  157.     { ngx_string("safari"), NGX_HTTP_KEEPALIVE_DISABLE_SAFARI },
  158.     { ngx_null_string, 0 }
  159. };


  162. ‌static ngx_path_init_t  ngx_http_client_temp_path = {
  163.     ngx_string(NGX_HTTP_CLIENT_TEMP_PATH), { 0, 0, 0 }
  164. };


  167. #if (NGX_HTTP_GZIP)

  169. ‌static ngx_conf_enum_t  ngx_http_gzip_http_version[] = {
  170.     { ngx_string("1.0"), NGX_HTTP_VERSION_10 },
  171.     { ngx_string("1.1"), NGX_HTTP_VERSION_11 },
  172.     { ngx_null_string, 0 }
  173. };


  176. ‌static ngx_conf_bitmask_t  ngx_http_gzip_proxied_mask[] = {
  177.     { ngx_string("off"), NGX_HTTP_GZIP_PROXIED_OFF },
  178.     { ngx_string("expired"), NGX_HTTP_GZIP_PROXIED_EXPIRED },
  179.     { ngx_string("no-cache"), NGX_HTTP_GZIP_PROXIED_NO_CACHE },
  180.     { ngx_string("no-store"), NGX_HTTP_GZIP_PROXIED_NO_STORE },
  181.     { ngx_string("private"), NGX_HTTP_GZIP_PROXIED_PRIVATE },
  182.     { ngx_string("no_last_modified"), NGX_HTTP_GZIP_PROXIED_NO_LM },
  183.     { ngx_string("no_etag"), NGX_HTTP_GZIP_PROXIED_NO_ETAG },
  184.     { ngx_string("auth"), NGX_HTTP_GZIP_PROXIED_AUTH },
  185.     { ngx_string("any"), NGX_HTTP_GZIP_PROXIED_ANY },
  186.     { ngx_null_string, 0 }
  187. };


  190. ‌static ngx_str_t  ngx_http_gzip_no_cache = ngx_string("no-cache");
  191. ‌static ngx_str_t  ngx_http_gzip_no_store = ngx_string("no-store");
  192. ‌static ngx_str_t  ngx_http_gzip_private = ngx_string("private");

  194. #endif


  197. ‌static ngx_command_t  ngx_http_core_commands[] = {

  199.     { ngx_string("variables_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, variables_hash_max_size),
  204.       NULL },

  206.     { ngx_string("variables_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, variables_hash_bucket_size),
  211.       NULL },

  213.     { ngx_string("server_names_hash_max_size"),
  214.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  215.       ngx_conf_set_num_slot,
  216.       NGX_HTTP_MAIN_CONF_OFFSET,
  217.       offsetof(ngx_http_core_main_conf_t, server_names_hash_max_size),
  218.       NULL },

  220.     { ngx_string("server_names_hash_bucket_size"),
  221.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  222.       ngx_conf_set_num_slot,
  223.       NGX_HTTP_MAIN_CONF_OFFSET,
  224.       offsetof(ngx_http_core_main_conf_t, server_names_hash_bucket_size),
  225.       NULL },

  227.     { ngx_string("server"),
  228.       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  229.       ngx_http_core_server,
  230.       0,
  231.       0,
  232.       NULL },

  234.     { ngx_string("connection_pool_size"),
  235.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  236.       ngx_conf_set_size_slot,
  237.       NGX_HTTP_SRV_CONF_OFFSET,
  238.       offsetof(ngx_http_core_srv_conf_t, connection_pool_size),
  239.       &ngx_http_core_pool_size_p },

  241.     { ngx_string("request_pool_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, request_pool_size),
  246.       &ngx_http_core_pool_size_p },

  248.     { ngx_string("client_header_timeout"),
  249.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  250.       ngx_conf_set_msec_slot,
  251.       NGX_HTTP_SRV_CONF_OFFSET,
  252.       offsetof(ngx_http_core_srv_conf_t, client_header_timeout),
  253.       NULL },

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

  262.     { ngx_string("large_client_header_buffers"),
  263.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE2,
  264.       ngx_conf_set_bufs_slot,
  265.       NGX_HTTP_SRV_CONF_OFFSET,
  266.       offsetof(ngx_http_core_srv_conf_t, large_client_header_buffers),
  267.       NULL },

  269.     { ngx_string("optimize_server_names"),
  270.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
  271.       ngx_conf_set_flag_slot,
  272.       NGX_HTTP_LOC_CONF_OFFSET,
  273.       offsetof(ngx_http_core_loc_conf_t, server_name_in_redirect),
  274.       &ngx_conf_deprecated_optimize_server_names },

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

  283.     { ngx_string("merge_slashes"),
  284.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
  285.       ngx_conf_set_flag_slot,
  286.       NGX_HTTP_SRV_CONF_OFFSET,
  287.       offsetof(ngx_http_core_srv_conf_t, merge_slashes),
  288.       NULL },

  290.     { ngx_string("underscores_in_headers"),
  291.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
  292.       ngx_conf_set_flag_slot,
  293.       NGX_HTTP_SRV_CONF_OFFSET,
  294.       offsetof(ngx_http_core_srv_conf_t, underscores_in_headers),
  295.       NULL },

  297.     { ngx_string("location"),
  298.       NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12,
  299.       ngx_http_core_location,
  300.       NGX_HTTP_SRV_CONF_OFFSET,
  301.       0,
  302.       NULL },

  304.     { ngx_string("listen"),
  305.       NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
  306.       ngx_http_core_listen,
  307.       NGX_HTTP_SRV_CONF_OFFSET,
  308.       0,
  309.       NULL },

  311.     { ngx_string("server_name"),
  312.       NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
  313.       ngx_http_core_server_name,
  314.       NGX_HTTP_SRV_CONF_OFFSET,
  315.       0,
  316.       NULL },

  318.     { ngx_string("types_hash_max_size"),
  319.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  320.       ngx_conf_set_num_slot,
  321.       NGX_HTTP_LOC_CONF_OFFSET,
  322.       offsetof(ngx_http_core_loc_conf_t, types_hash_max_size),
  323.       NULL },

  325.     { ngx_string("types_hash_bucket_size"),
  326.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  327.       ngx_conf_set_num_slot,
  328.       NGX_HTTP_LOC_CONF_OFFSET,
  329.       offsetof(ngx_http_core_loc_conf_t, types_hash_bucket_size),
  330.       NULL },

  332.     { ngx_string("types"),
  333.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF
  334.                                           |NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  335.       ngx_http_core_types,
  336.       NGX_HTTP_LOC_CONF_OFFSET,
  337.       0,
  338.       NULL },

  340.     { ngx_string("default_type"),
  341.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  342.       ngx_conf_set_str_slot,
  343.       NGX_HTTP_LOC_CONF_OFFSET,
  344.       offsetof(ngx_http_core_loc_conf_t, default_type),
  345.       NULL },

  347.     { ngx_string("root"),
  348.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  349.                         |NGX_CONF_TAKE1,
  350.       ngx_http_core_root,
  351.       NGX_HTTP_LOC_CONF_OFFSET,
  352.       0,
  353.       NULL },

  355.     { ngx_string("alias"),
  356.       NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  357.       ngx_http_core_root,
  358.       NGX_HTTP_LOC_CONF_OFFSET,
  359.       0,
  360.       NULL },

  362.     { ngx_string("limit_except"),
  363.       NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_1MORE,
  364.       ngx_http_core_limit_except,
  365.       NGX_HTTP_LOC_CONF_OFFSET,
  366.       0,
  367.       NULL },

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

  376.     { ngx_string("client_body_buffer_size"),
  377.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  378.       ngx_conf_set_size_slot,
  379.       NGX_HTTP_LOC_CONF_OFFSET,
  380.       offsetof(ngx_http_core_loc_conf_t, client_body_buffer_size),
  381.       NULL },

  383.     { ngx_string("client_body_timeout"),
  384.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  385.       ngx_conf_set_msec_slot,
  386.       NGX_HTTP_LOC_CONF_OFFSET,
  387.       offsetof(ngx_http_core_loc_conf_t, client_body_timeout),
  388.       NULL },

  390.     { ngx_string("client_body_temp_path"),
  391.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  392.       ngx_conf_set_path_slot,
  393.       NGX_HTTP_LOC_CONF_OFFSET,
  394.       offsetof(ngx_http_core_loc_conf_t, client_body_temp_path),
  395.       NULL },

  397.     { ngx_string("client_body_in_file_only"),
  398.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  399.       ngx_conf_set_enum_slot,
  400.       NGX_HTTP_LOC_CONF_OFFSET,
  401.       offsetof(ngx_http_core_loc_conf_t, client_body_in_file_only),
  402.       &ngx_http_core_request_body_in_file },

  404.     { ngx_string("client_body_in_single_buffer"),
  405.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  406.       ngx_conf_set_flag_slot,
  407.       NGX_HTTP_LOC_CONF_OFFSET,
  408.       offsetof(ngx_http_core_loc_conf_t, client_body_in_single_buffer),
  409.       NULL },

  411.     { ngx_string("sendfile"),
  412.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  413.                         |NGX_CONF_FLAG,
  414.       ngx_conf_set_flag_slot,
  415.       NGX_HTTP_LOC_CONF_OFFSET,
  416.       offsetof(ngx_http_core_loc_conf_t, sendfile),
  417.       NULL },

  419.     { ngx_string("sendfile_max_chunk"),
  420.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  421.       ngx_conf_set_size_slot,
  422.       NGX_HTTP_LOC_CONF_OFFSET,
  423.       offsetof(ngx_http_core_loc_conf_t, sendfile_max_chunk),
  424.       NULL },

  426. #if (NGX_HAVE_FILE_AIO)

  428.     { ngx_string("aio"),
  429.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  430.       ngx_conf_set_enum_slot,
  431.       NGX_HTTP_LOC_CONF_OFFSET,
  432.       offsetof(ngx_http_core_loc_conf_t, aio),
  433.       &ngx_http_core_aio },

  435. #endif

  437.     { ngx_string("read_ahead"),
  438.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  439.       ngx_conf_set_size_slot,
  440.       NGX_HTTP_LOC_CONF_OFFSET,
  441.       offsetof(ngx_http_core_loc_conf_t, read_ahead),
  442.       NULL },

  444.     { ngx_string("directio"),
  445.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  446.       ngx_http_core_directio,
  447.       NGX_HTTP_LOC_CONF_OFFSET,
  448.       0,
  449.       NULL },

  451.     { ngx_string("directio_alignment"),
  452.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  453.       ngx_conf_set_off_slot,
  454.       NGX_HTTP_LOC_CONF_OFFSET,
  455.       offsetof(ngx_http_core_loc_conf_t, directio_alignment),
  456.       NULL },

  458.     { ngx_string("tcp_nopush"),
  459.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  460.       ngx_conf_set_flag_slot,
  461.       NGX_HTTP_LOC_CONF_OFFSET,
  462.       offsetof(ngx_http_core_loc_conf_t, tcp_nopush),
  463.       NULL },

  465.     { ngx_string("tcp_nodelay"),
  466.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  467.       ngx_conf_set_flag_slot,
  468.       NGX_HTTP_LOC_CONF_OFFSET,
  469.       offsetof(ngx_http_core_loc_conf_t, tcp_nodelay),
  470.       NULL },

  472.     { ngx_string("send_timeout"),
  473.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  474.       ngx_conf_set_msec_slot,
  475.       NGX_HTTP_LOC_CONF_OFFSET,
  476.       offsetof(ngx_http_core_loc_conf_t, send_timeout),
  477.       NULL },

  479.     { ngx_string("send_lowat"),
  480.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  481.       ngx_conf_set_size_slot,
  482.       NGX_HTTP_LOC_CONF_OFFSET,
  483.       offsetof(ngx_http_core_loc_conf_t, send_lowat),
  484.       &ngx_http_core_lowat_post },

  486.     { ngx_string("postpone_output"),
  487.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  488.       ngx_conf_set_size_slot,
  489.       NGX_HTTP_LOC_CONF_OFFSET,
  490.       offsetof(ngx_http_core_loc_conf_t, postpone_output),
  491.       NULL },

  493.     { ngx_string("limit_rate"),
  494.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  495.                         |NGX_CONF_TAKE1,
  496.       ngx_conf_set_size_slot,
  497.       NGX_HTTP_LOC_CONF_OFFSET,
  498.       offsetof(ngx_http_core_loc_conf_t, limit_rate),
  499.       NULL },

  501.     { ngx_string("limit_rate_after"),
  502.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  503.                         |NGX_CONF_TAKE1,
  504.       ngx_conf_set_size_slot,
  505.       NGX_HTTP_LOC_CONF_OFFSET,
  506.       offsetof(ngx_http_core_loc_conf_t, limit_rate_after),
  507.       NULL },

  509.     { ngx_string("keepalive_timeout"),
  510.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  511.       ngx_http_core_keepalive,
  512.       NGX_HTTP_LOC_CONF_OFFSET,
  513.       0,
  514.       NULL },

  516.     { ngx_string("keepalive_requests"),
  517.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  518.       ngx_conf_set_num_slot,
  519.       NGX_HTTP_LOC_CONF_OFFSET,
  520.       offsetof(ngx_http_core_loc_conf_t, keepalive_requests),
  521.       NULL },

  523.     { ngx_string("keepalive_disable"),
  524.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  525.       ngx_conf_set_bitmask_slot,
  526.       NGX_HTTP_LOC_CONF_OFFSET,
  527.       offsetof(ngx_http_core_loc_conf_t, keepalive_disable),
  528.       &ngx_http_core_keepalive_disable },

  530.     { ngx_string("satisfy"),
  531.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  532.       ngx_conf_set_enum_slot,
  533.       NGX_HTTP_LOC_CONF_OFFSET,
  534.       offsetof(ngx_http_core_loc_conf_t, satisfy),
  535.       &ngx_http_core_satisfy },

  537.     { ngx_string("satisfy_any"),
  538.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  539.       ngx_conf_set_flag_slot,
  540.       NGX_HTTP_LOC_CONF_OFFSET,
  541.       offsetof(ngx_http_core_loc_conf_t, satisfy),
  542.       &ngx_conf_deprecated_satisfy_any },

  544.     { ngx_string("internal"),
  545.       NGX_HTTP_LOC_CONF|NGX_CONF_NOARGS,
  546.       ngx_http_core_internal,
  547.       NGX_HTTP_LOC_CONF_OFFSET,
  548.       0,
  549.       NULL },

  551.     { ngx_string("lingering_close"),
  552.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  553.       ngx_conf_set_enum_slot,
  554.       NGX_HTTP_LOC_CONF_OFFSET,
  555.       offsetof(ngx_http_core_loc_conf_t, lingering_close),
  556.       &ngx_http_core_lingering_close },

  558.     { ngx_string("lingering_time"),
  559.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  560.       ngx_conf_set_msec_slot,
  561.       NGX_HTTP_LOC_CONF_OFFSET,
  562.       offsetof(ngx_http_core_loc_conf_t, lingering_time),
  563.       NULL },

  565.     { ngx_string("lingering_timeout"),
  566.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  567.       ngx_conf_set_msec_slot,
  568.       NGX_HTTP_LOC_CONF_OFFSET,
  569.       offsetof(ngx_http_core_loc_conf_t, lingering_timeout),
  570.       NULL },

  572.     { ngx_string("reset_timedout_connection"),
  573.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  574.       ngx_conf_set_flag_slot,
  575.       NGX_HTTP_LOC_CONF_OFFSET,
  576.       offsetof(ngx_http_core_loc_conf_t, reset_timedout_connection),
  577.       NULL },

  579.     { ngx_string("server_name_in_redirect"),
  580.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  581.       ngx_conf_set_flag_slot,
  582.       NGX_HTTP_LOC_CONF_OFFSET,
  583.       offsetof(ngx_http_core_loc_conf_t, server_name_in_redirect),
  584.       NULL },

  586.     { ngx_string("port_in_redirect"),
  587.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  588.       ngx_conf_set_flag_slot,
  589.       NGX_HTTP_LOC_CONF_OFFSET,
  590.       offsetof(ngx_http_core_loc_conf_t, port_in_redirect),
  591.       NULL },

  593.     { ngx_string("msie_padding"),
  594.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  595.       ngx_conf_set_flag_slot,
  596.       NGX_HTTP_LOC_CONF_OFFSET,
  597.       offsetof(ngx_http_core_loc_conf_t, msie_padding),
  598.       NULL },

  600.     { ngx_string("msie_refresh"),
  601.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  602.       ngx_conf_set_flag_slot,
  603.       NGX_HTTP_LOC_CONF_OFFSET,
  604.       offsetof(ngx_http_core_loc_conf_t, msie_refresh),
  605.       NULL },

  607.     { ngx_string("log_not_found"),
  608.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  609.       ngx_conf_set_flag_slot,
  610.       NGX_HTTP_LOC_CONF_OFFSET,
  611.       offsetof(ngx_http_core_loc_conf_t, log_not_found),
  612.       NULL },

  614.     { ngx_string("log_subrequest"),
  615.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  616.       ngx_conf_set_flag_slot,
  617.       NGX_HTTP_LOC_CONF_OFFSET,
  618.       offsetof(ngx_http_core_loc_conf_t, log_subrequest),
  619.       NULL },

  621.     { ngx_string("recursive_error_pages"),
  622.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  623.       ngx_conf_set_flag_slot,
  624.       NGX_HTTP_LOC_CONF_OFFSET,
  625.       offsetof(ngx_http_core_loc_conf_t, recursive_error_pages),
  626.       NULL },

  628.     { ngx_string("server_tokens"),
  629.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  630.       ngx_conf_set_flag_slot,
  631.       NGX_HTTP_LOC_CONF_OFFSET,
  632.       offsetof(ngx_http_core_loc_conf_t, server_tokens),
  633.       NULL },

  635.     { ngx_string("if_modified_since"),
  636.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  637.       ngx_conf_set_enum_slot,
  638.       NGX_HTTP_LOC_CONF_OFFSET,
  639.       offsetof(ngx_http_core_loc_conf_t, if_modified_since),
  640.       &ngx_http_core_if_modified_since },

  642.     { ngx_string("max_ranges"),
  643.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  644.       ngx_conf_set_num_slot,
  645.       NGX_HTTP_LOC_CONF_OFFSET,
  646.       offsetof(ngx_http_core_loc_conf_t, max_ranges),
  647.       NULL },

  649.     { ngx_string("chunked_transfer_encoding"),
  650.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  651.       ngx_conf_set_flag_slot,
  652.       NGX_HTTP_LOC_CONF_OFFSET,
  653.       offsetof(ngx_http_core_loc_conf_t, chunked_transfer_encoding),
  654.       NULL },

  656.     { ngx_string("etag"),
  657.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  658.       ngx_conf_set_flag_slot,
  659.       NGX_HTTP_LOC_CONF_OFFSET,
  660.       offsetof(ngx_http_core_loc_conf_t, etag),
  661.       NULL },

  663.     { ngx_string("error_page"),
  664.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  665.                         |NGX_CONF_2MORE,
  666.       ngx_http_core_error_page,
  667.       NGX_HTTP_LOC_CONF_OFFSET,
  668.       0,
  669.       NULL },

  671.     { ngx_string("try_files"),
  672.       NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_2MORE,
  673.       ngx_http_core_try_files,
  674.       NGX_HTTP_LOC_CONF_OFFSET,
  675.       0,
  676.       NULL },

  678.     { ngx_string("post_action"),
  679.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  680.                         |NGX_CONF_TAKE1,
  681.       ngx_conf_set_str_slot,
  682.       NGX_HTTP_LOC_CONF_OFFSET,
  683.       offsetof(ngx_http_core_loc_conf_t, post_action),
  684.       NULL },

  686.     { ngx_string("error_log"),
  687.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  688.       ngx_http_core_error_log,
  689.       NGX_HTTP_LOC_CONF_OFFSET,
  690.       0,
  691.       NULL },

  693.     { ngx_string("open_file_cache"),
  694.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  695.       ngx_http_core_open_file_cache,
  696.       NGX_HTTP_LOC_CONF_OFFSET,
  697.       offsetof(ngx_http_core_loc_conf_t, open_file_cache),
  698.       NULL },

  700.     { ngx_string("open_file_cache_valid"),
  701.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  702.       ngx_conf_set_sec_slot,
  703.       NGX_HTTP_LOC_CONF_OFFSET,
  704.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_valid),
  705.       NULL },

  707.     { ngx_string("open_file_cache_retest"),
  708.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  709.       ngx_conf_set_sec_slot,
  710.       NGX_HTTP_LOC_CONF_OFFSET,
  711.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_valid),
  712.       &ngx_conf_deprecated_open_file_cache_retest },

  714.     { ngx_string("open_file_cache_min_uses"),
  715.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  716.       ngx_conf_set_num_slot,
  717.       NGX_HTTP_LOC_CONF_OFFSET,
  718.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_min_uses),
  719.       NULL },

  721.     { ngx_string("open_file_cache_errors"),
  722.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  723.       ngx_conf_set_flag_slot,
  724.       NGX_HTTP_LOC_CONF_OFFSET,
  725.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_errors),
  726.       NULL },

  728.     { ngx_string("open_file_cache_events"),
  729.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  730.       ngx_conf_set_flag_slot,
  731.       NGX_HTTP_LOC_CONF_OFFSET,
  732.       offsetof(ngx_http_core_loc_conf_t, open_file_cache_events),
  733.       NULL },

  735.     { ngx_string("resolver"),
  736.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  737.       ngx_http_core_resolver,
  738.       NGX_HTTP_LOC_CONF_OFFSET,
  739.       0,
  740.       NULL },

  742.     { ngx_string("resolver_timeout"),
  743.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  744.       ngx_conf_set_msec_slot,
  745.       NGX_HTTP_LOC_CONF_OFFSET,
  746.       offsetof(ngx_http_core_loc_conf_t, resolver_timeout),
  747.       NULL },

  749. #if (NGX_HTTP_GZIP)

  751.     { ngx_string("gzip_vary"),
  752.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  753.       ngx_conf_set_flag_slot,
  754.       NGX_HTTP_LOC_CONF_OFFSET,
  755.       offsetof(ngx_http_core_loc_conf_t, gzip_vary),
  756.       NULL },

  758.     { ngx_string("gzip_http_version"),
  759.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  760.       ngx_conf_set_enum_slot,
  761.       NGX_HTTP_LOC_CONF_OFFSET,
  762.       offsetof(ngx_http_core_loc_conf_t, gzip_http_version),
  763.       &ngx_http_gzip_http_version },

  765.     { ngx_string("gzip_proxied"),
  766.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  767.       ngx_conf_set_bitmask_slot,
  768.       NGX_HTTP_LOC_CONF_OFFSET,
  769.       offsetof(ngx_http_core_loc_conf_t, gzip_proxied),
  770.       &ngx_http_gzip_proxied_mask },

  772.     { ngx_string("gzip_disable"),
  773.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  774.       ngx_http_gzip_disable,
  775.       NGX_HTTP_LOC_CONF_OFFSET,
  776.       0,
  777.       NULL },

  779. #endif

  781. #if (NGX_HAVE_OPENAT)

  783.     { ngx_string("disable_symlinks"),
  784.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  785.       ngx_http_disable_symlinks,
  786.       NGX_HTTP_LOC_CONF_OFFSET,
  787.       0,
  788.       NULL },

  790. #endif

  792.       ngx_null_command
  793. };


  796. ‌static ngx_http_module_t  ngx_http_core_module_ctx = {
  797.     ngx_http_core_preconfiguration,        /* preconfiguration */
  798.     NULL,                                  /* postconfiguration */

  800.     ngx_http_core_create_main_conf,        /* create main configuration */
  801.     ngx_http_core_init_main_conf,          /* init main configuration */

  803.     ngx_http_core_create_srv_conf,         /* create server configuration */
  804.     ngx_http_core_merge_srv_conf,          /* merge server configuration */

  806.     ngx_http_core_create_loc_conf,         /* create location configuration */
  807.     ngx_http_core_merge_loc_conf           /* merge location configuration */
  808. };


  811. ‌ngx_module_t  ngx_http_core_module = {
  812.     NGX_MODULE_V1,
  813.     &ngx_http_core_module_ctx,             /* module context */
  814.     ngx_http_core_commands,                /* module directives */
  815.     NGX_HTTP_MODULE,                       /* module type */
  816.     NULL,                                  /* init master */
  817.     NULL,                                  /* init module */
  818.     NULL,                                  /* init process */
  819.     NULL,                                  /* init thread */
  820.     NULL,                                  /* exit thread */
  821.     NULL,                                  /* exit process */
  822.     NULL,                                  /* exit master */
  823.     NGX_MODULE_V1_PADDING
  824. };


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


  830. void
  831. ‌ngx_http_handler(ngx_http_request_t *r)
  832. {
  833.     ngx_http_core_main_conf_t  *cmcf;

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

  837.     r->connection->unexpected_eof = 0;

  839.     if (!r->internal) {
  840.         switch (r->headers_in.connection_type) {
  841.         case 0:
  842.             r->keepalive = (r->http_version > NGX_HTTP_VERSION_10);
  843.             break;

  845.         case NGX_HTTP_CONNECTION_CLOSE:
  846.             r->keepalive = 0;
  847.             break;

  849.         case NGX_HTTP_CONNECTION_KEEP_ALIVE:
  850.             r->keepalive = 1;
  851.             break;
  852.         }

  854.         r->lingering_close = (r->headers_in.content_length_n > 0
  855.                               || r->headers_in.chunked);
  856.         r->phase_handler = 0;

  858.     } else {
  859.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
  860.         r->phase_handler = cmcf->phase_engine.server_rewrite_index;
  861.     }

  863.     r->valid_location = 1;
  864. #if (NGX_HTTP_GZIP)
  865.     r->gzip_tested = 0;
  866.     r->gzip_ok = 0;
  867.     r->gzip_vary = 0;
  868. #endif

  870.     r->write_event_handler = ngx_http_core_run_phases;
  871.     ngx_http_core_run_phases(r);
  872. }


  875. void
  876. ‌ngx_http_core_run_phases(ngx_http_request_t *r)
  877. {
  878.     ngx_int_t                   rc;
  879.     ngx_http_phase_handler_t   *ph;
  880.     ngx_http_core_main_conf_t  *cmcf;

  882.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  884.     ph = cmcf->phase_engine.handlers;

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

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

  890.         if (rc == NGX_OK) {
  891.             return;
  892.         }
  893.     }
  894. }


  897. ngx_int_t
  898. ‌ngx_http_core_generic_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  899. {
  900.     ngx_int_t  rc;

  902.     /*
  903.      * generic phase checker,
  904.      * used by the post read and pre-access phases
  905.      */

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

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

  912.     if (rc == NGX_OK) {
  913.         r->phase_handler = ph->next;
  914.         return NGX_AGAIN;
  915.     }

  917.     if (rc == NGX_DECLINED) {
  918.         r->phase_handler++;
  919.         return NGX_AGAIN;
  920.     }

  922.     if (rc == NGX_AGAIN || rc == NGX_DONE) {
  923.         return NGX_OK;
  924.     }

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

  928.     ngx_http_finalize_request(r, rc);

  930.     return NGX_OK;
  931. }


  934. ngx_int_t
  935. ‌ngx_http_core_rewrite_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  936. {
  937.     ngx_int_t  rc;

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

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

  944.     if (rc == NGX_DECLINED) {
  945.         r->phase_handler++;
  946.         return NGX_AGAIN;
  947.     }

  949.     if (rc == NGX_DONE) {
  950.         return NGX_OK;
  951.     }

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

  955.     ngx_http_finalize_request(r, rc);

  957.     return NGX_OK;
  958. }


  961. ngx_int_t
  962. ‌ngx_http_core_find_config_phase(ngx_http_request_t *r,
  963.     ngx_http_phase_handler_t *ph)
  964. {
  965.     u_char                    *p;
  966.     size_t                     len;
  967.     ngx_int_t                  rc;
  968.     ngx_http_core_loc_conf_t  *clcf;

  970.     r->content_handler = NULL;
  971.     r->uri_changed = 0;

  973.     rc = ngx_http_core_find_location(r);

  975.     if (rc == NGX_ERROR) {
  976.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  977.         return NGX_OK;
  978.     }

  980.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  982.     if (!r->internal && clcf->internal) {
  983.         ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  984.         return NGX_OK;
  985.     }

  987.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  988.                    "using configuration \"%s%V\"",
  989.                    (clcf->noname ? "*" : (clcf->exact_match ? "=" : "")),
  990.                    &clcf->name);

  992.     ngx_http_update_location_config(r);

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

  998.     if (r->headers_in.content_length_n != -1
  999.         && !r->discard_body
  1000.         && clcf->client_max_body_size
  1001.         && clcf->client_max_body_size < r->headers_in.content_length_n)
  1002.     {
  1003.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1004.                       "client intended to send too large body: %O bytes",
  1005.                       r->headers_in.content_length_n);

  1007.         r->expect_tested = 1;
  1008.         (void) ngx_http_discard_request_body(r);
  1009.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_ENTITY_TOO_LARGE);
  1010.         return NGX_OK;
  1011.     }

  1013.     if (rc == NGX_DONE) {
  1014.         ngx_http_clear_location(r);

  1016.         r->headers_out.location = ngx_list_push(&r->headers_out.headers);
  1017.         if (r->headers_out.location == NULL) {
  1018.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1019.             return NGX_OK;
  1020.         }

  1022.         /*
  1023.          * we do not need to set the r->headers_out.location->hash and
  1024.          * r->headers_out.location->key fields
  1025.          */

  1027.         if (r->args.len == 0) {
  1028.             r->headers_out.location->value = clcf->name;

  1030.         } else {
  1031.             len = clcf->name.len + 1 + r->args.len;
  1032.             p = ngx_pnalloc(r->pool, len);

  1034.             if (p == NULL) {
  1035.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1036.                 return NGX_OK;
  1037.             }

  1039.             r->headers_out.location->value.len = len;
  1040.             r->headers_out.location->value.data = p;

  1042.             p = ngx_cpymem(p, clcf->name.data, clcf->name.len);
  1043.             *p++ = '?';
  1044.             ngx_memcpy(p, r->args.data, r->args.len);
  1045.         }

  1047.         ngx_http_finalize_request(r, NGX_HTTP_MOVED_PERMANENTLY);
  1048.         return NGX_OK;
  1049.     }

  1051.     r->phase_handler++;
  1052.     return NGX_AGAIN;
  1053. }


  1056. ngx_int_t
  1057. ‌ngx_http_core_post_rewrite_phase(ngx_http_request_t *r,
  1058.     ngx_http_phase_handler_t *ph)
  1059. {
  1060.     ngx_http_core_srv_conf_t  *cscf;

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

  1065.     if (!r->uri_changed) {
  1066.         r->phase_handler++;
  1067.         return NGX_AGAIN;
  1068.     }

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

  1073.     /*
  1074.      * gcc before 3.3 compiles the broken code for
  1075.      *     if (r->uri_changes-- == 0)
  1076.      * if the r->uri_changes is defined as
  1077.      *     unsigned  uri_changes:4
  1078.      */

  1080.     r->uri_changes--;

  1082.     if (r->uri_changes == 0) {
  1083.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1084.                       "rewrite or internal redirection cycle "
  1085.                       "while processing \"%V\"", &r->uri);

  1087.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1088.         return NGX_OK;
  1089.     }

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

  1093.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  1094.     r->loc_conf = cscf->ctx->loc_conf;

  1096.     return NGX_AGAIN;
  1097. }


  1100. ngx_int_t
  1101. ‌ngx_http_core_access_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
  1102. {
  1103.     ngx_int_t                  rc;
  1104.     ngx_http_core_loc_conf_t  *clcf;

  1106.     if (r != r->main) {
  1107.         r->phase_handler = ph->next;
  1108.         return NGX_AGAIN;
  1109.     }

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

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

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

  1121.     if (rc == NGX_AGAIN || rc == NGX_DONE) {
  1122.         return NGX_OK;
  1123.     }

  1125.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

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

  1134.     } else {
  1135.         if (rc == NGX_OK) {
  1136.             r->access_code = 0;

  1138.             if (r->headers_out.www_authenticate) {
  1139.                 r->headers_out.www_authenticate->hash = 0;
  1140.             }

  1142.             r->phase_handler = ph->next;
  1143.             return NGX_AGAIN;
  1144.         }

  1146.         if (rc == NGX_HTTP_FORBIDDEN || rc == NGX_HTTP_UNAUTHORIZED) {
  1147.             if (r->access_code != NGX_HTTP_UNAUTHORIZED) {
  1148.                 r->access_code = rc;
  1149.             }

  1151.             r->phase_handler++;
  1152.             return NGX_AGAIN;
  1153.         }
  1154.     }

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

  1158.     ngx_http_finalize_request(r, rc);
  1159.     return NGX_OK;
  1160. }


  1163. ngx_int_t
  1164. ‌ngx_http_core_post_access_phase(ngx_http_request_t *r,
  1165.     ngx_http_phase_handler_t *ph)
  1166. {
  1167.     ngx_int_t  access_code;

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

  1172.     access_code = r->access_code;

  1174.     if (access_code) {
  1175.         if (access_code == NGX_HTTP_FORBIDDEN) {
  1176.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1177.                           "access forbidden by rule");
  1178.         }

  1180.         r->access_code = 0;
  1181.         ngx_http_finalize_request(r, access_code);
  1182.         return NGX_OK;
  1183.     }

  1185.     r->phase_handler++;
  1186.     return NGX_AGAIN;
  1187. }


  1190. ngx_int_t
  1191. ‌ngx_http_core_try_files_phase(ngx_http_request_t *r,
  1192.     ngx_http_phase_handler_t *ph)
  1193. {
  1194.     size_t                        len, root, alias, reserve, allocated;
  1195.     u_char                       *p, *name;
  1196.     ngx_str_t                     path, args;
  1197.     ngx_uint_t                    test_dir;
  1198.     ngx_http_try_file_t          *tf;
  1199.     ngx_open_file_info_t          of;
  1200.     ngx_http_script_code_pt       code;
  1201.     ngx_http_script_engine_t      e;
  1202.     ngx_http_core_loc_conf_t     *clcf;
  1203.     ngx_http_script_len_code_pt   lcode;

  1205.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1206.                    "try files phase: %ui", r->phase_handler);

  1208.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1210.     if (clcf->try_files == NULL) {
  1211.         r->phase_handler++;
  1212.         return NGX_AGAIN;
  1213.     }

  1215.     allocated = 0;
  1216.     root = 0;
  1217.     name = NULL;
  1218.     /* suppress MSVC warning */
  1219.     path.data = NULL;

  1221.     tf = clcf->try_files;

  1223.     alias = clcf->alias;

  1225.     for ( ;; ) {

  1227.         if (tf->lengths) {
  1228.             ngx_memzero(&e, sizeof(ngx_http_script_engine_t));

  1230.             e.ip = tf->lengths->elts;
  1231.             e.request = r;

  1233.             /* 1 is for terminating '\0' as in static names */
  1234.             len = 1;

  1236.             while (*(uintptr_t *) e.ip) {
  1237.                 lcode = *(ngx_http_script_len_code_pt *) e.ip;
  1238.                 len += lcode(&e);
  1239.             }

  1241.         } else {
  1242.             len = tf->name.len;
  1243.         }

  1245.         if (!alias) {
  1246.             reserve = len > r->uri.len ? len - r->uri.len : 0;

  1248.         } else if (alias == NGX_MAX_SIZE_T_VALUE) {
  1249.             reserve = len;

  1251.         } else {
  1252.             reserve = len > r->uri.len - alias ? len - (r->uri.len - alias) : 0;
  1253.         }

  1255.         if (reserve > allocated || !allocated) {

  1257.             /* 16 bytes are preallocation */
  1258.             allocated = reserve + 16;

  1260.             if (ngx_http_map_uri_to_path(r, &path, &root, allocated) == NULL) {
  1261.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1262.                 return NGX_OK;
  1263.             }

  1265.             name = path.data + root;
  1266.          }

  1268.         if (tf->values == NULL) {

  1270.             /* tf->name.len includes the terminating '\0' */

  1272.             ngx_memcpy(name, tf->name.data, tf->name.len);

  1274.             path.len = (name + tf->name.len - 1) - path.data;

  1276.         } else {
  1277.             e.ip = tf->values->elts;
  1278.             e.pos = name;
  1279.             e.flushed = 1;

  1281.             while (*(uintptr_t *) e.ip) {
  1282.                 code = *(ngx_http_script_code_pt *) e.ip;
  1283.                 code((ngx_http_script_engine_t *) &e);
  1284.             }

  1286.             path.len = e.pos - path.data;

  1288.             *e.pos = '\0';

  1290.             if (alias && ngx_strncmp(name, clcf->name.data, alias) == 0) {
  1291.                 ngx_memmove(name, name + alias, len - alias);
  1292.                 path.len -= alias;
  1293.             }
  1294.         }

  1296.         test_dir = tf->test_dir;

  1298.         tf++;

  1300.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1301.                        "trying to use %s: \"%s\" \"%s\"",
  1302.                        test_dir ? "dir" : "file", name, path.data);

  1304.         if (tf->lengths == NULL && tf->name.len == 0) {

  1306.             if (tf->code) {
  1307.                 ngx_http_finalize_request(r, tf->code);
  1308.                 return NGX_OK;
  1309.             }

  1311.             path.len -= root;
  1312.             path.data += root;

  1314.             if (path.data[0] == '@') {
  1315.                 (void) ngx_http_named_location(r, &path);

  1317.             } else {
  1318.                 ngx_http_split_args(r, &path, &args);

  1320.                 (void) ngx_http_internal_redirect(r, &path, &args);
  1321.             }

  1323.             ngx_http_finalize_request(r, NGX_DONE);
  1324.             return NGX_OK;
  1325.         }

  1327.         ngx_memzero(&of, sizeof(ngx_open_file_info_t));

  1329.         of.read_ahead = clcf->read_ahead;
  1330.         of.directio = clcf->directio;
  1331.         of.valid = clcf->open_file_cache_valid;
  1332.         of.min_uses = clcf->open_file_cache_min_uses;
  1333.         of.test_only = 1;
  1334.         of.errors = clcf->open_file_cache_errors;
  1335.         of.events = clcf->open_file_cache_events;

  1337.         if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) {
  1338.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1339.             return NGX_OK;
  1340.         }

  1342.         if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
  1343.             != NGX_OK)
  1344.         {
  1345.             if (of.err != NGX_ENOENT
  1346.                 && of.err != NGX_ENOTDIR
  1347.                 && of.err != NGX_ENAMETOOLONG)
  1348.             {
  1349.                 ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
  1350.                               "%s \"%s\" failed", of.failed, path.data);
  1351.             }

  1353.             continue;
  1354.         }

  1356.         if (of.is_dir != test_dir) {
  1357.             continue;
  1358.         }

  1360.         path.len -= root;
  1361.         path.data += root;

  1363.         if (!alias) {
  1364.             r->uri = path;

  1366.         } else if (alias == NGX_MAX_SIZE_T_VALUE) {
  1367.             if (!test_dir) {
  1368.                 r->uri = path;
  1369.                 r->add_uri_to_alias = 1;
  1370.             }

  1372.         } else {
  1373.             r->uri.len = alias + path.len;
  1374.             r->uri.data = ngx_pnalloc(r->pool, r->uri.len);
  1375.             if (r->uri.data == NULL) {
  1376.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1377.                 return NGX_OK;
  1378.             }

  1380.             p = ngx_copy(r->uri.data, clcf->name.data, alias);
  1381.             ngx_memcpy(p, name, path.len);
  1382.         }

  1384.         ngx_http_set_exten(r);

  1386.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1387.                        "try file uri: \"%V\"", &r->uri);

  1389.         r->phase_handler++;
  1390.         return NGX_AGAIN;
  1391.     }

  1393.     /* not reached */
  1394. }


  1397. ngx_int_t
  1398. ‌ngx_http_core_content_phase(ngx_http_request_t *r,
  1399.     ngx_http_phase_handler_t *ph)
  1400. {
  1401.     size_t     root;
  1402.     ngx_int_t  rc;
  1403.     ngx_str_t  path;

  1405.     if (r->content_handler) {
  1406.         r->write_event_handler = ngx_http_request_empty_handler;
  1407.         ngx_http_finalize_request(r, r->content_handler(r));
  1408.         return NGX_OK;
  1409.     }

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

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

  1416.     if (rc != NGX_DECLINED) {
  1417.         ngx_http_finalize_request(r, rc);
  1418.         return NGX_OK;
  1419.     }

  1421.     /* rc == NGX_DECLINED */

  1423.     ph++;

  1425.     if (ph->checker) {
  1426.         r->phase_handler++;
  1427.         return NGX_AGAIN;
  1428.     }

  1430.     /* no content handler was found */

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

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

  1439.         ngx_http_finalize_request(r, NGX_HTTP_FORBIDDEN);
  1440.         return NGX_OK;
  1441.     }

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

  1445.     ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  1446.     return NGX_OK;
  1447. }


  1450. void
  1451. ‌ngx_http_update_location_config(ngx_http_request_t *r)
  1452. {
  1453.     ngx_http_core_loc_conf_t  *clcf;

  1455.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1457.     if (r->method & clcf->limit_except) {
  1458.         r->loc_conf = clcf->limit_except_loc_conf;
  1459.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  1460.     }

  1462.     if (r == r->main) {
  1463.         ngx_http_set_connection_log(r->connection, clcf->error_log);
  1464.     }

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

  1469.     } else {
  1470.         r->connection->sendfile = 0;
  1471.     }

  1473.     if (clcf->client_body_in_file_only) {
  1474.         r->request_body_in_file_only = 1;
  1475.         r->request_body_in_persistent_file = 1;
  1476.         r->request_body_in_clean_file =
  1477.             clcf->client_body_in_file_only == NGX_HTTP_REQUEST_BODY_FILE_CLEAN;
  1478.         r->request_body_file_log_level = NGX_LOG_NOTICE;

  1480.     } else {
  1481.         r->request_body_file_log_level = NGX_LOG_WARN;
  1482.     }

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

  1486.     if (r->keepalive) {
  1487.         if (clcf->keepalive_timeout == 0) {
  1488.             r->keepalive = 0;

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

  1493.         } else if (r->headers_in.msie6
  1494.                    && r->method == NGX_HTTP_POST
  1495.                    && (clcf->keepalive_disable
  1496.                        & NGX_HTTP_KEEPALIVE_DISABLE_MSIE6))
  1497.         {
  1498.             /*
  1499.              * MSIE may wait for some time if an response for
  1500.              * a POST request was sent over a keepalive connection
  1501.              */
  1502.             r->keepalive = 0;

  1504.         } else if (r->headers_in.safari
  1505.                    && (clcf->keepalive_disable
  1506.                        & NGX_HTTP_KEEPALIVE_DISABLE_SAFARI))
  1507.         {
  1508.             /*
  1509.              * Safari may send a POST request to a closed keepalive
  1510.              * connection and may stall for some time, see
  1511.              *     https://bugs.webkit.org/show_bug.cgi?id=5760
  1512.              */
  1513.             r->keepalive = 0;
  1514.         }
  1515.     }

  1517.     if (!clcf->tcp_nopush) {
  1518.         /* disable TCP_NOPUSH/TCP_CORK use */
  1519.         r->connection->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  1520.     }

  1522.     if (r->limit_rate == 0) {
  1523.         r->limit_rate = clcf->limit_rate;
  1524.     }

  1526.     if (clcf->handler) {
  1527.         r->content_handler = clcf->handler;
  1528.     }
  1529. }


  1532. /*
  1533. * NGX_OK       - exact or regex match
  1534. * NGX_DONE     - auto redirect
  1535. * NGX_AGAIN    - inclusive match
  1536. * NGX_ERROR    - regex error
  1537. * NGX_DECLINED - no match
  1538. */

  1540. static ngx_int_t
  1541. ‌ngx_http_core_find_location(ngx_http_request_t *r)
  1542. {
  1543.     ngx_int_t                  rc;
  1544.     ngx_http_core_loc_conf_t  *pclcf;
  1545. #if (NGX_PCRE)
  1546.     ngx_int_t                  n;
  1547.     ngx_uint_t                 noregex;
  1548.     ngx_http_core_loc_conf_t  *clcf, **clcfp;

  1550.     noregex = 0;
  1551. #endif

  1553.     pclcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  1557.     if (rc == NGX_AGAIN) {

  1559. #if (NGX_PCRE)
  1560.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1562.         noregex = clcf->noregex;
  1563. #endif

  1565.         /* look up nested locations */

  1567.         rc = ngx_http_core_find_location(r);
  1568.     }

  1570.     if (rc == NGX_OK || rc == NGX_DONE) {
  1571.         return rc;
  1572.     }

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

  1576. #if (NGX_PCRE)

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

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

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

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

  1587.             if (n == NGX_OK) {
  1588.                 r->loc_conf = (*clcfp)->loc_conf;

  1590.                 /* look up nested locations */

  1592.                 rc = ngx_http_core_find_location(r);

  1594.                 return (rc == NGX_ERROR) ? rc : NGX_OK;
  1595.             }

  1597.             if (n == NGX_DECLINED) {
  1598.                 continue;
  1599.             }

  1601.             return NGX_ERROR;
  1602.         }
  1603.     }
  1604. #endif

  1606.     return rc;
  1607. }


  1610. /*
  1611. * NGX_OK       - exact match
  1612. * NGX_DONE     - auto redirect
  1613. * NGX_AGAIN    - inclusive match
  1614. * NGX_DECLINED - no match
  1615. */

  1617. static ngx_int_t
  1618. ‌ngx_http_core_find_static_location(ngx_http_request_t *r,
  1619.     ngx_http_location_tree_node_t *node)
  1620. {
  1621.     u_char     *uri;
  1622.     size_t      len, n;
  1623.     ngx_int_t   rc, rv;

  1625.     len = r->uri.len;
  1626.     uri = r->uri.data;

  1628.     rv = NGX_DECLINED;

  1630.     for ( ;; ) {

  1632.         if (node == NULL) {
  1633.             return rv;
  1634.         }

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

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

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

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

  1646.             continue;
  1647.         }

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

  1651.             if (node->inclusive) {

  1653.                 r->loc_conf = node->inclusive->loc_conf;
  1654.                 rv = NGX_AGAIN;

  1656.                 node = node->tree;
  1657.                 uri += n;
  1658.                 len -= n;

  1660.                 continue;
  1661.             }

  1663.             /* exact only */

  1665.             node = node->right;

  1667.             continue;
  1668.         }

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

  1672.             if (node->exact) {
  1673.                 r->loc_conf = node->exact->loc_conf;
  1674.                 return NGX_OK;

  1676.             } else {
  1677.                 r->loc_conf = node->inclusive->loc_conf;
  1678.                 return NGX_AGAIN;
  1679.             }
  1680.         }

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

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

  1686.             r->loc_conf = (node->exact) ? node->exact->loc_conf:
  1687.                                           node->inclusive->loc_conf;
  1688.             rv = NGX_DONE;
  1689.         }

  1691.         node = node->left;
  1692.     }
  1693. }


  1696. void *
  1697. ‌ngx_http_test_content_type(ngx_http_request_t *r, ngx_hash_t *types_hash)
  1698. {
  1699.     u_char      c, *lowcase;
  1700.     size_t      len;
  1701.     ngx_uint_t  i, hash;

  1703.     if (types_hash->size == 0) {
  1704.         return (void *) 4;
  1705.     }

  1707.     if (r->headers_out.content_type.len == 0) {
  1708.         return NULL;
  1709.     }

  1711.     len = r->headers_out.content_type_len;

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

  1715.         lowcase = ngx_pnalloc(r->pool, len);
  1716.         if (lowcase == NULL) {
  1717.             return NULL;
  1718.         }

  1720.         r->headers_out.content_type_lowcase = lowcase;

  1722.         hash = 0;

  1724.         for (i = 0; i < len; i++) {
  1725.             c = ngx_tolower(r->headers_out.content_type.data[i]);
  1726.             hash = ngx_hash(hash, c);
  1727.             lowcase[i] = c;
  1728.         }

  1730.         r->headers_out.content_type_hash = hash;
  1731.     }

  1733.     return ngx_hash_find(types_hash, r->headers_out.content_type_hash,
  1734.                          r->headers_out.content_type_lowcase, len);
  1735. }


  1738. ngx_int_t
  1739. ‌ngx_http_set_content_type(ngx_http_request_t *r)
  1740. {
  1741.     u_char                     c, *exten;
  1742.     ngx_str_t                 *type;
  1743.     ngx_uint_t                 i, hash;
  1744.     ngx_http_core_loc_conf_t  *clcf;

  1746.     if (r->headers_out.content_type.len) {
  1747.         return NGX_OK;
  1748.     }

  1750.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  1754.         hash = 0;

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

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

  1761.                 exten = ngx_pnalloc(r->pool, r->exten.len);
  1762.                 if (exten == NULL) {
  1763.                     return NGX_ERROR;
  1764.                 }

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

  1768.                 r->exten.data = exten;

  1770.                 break;
  1771.             }

  1773.             hash = ngx_hash(hash, c);
  1774.         }

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

  1779.         if (type) {
  1780.             r->headers_out.content_type_len = type->len;
  1781.             r->headers_out.content_type = *type;

  1783.             return NGX_OK;
  1784.         }
  1785.     }

  1787.     r->headers_out.content_type_len = clcf->default_type.len;
  1788.     r->headers_out.content_type = clcf->default_type;

  1790.     return NGX_OK;
  1791. }


  1794. void
  1795. ‌ngx_http_set_exten(ngx_http_request_t *r)
  1796. {
  1797.     ngx_int_t  i;

  1799.     ngx_str_null(&r->exten);

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

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

  1807.             return;

  1809.         } else if (r->uri.data[i] == '/') {
  1810.             return;
  1811.         }
  1812.     }

  1814.     return;
  1815. }


  1818. ngx_int_t
  1819. ‌ngx_http_set_etag(ngx_http_request_t *r)
  1820. {
  1821.     ngx_table_elt_t           *etag;
  1822.     ngx_http_core_loc_conf_t  *clcf;

  1824.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1826.     if (!clcf->etag) {
  1827.         return NGX_OK;
  1828.     }

  1830.     etag = ngx_list_push(&r->headers_out.headers);
  1831.     if (etag == NULL) {
  1832.         return NGX_ERROR;
  1833.     }

  1835.     etag->hash = 1;
  1836.     ngx_str_set(&etag->key, "ETag");

  1838.     etag->value.data = ngx_pnalloc(r->pool, NGX_OFF_T_LEN + NGX_TIME_T_LEN + 3);
  1839.     if (etag->value.data == NULL) {
  1840.         etag->hash = 0;
  1841.         return NGX_ERROR;
  1842.     }

  1844.     etag->value.len = ngx_sprintf(etag->value.data, "\"%xT-%xO\"",
  1845.                                   r->headers_out.last_modified_time,
  1846.                                   r->headers_out.content_length_n)
  1847.                       - etag->value.data;

  1849.     r->headers_out.etag = etag;

  1851.     return NGX_OK;
  1852. }


  1855. void
  1856. ‌ngx_http_weak_etag(ngx_http_request_t *r)
  1857. {
  1858.     size_t            len;
  1859.     u_char           *p;
  1860.     ngx_table_elt_t  *etag;

  1862.     etag = r->headers_out.etag;

  1864.     if (etag == NULL) {
  1865.         return;
  1866.     }

  1868.     if (etag->value.len > 2
  1869.         && etag->value.data[0] == 'W'
  1870.         && etag->value.data[1] == '/')
  1871.     {
  1872.         return;
  1873.     }

  1875.     if (etag->value.len < 1 || etag->value.data[0] != '"') {
  1876.         r->headers_out.etag->hash = 0;
  1877.         r->headers_out.etag = NULL;
  1878.         return;
  1879.     }

  1881.     p = ngx_pnalloc(r->pool, etag->value.len + 2);
  1882.     if (p == NULL) {
  1883.         r->headers_out.etag->hash = 0;
  1884.         r->headers_out.etag = NULL;
  1885.         return;
  1886.     }

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

  1890.     etag->value.data = p;
  1891.     etag->value.len = len;
  1892. }


  1895. ngx_int_t
  1896. ‌ngx_http_send_response(ngx_http_request_t *r, ngx_uint_t status,
  1897.     ngx_str_t *ct, ngx_http_complex_value_t *cv)
  1898. {
  1899.     ngx_int_t     rc;
  1900.     ngx_str_t     val;
  1901.     ngx_buf_t    *b;
  1902.     ngx_chain_t   out;

  1904.     if (ngx_http_discard_request_body(r) != NGX_OK) {
  1905.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1906.     }

  1908.     r->headers_out.status = status;

  1910.     if (ngx_http_complex_value(r, cv, &val) != NGX_OK) {
  1911.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1912.     }

  1914.     if (status == NGX_HTTP_MOVED_PERMANENTLY
  1915.         || status == NGX_HTTP_MOVED_TEMPORARILY
  1916.         || status == NGX_HTTP_SEE_OTHER
  1917.         || status == NGX_HTTP_TEMPORARY_REDIRECT)
  1918.     {
  1919.         ngx_http_clear_location(r);

  1921.         r->headers_out.location = ngx_list_push(&r->headers_out.headers);
  1922.         if (r->headers_out.location == NULL) {
  1923.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1924.         }

  1926.         r->headers_out.location->hash = 1;
  1927.         ngx_str_set(&r->headers_out.location->key, "Location");
  1928.         r->headers_out.location->value = val;

  1930.         return status;
  1931.     }

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

  1935.     if (ct) {
  1936.         r->headers_out.content_type_len = ct->len;
  1937.         r->headers_out.content_type = *ct;

  1939.     } else {
  1940.         if (ngx_http_set_content_type(r) != NGX_OK) {
  1941.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1942.         }
  1943.     }

  1945.     if (r->method == NGX_HTTP_HEAD || (r != r->main && val.len == 0)) {
  1946.         return ngx_http_send_header(r);
  1947.     }

  1949.     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
  1950.     if (b == NULL) {
  1951.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1952.     }

  1954.     b->pos = val.data;
  1955.     b->last = val.data + val.len;
  1956.     b->memory = val.len ? 1 : 0;
  1957.     b->last_buf = (r == r->main) ? 1 : 0;
  1958.     b->last_in_chain = 1;

  1960.     out.buf = b;
  1961.     out.next = NULL;

  1963.     rc = ngx_http_send_header(r);

  1965.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  1966.         return rc;
  1967.     }

  1969.     return ngx_http_output_filter(r, &out);
  1970. }


  1973. ngx_int_t
  1974. ‌ngx_http_send_header(ngx_http_request_t *r)
  1975. {
  1976.     if (r->post_action) {
  1977.         return NGX_OK;
  1978.     }

  1980.     if (r->header_sent) {
  1981.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1982.                       "header already sent");
  1983.         return NGX_ERROR;
  1984.     }

  1986.     if (r->err_status) {
  1987.         r->headers_out.status = r->err_status;
  1988.         r->headers_out.status_line.len = 0;
  1989.     }

  1991.     return ngx_http_top_header_filter(r);
  1992. }


  1995. ngx_int_t
  1996. ‌ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1997. {
  1998.     ngx_int_t          rc;
  1999.     ngx_connection_t  *c;

  2001.     c = r->connection;

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

  2006.     rc = ngx_http_top_body_filter(r, in);

  2008.     if (rc == NGX_ERROR) {
  2009.         /* NGX_ERROR may be returned by any filter */
  2010.         c->error = 1;
  2011.     }

  2013.     return rc;
  2014. }


  2017. u_char *
  2018. ‌ngx_http_map_uri_to_path(ngx_http_request_t *r, ngx_str_t *path,
  2019.     size_t *root_length, size_t reserved)
  2020. {
  2021.     u_char                    *last;
  2022.     size_t                     alias;
  2023.     ngx_http_core_loc_conf_t  *clcf;

  2025.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2027.     alias = clcf->alias;

  2029.     if (alias && !r->valid_location) {
  2030.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  2031.                       "\"alias\" cannot be used in location \"%V\" "
  2032.                       "where URI was rewritten", &clcf->name);
  2033.         return NULL;
  2034.     }

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

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

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

  2042.         path->data = ngx_pnalloc(r->pool, path->len);
  2043.         if (path->data == NULL) {
  2044.             return NULL;
  2045.         }

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

  2049.     } else {

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

  2054.         } else {
  2055.             reserved += r->uri.len - alias + 1;
  2056.         }

  2058.         if (ngx_http_script_run(r, path, clcf->root_lengths->elts, reserved,
  2059.                                 clcf->root_values->elts)
  2060.             == NULL)
  2061.         {
  2062.             return NULL;
  2063.         }

  2065.         if (ngx_get_full_name(r->pool, (ngx_str_t *) &ngx_cycle->prefix, path)
  2066.             != NGX_OK)
  2067.         {
  2068.             return NULL;
  2069.         }

  2071.         *root_length = path->len - reserved;
  2072.         last = path->data + *root_length;

  2074.         if (alias == NGX_MAX_SIZE_T_VALUE) {
  2075.             if (!r->add_uri_to_alias) {
  2076.                 *last = '\0';
  2077.                 return last;
  2078.             }

  2080.             alias = 0;
  2081.         }
  2082.     }

  2084.     last = ngx_cpystrn(last, r->uri.data + alias, r->uri.len - alias + 1);

  2086.     return last;
  2087. }


  2090. ngx_int_t
  2091. ‌ngx_http_auth_basic_user(ngx_http_request_t *r)
  2092. {
  2093.     ngx_str_t   auth, encoded;
  2094.     ngx_uint_t  len;

  2096.     if (r->headers_in.user.len == 0 && r->headers_in.user.data != NULL) {
  2097.         return NGX_DECLINED;
  2098.     }

  2100.     if (r->headers_in.authorization == NULL) {
  2101.         r->headers_in.user.data = (u_char *) "";
  2102.         return NGX_DECLINED;
  2103.     }

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

  2107.     if (encoded.len < sizeof("Basic ") - 1
  2108.         || ngx_strncasecmp(encoded.data, (u_char *) "Basic ",
  2109.                            sizeof("Basic ") - 1)
  2110.            != 0)
  2111.     {
  2112.         r->headers_in.user.data = (u_char *) "";
  2113.         return NGX_DECLINED;
  2114.     }

  2116.     encoded.len -= sizeof("Basic ") - 1;
  2117.     encoded.data += sizeof("Basic ") - 1;

  2119.     while (encoded.len && encoded.data[0] == ' ') {
  2120.         encoded.len--;
  2121.         encoded.data++;
  2122.     }

  2124.     if (encoded.len == 0) {
  2125.         r->headers_in.user.data = (u_char *) "";
  2126.         return NGX_DECLINED;
  2127.     }

  2129.     auth.len = ngx_base64_decoded_length(encoded.len);
  2130.     auth.data = ngx_pnalloc(r->pool, auth.len + 1);
  2131.     if (auth.data == NULL) {
  2132.         return NGX_ERROR;
  2133.     }

  2135.     if (ngx_decode_base64(&auth, &encoded) != NGX_OK) {
  2136.         r->headers_in.user.data = (u_char *) "";
  2137.         return NGX_DECLINED;
  2138.     }

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

  2142.     for (len = 0; len < auth.len; len++) {
  2143.         if (auth.data[len] == ':') {
  2144.             break;
  2145.         }
  2146.     }

  2148.     if (len == 0 || len == auth.len) {
  2149.         r->headers_in.user.data = (u_char *) "";
  2150.         return NGX_DECLINED;
  2151.     }

  2153.     r->headers_in.user.len = len;
  2154.     r->headers_in.user.data = auth.data;
  2155.     r->headers_in.passwd.len = auth.len - len - 1;
  2156.     r->headers_in.passwd.data = &auth.data[len + 1];

  2158.     return NGX_OK;
  2159. }


  2162. #if (NGX_HTTP_GZIP)

  2164. ngx_int_t
  2165. ‌ngx_http_gzip_ok(ngx_http_request_t *r)
  2166. {
  2167.     time_t                     date, expires;
  2168.     ngx_uint_t                 p;
  2169.     ngx_array_t               *cc;
  2170.     ngx_table_elt_t           *e, *d, *ae;
  2171.     ngx_http_core_loc_conf_t  *clcf;

  2173.     r->gzip_tested = 1;

  2175.     if (r != r->main) {
  2176.         return NGX_DECLINED;
  2177.     }

  2179. #if (NGX_HTTP_SPDY)
  2180.     if (r->spdy_stream) {
  2181.         r->gzip_ok = 1;
  2182.         return NGX_OK;
  2183.     }
  2184. #endif

  2186.     ae = r->headers_in.accept_encoding;
  2187.     if (ae == NULL) {
  2188.         return NGX_DECLINED;
  2189.     }

  2191.     if (ae->value.len < sizeof("gzip") - 1) {
  2192.         return NGX_DECLINED;
  2193.     }

  2195.     /*
  2196.      * test first for the most common case "gzip,...":
  2197.      *   MSIE:    "gzip, deflate"
  2198.      *   Firefox: "gzip,deflate"
  2199.      *   Chrome:  "gzip,deflate,sdch"
  2200.      *   Safari:  "gzip, deflate"
  2201.      *   Opera:   "gzip, deflate"
  2202.      */

  2204.     if (ngx_memcmp(ae->value.data, "gzip,", 5) != 0
  2205.         && ngx_http_gzip_accept_encoding(&ae->value) != NGX_OK)
  2206.     {
  2207.         return NGX_DECLINED;
  2208.     }

  2210.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2212.     if (r->headers_in.msie6 && clcf->gzip_disable_msie6) {
  2213.         return NGX_DECLINED;
  2214.     }

  2216.     if (r->http_version < clcf->gzip_http_version) {
  2217.         return NGX_DECLINED;
  2218.     }

  2220.     if (r->headers_in.via == NULL) {
  2221.         goto ok;
  2222.     }

  2224.     p = clcf->gzip_proxied;

  2226.     if (p & NGX_HTTP_GZIP_PROXIED_OFF) {
  2227.         return NGX_DECLINED;
  2228.     }

  2230.     if (p & NGX_HTTP_GZIP_PROXIED_ANY) {
  2231.         goto ok;
  2232.     }

  2234.     if (r->headers_in.authorization && (p & NGX_HTTP_GZIP_PROXIED_AUTH)) {
  2235.         goto ok;
  2236.     }

  2238.     e = r->headers_out.expires;

  2240.     if (e) {

  2242.         if (!(p & NGX_HTTP_GZIP_PROXIED_EXPIRED)) {
  2243.             return NGX_DECLINED;
  2244.         }

  2246.         expires = ngx_http_parse_time(e->value.data, e->value.len);
  2247.         if (expires == NGX_ERROR) {
  2248.             return NGX_DECLINED;
  2249.         }

  2251.         d = r->headers_out.date;

  2253.         if (d) {
  2254.             date = ngx_http_parse_time(d->value.data, d->value.len);
  2255.             if (date == NGX_ERROR) {
  2256.                 return NGX_DECLINED;
  2257.             }

  2259.         } else {
  2260.             date = ngx_time();
  2261.         }

  2263.         if (expires < date) {
  2264.             goto ok;
  2265.         }

  2267.         return NGX_DECLINED;
  2268.     }

  2270.     cc = &r->headers_out.cache_control;

  2272.     if (cc->elts) {

  2274.         if ((p & NGX_HTTP_GZIP_PROXIED_NO_CACHE)
  2275.             && ngx_http_parse_multi_header_lines(cc, &ngx_http_gzip_no_cache,
  2276.                                                  NULL)
  2277.                >= 0)
  2278.         {
  2279.             goto ok;
  2280.         }

  2282.         if ((p & NGX_HTTP_GZIP_PROXIED_NO_STORE)
  2283.             && ngx_http_parse_multi_header_lines(cc, &ngx_http_gzip_no_store,
  2284.                                                  NULL)
  2285.                >= 0)
  2286.         {
  2287.             goto ok;
  2288.         }

  2290.         if ((p & NGX_HTTP_GZIP_PROXIED_PRIVATE)
  2291.             && ngx_http_parse_multi_header_lines(cc, &ngx_http_gzip_private,
  2292.                                                  NULL)
  2293.                >= 0)
  2294.         {
  2295.             goto ok;
  2296.         }

  2298.         return NGX_DECLINED;
  2299.     }

  2301.     if ((p & NGX_HTTP_GZIP_PROXIED_NO_LM) && r->headers_out.last_modified) {
  2302.         return NGX_DECLINED;
  2303.     }

  2305.     if ((p & NGX_HTTP_GZIP_PROXIED_NO_ETAG) && r->headers_out.etag) {
  2306.         return NGX_DECLINED;
  2307.     }

  2309. ok:

  2311. #if (NGX_PCRE)

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

  2315.         if (ngx_regex_exec_array(clcf->gzip_disable,
  2316.                                  &r->headers_in.user_agent->value,
  2317.                                  r->connection->log)
  2318.             != NGX_DECLINED)
  2319.         {
  2320.             return NGX_DECLINED;
  2321.         }
  2322.     }

  2324. #endif

  2326.     r->gzip_ok = 1;

  2328.     return NGX_OK;
  2329. }


  2332. /*
  2333. * gzip is enabled for the following quantities:
  2334. *     "gzip; q=0.001" ... "gzip; q=1.000"
  2335. * gzip is disabled for the following quantities:
  2336. *     "gzip; q=0" ... "gzip; q=0.000", and for any invalid cases
  2337. */

  2339. static ngx_int_t
  2340. ‌ngx_http_gzip_accept_encoding(ngx_str_t *ae)
  2341. {
  2342.     u_char  *p, *start, *last;

  2344.     start = ae->data;
  2345.     last = start + ae->len;

  2347.     for ( ;; ) {
  2348.         p = ngx_strcasestrn(start, "gzip", 4 - 1);
  2349.         if (p == NULL) {
  2350.             return NGX_DECLINED;
  2351.         }

  2353.         if (p == start || (*(p - 1) == ',' || *(p - 1) == ' ')) {
  2354.             break;
  2355.         }

  2357.         start = p + 4;
  2358.     }

  2360.     p += 4;

  2362.     while (p < last) {
  2363.         switch (*p++) {
  2364.         case ',':
  2365.             return NGX_OK;
  2366.         case ';':
  2367.             goto quantity;
  2368.         case ' ':
  2369.             continue;
  2370.         default:
  2371.             return NGX_DECLINED;
  2372.         }
  2373.     }

  2375.     return NGX_OK;

  2377. quantity:

  2379.     while (p < last) {
  2380.         switch (*p++) {
  2381.         case 'q':
  2382.         case 'Q':
  2383.             goto equal;
  2384.         case ' ':
  2385.             continue;
  2386.         default:
  2387.             return NGX_DECLINED;
  2388.         }
  2389.     }

  2391.     return NGX_OK;

  2393. equal:

  2395.     if (p + 2 > last || *p++ != '=') {
  2396.         return NGX_DECLINED;
  2397.     }

  2399.     if (ngx_http_gzip_quantity(p, last) == 0) {
  2400.         return NGX_DECLINED;
  2401.     }

  2403.     return NGX_OK;
  2404. }


  2407. static ngx_uint_t
  2408. ‌ngx_http_gzip_quantity(u_char *p, u_char *last)
  2409. {
  2410.     u_char      c;
  2411.     ngx_uint_t  n, q;

  2413.     c = *p++;

  2415.     if (c != '0' && c != '1') {
  2416.         return 0;
  2417.     }

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

  2421.     if (p == last) {
  2422.         return q;
  2423.     }

  2425.     c = *p++;

  2427.     if (c == ',' || c == ' ') {
  2428.         return q;
  2429.     }

  2431.     if (c != '.') {
  2432.         return 0;
  2433.     }

  2435.     n = 0;

  2437.     while (p < last) {
  2438.         c = *p++;

  2440.         if (c == ',' || c == ' ') {
  2441.             break;
  2442.         }

  2444.         if (c >= '0' && c <= '9') {
  2445.             q += c - '0';
  2446.             n++;
  2447.             continue;
  2448.         }

  2450.         return 0;
  2451.     }

  2453.     if (q > 100 || n > 3) {
  2454.         return 0;
  2455.     }

  2457.     return q;
  2458. }

  2460. #endif


  2463. ngx_int_t
  2464. ‌ngx_http_subrequest(ngx_http_request_t *r,
  2465.     ngx_str_t *uri, ngx_str_t *args, ngx_http_request_t **psr,
  2466.     ngx_http_post_subrequest_t *ps, ngx_uint_t flags)
  2467. {
  2468.     ngx_time_t                    *tp;
  2469.     ngx_connection_t              *c;
  2470.     ngx_http_request_t            *sr;
  2471.     ngx_http_core_srv_conf_t      *cscf;
  2472.     ngx_http_postponed_request_t  *pr, *p;

  2474.     r->main->subrequests--;

  2476.     if (r->main->subrequests == 0) {
  2477.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2478.                       "subrequests cycle while processing \"%V\"", uri);
  2479.         r->main->subrequests = 1;
  2480.         return NGX_ERROR;
  2481.     }

  2483.     sr = ngx_pcalloc(r->pool, sizeof(ngx_http_request_t));
  2484.     if (sr == NULL) {
  2485.         return NGX_ERROR;
  2486.     }

  2488.     sr->signature = NGX_HTTP_MODULE;

  2490.     c = r->connection;
  2491.     sr->connection = c;

  2493.     sr->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);
  2494.     if (sr->ctx == NULL) {
  2495.         return NGX_ERROR;
  2496.     }

  2498.     if (ngx_list_init(&sr->headers_out.headers, r->pool, 20,
  2499.                       sizeof(ngx_table_elt_t))
  2500.         != NGX_OK)
  2501.     {
  2502.         return NGX_ERROR;
  2503.     }

  2505.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2506.     sr->main_conf = cscf->ctx->main_conf;
  2507.     sr->srv_conf = cscf->ctx->srv_conf;
  2508.     sr->loc_conf = cscf->ctx->loc_conf;

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

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

  2514.     ngx_http_clear_content_length(sr);
  2515.     ngx_http_clear_accept_ranges(sr);
  2516.     ngx_http_clear_last_modified(sr);

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

  2520. #if (NGX_HTTP_SPDY)
  2521.     sr->spdy_stream = r->spdy_stream;
  2522. #endif

  2524.     sr->method = NGX_HTTP_GET;
  2525.     sr->http_version = r->http_version;

  2527.     sr->request_line = r->request_line;
  2528.     sr->uri = *uri;

  2530.     if (args) {
  2531.         sr->args = *args;
  2532.     }

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

  2537.     sr->subrequest_in_memory = (flags & NGX_HTTP_SUBREQUEST_IN_MEMORY) != 0;
  2538.     sr->waited = (flags & NGX_HTTP_SUBREQUEST_WAITED) != 0;

  2540.     sr->unparsed_uri = r->unparsed_uri;
  2541.     sr->method_name = ngx_http_core_get_method;
  2542.     sr->http_protocol = r->http_protocol;

  2544.     ngx_http_set_exten(sr);

  2546.     sr->main = r->main;
  2547.     sr->parent = r;
  2548.     sr->post_subrequest = ps;
  2549.     sr->read_event_handler = ngx_http_request_empty_handler;
  2550.     sr->write_event_handler = ngx_http_handler;

  2552.     if (c->data == r && r->postponed == NULL) {
  2553.         c->data = sr;
  2554.     }

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

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

  2560.     pr = ngx_palloc(r->pool, sizeof(ngx_http_postponed_request_t));
  2561.     if (pr == NULL) {
  2562.         return NGX_ERROR;
  2563.     }

  2565.     pr->request = sr;
  2566.     pr->out = NULL;
  2567.     pr->next = NULL;

  2569.     if (r->postponed) {
  2570.         for (p = r->postponed; p->next; p = p->next) { /* void */ }
  2571.         p->next = pr;

  2573.     } else {
  2574.         r->postponed = pr;
  2575.     }

  2577.     sr->internal = 1;

  2579.     sr->discard_body = r->discard_body;
  2580.     sr->expect_tested = 1;
  2581.     sr->main_filter_need_in_memory = r->main_filter_need_in_memory;

  2583.     sr->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;

  2585.     tp = ngx_timeofday();
  2586.     sr->start_sec = tp->sec;
  2587.     sr->start_msec = tp->msec;

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

  2591.     *psr = sr;

  2593.     return ngx_http_post_request(sr, NULL);
  2594. }


  2597. ngx_int_t
  2598. ‌ngx_http_internal_redirect(ngx_http_request_t *r,
  2599.     ngx_str_t *uri, ngx_str_t *args)
  2600. {
  2601.     ngx_http_core_srv_conf_t  *cscf;

  2603.     r->uri_changes--;

  2605.     if (r->uri_changes == 0) {
  2606.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2607.                       "rewrite or internal redirection cycle "
  2608.                       "while internally redirecting to \"%V\"", uri);

  2610.         r->main->count++;
  2611.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2612.         return NGX_DONE;
  2613.     }

  2615.     r->uri = *uri;

  2617.     if (args) {
  2618.         r->args = *args;

  2620.     } else {
  2621.         ngx_str_null(&r->args);
  2622.     }

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

  2627.     ngx_http_set_exten(r);

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

  2632.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2633.     r->loc_conf = cscf->ctx->loc_conf;

  2635.     ngx_http_update_location_config(r);

  2637. #if (NGX_HTTP_CACHE)
  2638.     r->cache = NULL;
  2639. #endif

  2641.     r->internal = 1;
  2642.     r->valid_unparsed_uri = 0;
  2643.     r->add_uri_to_alias = 0;
  2644.     r->main->count++;

  2646.     ngx_http_handler(r);

  2648.     return NGX_DONE;
  2649. }


  2652. ngx_int_t
  2653. ‌ngx_http_named_location(ngx_http_request_t *r, ngx_str_t *name)
  2654. {
  2655.     ngx_http_core_srv_conf_t    *cscf;
  2656.     ngx_http_core_loc_conf_t   **clcfp;
  2657.     ngx_http_core_main_conf_t   *cmcf;

  2659.     r->main->count++;
  2660.     r->uri_changes--;

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

  2667.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2668.         return NGX_DONE;
  2669.     }

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

  2675.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2676.         return NGX_DONE;
  2677.     }

  2679.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  2681.     if (cscf->named_locations) {

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

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

  2688.             if (name->len != (*clcfp)->name.len
  2689.                 || ngx_strncmp(name->data, (*clcfp)->name.data, name->len) != 0)
  2690.             {
  2691.                 continue;
  2692.             }

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

  2698.             r->internal = 1;
  2699.             r->content_handler = NULL;
  2700.             r->uri_changed = 0;
  2701.             r->loc_conf = (*clcfp)->loc_conf;

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

  2706.             ngx_http_update_location_config(r);

  2708.             cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  2712.             r->write_event_handler = ngx_http_core_run_phases;
  2713.             ngx_http_core_run_phases(r);

  2715.             return NGX_DONE;
  2716.         }
  2717.     }

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

  2722.     ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);

  2724.     return NGX_DONE;
  2725. }


  2728. ngx_http_cleanup_t *
  2729. ‌ngx_http_cleanup_add(ngx_http_request_t *r, size_t size)
  2730. {
  2731.     ngx_http_cleanup_t  *cln;

  2733.     r = r->main;

  2735.     cln = ngx_palloc(r->pool, sizeof(ngx_http_cleanup_t));
  2736.     if (cln == NULL) {
  2737.         return NULL;
  2738.     }

  2740.     if (size) {
  2741.         cln->data = ngx_palloc(r->pool, size);
  2742.         if (cln->data == NULL) {
  2743.             return NULL;
  2744.         }

  2746.     } else {
  2747.         cln->data = NULL;
  2748.     }

  2750.     cln->handler = NULL;
  2751.     cln->next = r->cleanup;

  2753.     r->cleanup = cln;

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

  2758.     return cln;
  2759. }


  2762. ngx_int_t
  2763. ‌ngx_http_set_disable_symlinks(ngx_http_request_t *r,
  2764.     ngx_http_core_loc_conf_t *clcf, ngx_str_t *path, ngx_open_file_info_t *of)
  2765. {
  2766. #if (NGX_HAVE_OPENAT)
  2767.     u_char     *p;
  2768.     ngx_str_t   from;

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

  2772.     if (clcf->disable_symlinks_from == NULL) {
  2773.         return NGX_OK;
  2774.     }

  2776.     if (ngx_http_complex_value(r, clcf->disable_symlinks_from, &from)
  2777.         != NGX_OK)
  2778.     {
  2779.         return NGX_ERROR;
  2780.     }

  2782.     if (from.len == 0
  2783.         || from.len > path->len
  2784.         || ngx_memcmp(path->data, from.data, from.len) != 0)
  2785.     {
  2786.         return NGX_OK;
  2787.     }

  2789.     if (from.len == path->len) {
  2790.         of->disable_symlinks = NGX_DISABLE_SYMLINKS_OFF;
  2791.         return NGX_OK;
  2792.     }

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

  2796.     if (*p == '/') {
  2797.         of->disable_symlinks_from = from.len;
  2798.         return NGX_OK;
  2799.     }

  2801.     p--;

  2803.     if (*p == '/') {
  2804.         of->disable_symlinks_from = from.len - 1;
  2805.     }
  2806. #endif

  2808.     return NGX_OK;
  2809. }


  2812. ngx_int_t
  2813. ‌ngx_http_get_forwarded_addr(ngx_http_request_t *r, ngx_addr_t *addr,
  2814.     ngx_array_t *headers, ngx_str_t *value, ngx_array_t *proxies,
  2815.     int recursive)
  2816. {
  2817.     ngx_int_t          rc;
  2818.     ngx_uint_t         i, found;
  2819.     ngx_table_elt_t  **h;

  2821.     if (headers == NULL) {
  2822.         return ngx_http_get_forwarded_addr_internal(r, addr, value->data,
  2823.                                                     value->len, proxies,
  2824.                                                     recursive);
  2825.     }

  2827.     i = headers->nelts;
  2828.     h = headers->elts;

  2830.     rc = NGX_DECLINED;

  2832.     found = 0;

  2834.     while (i-- > 0) {
  2835.         rc = ngx_http_get_forwarded_addr_internal(r, addr, h[i]->value.data,
  2836.                                                   h[i]->value.len, proxies,
  2837.                                                   recursive);

  2839.         if (!recursive) {
  2840.             break;
  2841.         }

  2843.         if (rc == NGX_DECLINED && found) {
  2844.             rc = NGX_DONE;
  2845.             break;
  2846.         }

  2848.         if (rc != NGX_OK) {
  2849.             break;
  2850.         }

  2852.         found = 1;
  2853.     }

  2855.     return rc;
  2856. }


  2859. static ngx_int_t
  2860. ‌ngx_http_get_forwarded_addr_internal(ngx_http_request_t *r, ngx_addr_t *addr,
  2861.     u_char *xff, size_t xfflen, ngx_array_t *proxies, int recursive)
  2862. {
  2863.     u_char           *p;
  2864.     in_addr_t         inaddr;
  2865.     ngx_int_t         rc;
  2866.     ngx_addr_t        paddr;
  2867.     ngx_cidr_t       *cidr;
  2868.     ngx_uint_t        family, i;
  2869. #if (NGX_HAVE_INET6)
  2870.     ngx_uint_t        n;
  2871.     struct in6_addr  *inaddr6;
  2872. #endif

  2874. #if (NGX_SUPPRESS_WARN)
  2875.     inaddr = 0;
  2876. #if (NGX_HAVE_INET6)
  2877.     inaddr6 = NULL;
  2878. #endif
  2879. #endif

  2881.     family = addr->sockaddr->sa_family;

  2883.     if (family == AF_INET) {
  2884.         inaddr = ((struct sockaddr_in *) addr->sockaddr)->sin_addr.s_addr;
  2885.     }

  2887. #if (NGX_HAVE_INET6)
  2888.     else if (family == AF_INET6) {
  2889.         inaddr6 = &((struct sockaddr_in6 *) addr->sockaddr)->sin6_addr;

  2891.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  2892.             family = AF_INET;

  2894.             p = inaddr6->s6_addr;

  2896.             inaddr = p[12] << 24;
  2897.             inaddr += p[13] << 16;
  2898.             inaddr += p[14] << 8;
  2899.             inaddr += p[15];

  2901.             inaddr = htonl(inaddr);
  2902.         }
  2903.     }
  2904. #endif

  2906.     for (cidr = proxies->elts, i = 0; i < proxies->nelts; i++) {
  2907.         if (cidr[i].family != family) {
  2908.             goto next;
  2909.         }

  2911.         switch (family) {

  2913. #if (NGX_HAVE_INET6)
  2914.         case AF_INET6:
  2915.             for (n = 0; n < 16; n++) {
  2916.                 if ((inaddr6->s6_addr[n] & cidr[i].u.in6.mask.s6_addr[n])
  2917.                     != cidr[i].u.in6.addr.s6_addr[n])
  2918.                 {
  2919.                     goto next;
  2920.                 }
  2921.             }
  2922.             break;
  2923. #endif

  2925. #if (NGX_HAVE_UNIX_DOMAIN)
  2926.         case AF_UNIX:
  2927.             break;
  2928. #endif

  2930.         default: /* AF_INET */
  2931.             if ((inaddr & cidr[i].u.in.mask) != cidr[i].u.in.addr) {
  2932.                 goto next;
  2933.             }
  2934.             break;
  2935.         }

  2937.         for (p = xff + xfflen - 1; p > xff; p--, xfflen--) {
  2938.             if (*p != ' ' && *p != ',') {
  2939.                 break;
  2940.             }
  2941.         }

  2943.         for ( /* void */ ; p > xff; p--) {
  2944.             if (*p == ' ' || *p == ',') {
  2945.                 p++;
  2946.                 break;
  2947.             }
  2948.         }

  2950.         if (ngx_parse_addr(r->pool, &paddr, p, xfflen - (p - xff)) != NGX_OK) {
  2951.             return NGX_DECLINED;
  2952.         }

  2954.         *addr = paddr;

  2956.         if (recursive && p > xff) {
  2957.             rc = ngx_http_get_forwarded_addr_internal(r, addr, xff, p - 1 - xff,
  2958.                                                       proxies, 1);

  2960.             if (rc == NGX_DECLINED) {
  2961.                 return NGX_DONE;
  2962.             }

  2964.             /* rc == NGX_OK || rc == NGX_DONE  */
  2965.             return rc;
  2966.         }

  2968.         return NGX_OK;

  2970.     next:
  2971.         continue;
  2972.     }

  2974.     return NGX_DECLINED;
  2975. }


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

  2992.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  2993.     if (ctx == NULL) {
  2994.         return NGX_CONF_ERROR;
  2995.     }

  2997.     http_ctx = cf->ctx;
  2998.     ctx->main_conf = http_ctx->main_conf;

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

  3002.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  3003.     if (ctx->srv_conf == NULL) {
  3004.         return NGX_CONF_ERROR;
  3005.     }

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

  3009.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  3010.     if (ctx->loc_conf == NULL) {
  3011.         return NGX_CONF_ERROR;
  3012.     }

  3014.     for (i = 0; ngx_modules[i]; i++) {
  3015.         if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
  3016.             continue;
  3017.         }

  3019.         module = ngx_modules[i]->ctx;

  3021.         if (module->create_srv_conf) {
  3022.             mconf = module->create_srv_conf(cf);
  3023.             if (mconf == NULL) {
  3024.                 return NGX_CONF_ERROR;
  3025.             }

  3027.             ctx->srv_conf[ngx_modules[i]->ctx_index] = mconf;
  3028.         }

  3030.         if (module->create_loc_conf) {
  3031.             mconf = module->create_loc_conf(cf);
  3032.             if (mconf == NULL) {
  3033.                 return NGX_CONF_ERROR;
  3034.             }

  3036.             ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
  3037.         }
  3038.     }


  3041.     /* the server configuration context */

  3043.     cscf = ctx->srv_conf[ngx_http_core_module.ctx_index];
  3044.     cscf->ctx = ctx;


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

  3049.     cscfp = ngx_array_push(&cmcf->servers);
  3050.     if (cscfp == NULL) {
  3051.         return NGX_CONF_ERROR;
  3052.     }

  3054.     *cscfp = cscf;


  3057.     /* parse inside server{} */

  3059.     pcf = *cf;
  3060.     cf->ctx = ctx;
  3061.     cf->cmd_type = NGX_HTTP_SRV_CONF;

  3063.     rv = ngx_conf_parse(cf, NULL);

  3065.     *cf = pcf;

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

  3070.         sin = &lsopt.u.sockaddr_in;

  3072.         sin->sin_family = AF_INET;
  3073. #if (NGX_WIN32)
  3074.         sin->sin_port = htons(80);
  3075. #else
  3076.         sin->sin_port = htons((getuid() == 0) ? 80 : 8000);
  3077. #endif
  3078.         sin->sin_addr.s_addr = INADDR_ANY;

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

  3082.         lsopt.backlog = NGX_LISTEN_BACKLOG;
  3083.         lsopt.rcvbuf = -1;
  3084.         lsopt.sndbuf = -1;
  3085. #if (NGX_HAVE_SETFIB)
  3086.         lsopt.setfib = -1;
  3087. #endif
  3088. #if (NGX_HAVE_TCP_FASTOPEN)
  3089.         lsopt.fastopen = -1;
  3090. #endif
  3091.         lsopt.wildcard = 1;

  3093.         (void) ngx_sock_ntop(&lsopt.u.sockaddr, lsopt.socklen, lsopt.addr,
  3094.                              NGX_SOCKADDR_STRLEN, 1);

  3096.         if (ngx_http_add_listen(cf, cscf, &lsopt) != NGX_OK) {
  3097.             return NGX_CONF_ERROR;
  3098.         }
  3099.     }

  3101.     return rv;
  3102. }


  3105. static char *
  3106. ‌ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  3107. {
  3108.     char                      *rv;
  3109.     u_char                    *mod;
  3110.     size_t                     len;
  3111.     ngx_str_t                 *value, *name;
  3112.     ngx_uint_t                 i;
  3113.     ngx_conf_t                 save;
  3114.     ngx_http_module_t         *module;
  3115.     ngx_http_conf_ctx_t       *ctx, *pctx;
  3116.     ngx_http_core_loc_conf_t  *clcf, *pclcf;

  3118.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  3119.     if (ctx == NULL) {
  3120.         return NGX_CONF_ERROR;
  3121.     }

  3123.     pctx = cf->ctx;
  3124.     ctx->main_conf = pctx->main_conf;
  3125.     ctx->srv_conf = pctx->srv_conf;

  3127.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  3128.     if (ctx->loc_conf == NULL) {
  3129.         return NGX_CONF_ERROR;
  3130.     }

  3132.     for (i = 0; ngx_modules[i]; i++) {
  3133.         if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
  3134.             continue;
  3135.         }

  3137.         module = ngx_modules[i]->ctx;

  3139.         if (module->create_loc_conf) {
  3140.             ctx->loc_conf[ngx_modules[i]->ctx_index] =
  3141.                                                    module->create_loc_conf(cf);
  3142.             if (ctx->loc_conf[ngx_modules[i]->ctx_index] == NULL) {
  3143.                  return NGX_CONF_ERROR;
  3144.             }
  3145.         }
  3146.     }

  3148.     clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
  3149.     clcf->loc_conf = ctx->loc_conf;

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

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

  3155.         len = value[1].len;
  3156.         mod = value[1].data;
  3157.         name = &value[2];

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

  3161.             clcf->name = *name;
  3162.             clcf->exact_match = 1;

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

  3166.             clcf->name = *name;
  3167.             clcf->noregex = 1;

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

  3171.             if (ngx_http_core_regex_location(cf, clcf, name, 0) != NGX_OK) {
  3172.                 return NGX_CONF_ERROR;
  3173.             }

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

  3177.             if (ngx_http_core_regex_location(cf, clcf, name, 1) != NGX_OK) {
  3178.                 return NGX_CONF_ERROR;
  3179.             }

  3181.         } else {
  3182.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3183.                                "invalid location modifier \"%V\"", &value[1]);
  3184.             return NGX_CONF_ERROR;
  3185.         }

  3187.     } else {

  3189.         name = &value[1];

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

  3193.             clcf->name.len = name->len - 1;
  3194.             clcf->name.data = name->data + 1;
  3195.             clcf->exact_match = 1;

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

  3199.             clcf->name.len = name->len - 2;
  3200.             clcf->name.data = name->data + 2;
  3201.             clcf->noregex = 1;

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

  3205.             name->len--;
  3206.             name->data++;

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

  3210.                 name->len--;
  3211.                 name->data++;

  3213.                 if (ngx_http_core_regex_location(cf, clcf, name, 1) != NGX_OK) {
  3214.                     return NGX_CONF_ERROR;
  3215.                 }

  3217.             } else {
  3218.                 if (ngx_http_core_regex_location(cf, clcf, name, 0) != NGX_OK) {
  3219.                     return NGX_CONF_ERROR;
  3220.                 }
  3221.             }

  3223.         } else {

  3225.             clcf->name = *name;

  3227.             if (name->data[0] == '@') {
  3228.                 clcf->named = 1;
  3229.             }
  3230.         }
  3231.     }

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

  3235.     if (pclcf->name.len) {

  3237.         /* nested location */

  3239. #if 0
  3240.         clcf->prev_location = pclcf;
  3241. #endif

  3243.         if (pclcf->exact_match) {
  3244.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3245.                                "location \"%V\" cannot be inside "
  3246.                                "the exact location \"%V\"",
  3247.                                &clcf->name, &pclcf->name);
  3248.             return NGX_CONF_ERROR;
  3249.         }

  3251.         if (pclcf->named) {
  3252.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3253.                                "location \"%V\" cannot be inside "
  3254.                                "the named location \"%V\"",
  3255.                                &clcf->name, &pclcf->name);
  3256.             return NGX_CONF_ERROR;
  3257.         }

  3259.         if (clcf->named) {
  3260.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3261.                                "named location \"%V\" can be "
  3262.                                "on the server level only",
  3263.                                &clcf->name);
  3264.             return NGX_CONF_ERROR;
  3265.         }

  3267.         len = pclcf->name.len;

  3269. #if (NGX_PCRE)
  3270.         if (clcf->regex == NULL
  3271.             && ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
  3272. #else
  3273.         if (ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
  3274. #endif
  3275.         {
  3276.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3277.                                "location \"%V\" is outside location \"%V\"",
  3278.                                &clcf->name, &pclcf->name);
  3279.             return NGX_CONF_ERROR;
  3280.         }
  3281.     }

  3283.     if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
  3284.         return NGX_CONF_ERROR;
  3285.     }

  3287.     save = *cf;
  3288.     cf->ctx = ctx;
  3289.     cf->cmd_type = NGX_HTTP_LOC_CONF;

  3291.     rv = ngx_conf_parse(cf, NULL);

  3293.     *cf = save;

  3295.     return rv;
  3296. }


  3299. static ngx_int_t
  3300. ‌ngx_http_core_regex_location(ngx_conf_t *cf, ngx_http_core_loc_conf_t *clcf,
  3301.     ngx_str_t *regex, ngx_uint_t caseless)
  3302. {
  3303. #if (NGX_PCRE)
  3304.     ngx_regex_compile_t  rc;
  3305.     u_char               errstr[NGX_MAX_CONF_ERRSTR];

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

  3309.     rc.pattern = *regex;
  3310.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  3311.     rc.err.data = errstr;

  3313. #if (NGX_HAVE_CASELESS_FILESYSTEM)
  3314.     rc.options = NGX_REGEX_CASELESS;
  3315. #else
  3316.     rc.options = caseless ? NGX_REGEX_CASELESS : 0;
  3317. #endif

  3319.     clcf->regex = ngx_http_regex_compile(cf, &rc);
  3320.     if (clcf->regex == NULL) {
  3321.         return NGX_ERROR;
  3322.     }

  3324.     clcf->name = *regex;

  3326.     return NGX_OK;

  3328. #else

  3330.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3331.                        "using regex \"%V\" requires PCRE library",
  3332.                        regex);
  3333.     return NGX_ERROR;

  3335. #endif
  3336. }


  3339. static char *
  3340. ‌ngx_http_core_types(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3341. {
  3342.     ngx_http_core_loc_conf_t *clcf = conf;

  3344.     char        *rv;
  3345.     ngx_conf_t   save;

  3347.     if (clcf->types == NULL) {
  3348.         clcf->types = ngx_array_create(cf->pool, 64, sizeof(ngx_hash_key_t));
  3349.         if (clcf->types == NULL) {
  3350.             return NGX_CONF_ERROR;
  3351.         }
  3352.     }

  3354.     save = *cf;
  3355.     cf->handler = ngx_http_core_type;
  3356.     cf->handler_conf = conf;

  3358.     rv = ngx_conf_parse(cf, NULL);

  3360.     *cf = save;

  3362.     return rv;
  3363. }


  3366. static char *
  3367. ‌ngx_http_core_type(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
  3368. {
  3369.     ngx_http_core_loc_conf_t *clcf = conf;

  3371.     ngx_str_t       *value, *content_type, *old;
  3372.     ngx_uint_t       i, n, hash;
  3373.     ngx_hash_key_t  *type;

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

  3377.     if (ngx_strcmp(value[0].data, "include") == 0) {
  3378.         if (cf->args->nelts != 2) {
  3379.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3380.                                "invalid number of arguments"
  3381.                                " in \"include\" directive");
  3382.             return NGX_CONF_ERROR;
  3383.         }

  3385.         return ngx_conf_include(cf, dummy, conf);
  3386.     }

  3388.     content_type = ngx_palloc(cf->pool, sizeof(ngx_str_t));
  3389.     if (content_type == NULL) {
  3390.         return NGX_CONF_ERROR;
  3391.     }

  3393.     *content_type = value[0];

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

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

  3399.         type = clcf->types->elts;
  3400.         for (n = 0; n < clcf->types->nelts; n++) {
  3401.             if (ngx_strcmp(value[i].data, type[n].key.data) == 0) {
  3402.                 old = type[n].value;
  3403.                 type[n].value = content_type;

  3405.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  3406.                                    "duplicate extension \"%V\", "
  3407.                                    "content type: \"%V\", "
  3408.                                    "previous content type: \"%V\"",
  3409.                                    &value[i], content_type, old);
  3410.                 goto next;
  3411.             }
  3412.         }


  3415.         type = ngx_array_push(clcf->types);
  3416.         if (type == NULL) {
  3417.             return NGX_CONF_ERROR;
  3418.         }

  3420.         type->key = value[i];
  3421.         type->key_hash = hash;
  3422.         type->value = content_type;

  3424.     next:
  3425.         continue;
  3426.     }

  3428.     return NGX_CONF_OK;
  3429. }


  3432. static ngx_int_t
  3433. ‌ngx_http_core_preconfiguration(ngx_conf_t *cf)
  3434. {
  3435.     return ngx_http_variables_add_core_vars(cf);
  3436. }


  3439. static void *
  3440. ‌ngx_http_core_create_main_conf(ngx_conf_t *cf)
  3441. {
  3442.     ngx_http_core_main_conf_t  *cmcf;

  3444.     cmcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_main_conf_t));
  3445.     if (cmcf == NULL) {
  3446.         return NULL;
  3447.     }

  3449.     if (ngx_array_init(&cmcf->servers, cf->pool, 4,
  3450.                        sizeof(ngx_http_core_srv_conf_t *))
  3451.         != NGX_OK)
  3452.     {
  3453.         return NULL;
  3454.     }

  3456.     cmcf->server_names_hash_max_size = NGX_CONF_UNSET_UINT;
  3457.     cmcf->server_names_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3459.     cmcf->variables_hash_max_size = NGX_CONF_UNSET_UINT;
  3460.     cmcf->variables_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3462.     return cmcf;
  3463. }


  3466. static char *
  3467. ‌ngx_http_core_init_main_conf(ngx_conf_t *cf, void *conf)
  3468. {
  3469.     ngx_http_core_main_conf_t *cmcf = conf;

  3471.     ngx_conf_init_uint_value(cmcf->server_names_hash_max_size, 512);
  3472.     ngx_conf_init_uint_value(cmcf->server_names_hash_bucket_size,
  3473.                              ngx_cacheline_size);

  3475.     cmcf->server_names_hash_bucket_size =
  3476.             ngx_align(cmcf->server_names_hash_bucket_size, ngx_cacheline_size);


  3479.     ngx_conf_init_uint_value(cmcf->variables_hash_max_size, 1024);
  3480.     ngx_conf_init_uint_value(cmcf->variables_hash_bucket_size, 64);

  3482.     cmcf->variables_hash_bucket_size =
  3483.                ngx_align(cmcf->variables_hash_bucket_size, ngx_cacheline_size);

  3485.     if (cmcf->ncaptures) {
  3486.         cmcf->ncaptures = (cmcf->ncaptures + 1) * 3;
  3487.     }

  3489.     return NGX_CONF_OK;
  3490. }


  3493. static void *
  3494. ‌ngx_http_core_create_srv_conf(ngx_conf_t *cf)
  3495. {
  3496.     ngx_http_core_srv_conf_t  *cscf;

  3498.     cscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_srv_conf_t));
  3499.     if (cscf == NULL) {
  3500.         return NULL;
  3501.     }

  3503.     /*
  3504.      * set by ngx_pcalloc():
  3505.      *
  3506.      *     conf->client_large_buffers.num = 0;
  3507.      */

  3509.     if (ngx_array_init(&cscf->server_names, cf->temp_pool, 4,
  3510.                        sizeof(ngx_http_server_name_t))
  3511.         != NGX_OK)
  3512.     {
  3513.         return NULL;
  3514.     }

  3516.     cscf->connection_pool_size = NGX_CONF_UNSET_SIZE;
  3517.     cscf->request_pool_size = NGX_CONF_UNSET_SIZE;
  3518.     cscf->client_header_timeout = NGX_CONF_UNSET_MSEC;
  3519.     cscf->client_header_buffer_size = NGX_CONF_UNSET_SIZE;
  3520.     cscf->ignore_invalid_headers = NGX_CONF_UNSET;
  3521.     cscf->merge_slashes = NGX_CONF_UNSET;
  3522.     cscf->underscores_in_headers = NGX_CONF_UNSET;

  3524.     return cscf;
  3525. }


  3528. static char *
  3529. ‌ngx_http_core_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  3530. {
  3531.     ngx_http_core_srv_conf_t *prev = parent;
  3532.     ngx_http_core_srv_conf_t *conf = child;

  3534.     ngx_str_t                name;
  3535.     ngx_http_server_name_t  *sn;

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

  3539.     ngx_conf_merge_size_value(conf->connection_pool_size,
  3540.                               prev->connection_pool_size, 256);
  3541.     ngx_conf_merge_size_value(conf->request_pool_size,
  3542.                               prev->request_pool_size, 4096);
  3543.     ngx_conf_merge_msec_value(conf->client_header_timeout,
  3544.                               prev->client_header_timeout, 60000);
  3545.     ngx_conf_merge_size_value(conf->client_header_buffer_size,
  3546.                               prev->client_header_buffer_size, 1024);
  3547.     ngx_conf_merge_bufs_value(conf->large_client_header_buffers,
  3548.                               prev->large_client_header_buffers,
  3549.                               4, 8192);

  3551.     if (conf->large_client_header_buffers.size < conf->connection_pool_size) {
  3552.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3553.                            "the \"large_client_header_buffers\" size must be "
  3554.                            "equal to or greater than \"connection_pool_size\"");
  3555.         return NGX_CONF_ERROR;
  3556.     }

  3558.     ngx_conf_merge_value(conf->ignore_invalid_headers,
  3559.                               prev->ignore_invalid_headers, 1);

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

  3563.     ngx_conf_merge_value(conf->underscores_in_headers,
  3564.                               prev->underscores_in_headers, 0);

  3566.     if (conf->server_names.nelts == 0) {
  3567.         /* the array has 4 empty preallocated elements, so push cannot fail */
  3568.         sn = ngx_array_push(&conf->server_names);
  3569. #if (NGX_PCRE)
  3570.         sn->regex = NULL;
  3571. #endif
  3572.         sn->server = conf;
  3573.         ngx_str_set(&sn->name, "");
  3574.     }

  3576.     sn = conf->server_names.elts;
  3577.     name = sn[0].name;

  3579. #if (NGX_PCRE)
  3580.     if (sn->regex) {
  3581.         name.len++;
  3582.         name.data--;
  3583.     } else
  3584. #endif

  3586.     if (name.data[0] == '.') {
  3587.         name.len--;
  3588.         name.data++;
  3589.     }

  3591.     conf->server_name.len = name.len;
  3592.     conf->server_name.data = ngx_pstrdup(cf->pool, &name);
  3593.     if (conf->server_name.data == NULL) {
  3594.         return NGX_CONF_ERROR;
  3595.     }

  3597.     return NGX_CONF_OK;
  3598. }


  3601. static void *
  3602. ‌ngx_http_core_create_loc_conf(ngx_conf_t *cf)
  3603. {
  3604.     ngx_http_core_loc_conf_t  *clcf;

  3606.     clcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_loc_conf_t));
  3607.     if (clcf == NULL) {
  3608.         return NULL;
  3609.     }

  3611.     /*
  3612.      * set by ngx_pcalloc():
  3613.      *
  3614.      *     clcf->root = { 0, NULL };
  3615.      *     clcf->limit_except = 0;
  3616.      *     clcf->post_action = { 0, NULL };
  3617.      *     clcf->types = NULL;
  3618.      *     clcf->default_type = { 0, NULL };
  3619.      *     clcf->error_log = NULL;
  3620.      *     clcf->error_pages = NULL;
  3621.      *     clcf->try_files = NULL;
  3622.      *     clcf->client_body_path = NULL;
  3623.      *     clcf->regex = NULL;
  3624.      *     clcf->exact_match = 0;
  3625.      *     clcf->auto_redirect = 0;
  3626.      *     clcf->alias = 0;
  3627.      *     clcf->gzip_proxied = 0;
  3628.      *     clcf->keepalive_disable = 0;
  3629.      */

  3631.     clcf->client_max_body_size = NGX_CONF_UNSET;
  3632.     clcf->client_body_buffer_size = NGX_CONF_UNSET_SIZE;
  3633.     clcf->client_body_timeout = NGX_CONF_UNSET_MSEC;
  3634.     clcf->satisfy = NGX_CONF_UNSET_UINT;
  3635.     clcf->if_modified_since = NGX_CONF_UNSET_UINT;
  3636.     clcf->max_ranges = NGX_CONF_UNSET_UINT;
  3637.     clcf->client_body_in_file_only = NGX_CONF_UNSET_UINT;
  3638.     clcf->client_body_in_single_buffer = NGX_CONF_UNSET;
  3639.     clcf->internal = NGX_CONF_UNSET;
  3640.     clcf->sendfile = NGX_CONF_UNSET;
  3641.     clcf->sendfile_max_chunk = NGX_CONF_UNSET_SIZE;
  3642. #if (NGX_HAVE_FILE_AIO)
  3643.     clcf->aio = NGX_CONF_UNSET;
  3644. #endif
  3645.     clcf->read_ahead = NGX_CONF_UNSET_SIZE;
  3646.     clcf->directio = NGX_CONF_UNSET;
  3647.     clcf->directio_alignment = NGX_CONF_UNSET;
  3648.     clcf->tcp_nopush = NGX_CONF_UNSET;
  3649.     clcf->tcp_nodelay = NGX_CONF_UNSET;
  3650.     clcf->send_timeout = NGX_CONF_UNSET_MSEC;
  3651.     clcf->send_lowat = NGX_CONF_UNSET_SIZE;
  3652.     clcf->postpone_output = NGX_CONF_UNSET_SIZE;
  3653.     clcf->limit_rate = NGX_CONF_UNSET_SIZE;
  3654.     clcf->limit_rate_after = NGX_CONF_UNSET_SIZE;
  3655.     clcf->keepalive_timeout = NGX_CONF_UNSET_MSEC;
  3656.     clcf->keepalive_header = NGX_CONF_UNSET;
  3657.     clcf->keepalive_requests = NGX_CONF_UNSET_UINT;
  3658.     clcf->lingering_close = NGX_CONF_UNSET_UINT;
  3659.     clcf->lingering_time = NGX_CONF_UNSET_MSEC;
  3660.     clcf->lingering_timeout = NGX_CONF_UNSET_MSEC;
  3661.     clcf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  3662.     clcf->reset_timedout_connection = NGX_CONF_UNSET;
  3663.     clcf->server_name_in_redirect = NGX_CONF_UNSET;
  3664.     clcf->port_in_redirect = NGX_CONF_UNSET;
  3665.     clcf->msie_padding = NGX_CONF_UNSET;
  3666.     clcf->msie_refresh = NGX_CONF_UNSET;
  3667.     clcf->log_not_found = NGX_CONF_UNSET;
  3668.     clcf->log_subrequest = NGX_CONF_UNSET;
  3669.     clcf->recursive_error_pages = NGX_CONF_UNSET;
  3670.     clcf->server_tokens = NGX_CONF_UNSET;
  3671.     clcf->chunked_transfer_encoding = NGX_CONF_UNSET;
  3672.     clcf->etag = NGX_CONF_UNSET;
  3673.     clcf->types_hash_max_size = NGX_CONF_UNSET_UINT;
  3674.     clcf->types_hash_bucket_size = NGX_CONF_UNSET_UINT;

  3676.     clcf->open_file_cache = NGX_CONF_UNSET_PTR;
  3677.     clcf->open_file_cache_valid = NGX_CONF_UNSET;
  3678.     clcf->open_file_cache_min_uses = NGX_CONF_UNSET_UINT;
  3679.     clcf->open_file_cache_errors = NGX_CONF_UNSET;
  3680.     clcf->open_file_cache_events = NGX_CONF_UNSET;

  3682. #if (NGX_HTTP_GZIP)
  3683.     clcf->gzip_vary = NGX_CONF_UNSET;
  3684.     clcf->gzip_http_version = NGX_CONF_UNSET_UINT;
  3685. #if (NGX_PCRE)
  3686.     clcf->gzip_disable = NGX_CONF_UNSET_PTR;
  3687. #endif
  3688.     clcf->gzip_disable_msie6 = 3;
  3689. #if (NGX_HTTP_DEGRADATION)
  3690.     clcf->gzip_disable_degradation = 3;
  3691. #endif
  3692. #endif

  3694. #if (NGX_HAVE_OPENAT)
  3695.     clcf->disable_symlinks = NGX_CONF_UNSET_UINT;
  3696.     clcf->disable_symlinks_from = NGX_CONF_UNSET_PTR;
  3697. #endif

  3699.     return clcf;
  3700. }


  3703. ‌static ngx_str_t  ngx_http_core_text_html_type = ngx_string("text/html");
  3704. ‌static ngx_str_t  ngx_http_core_image_gif_type = ngx_string("image/gif");
  3705. ‌static ngx_str_t  ngx_http_core_image_jpeg_type = ngx_string("image/jpeg");

  3707. ‌static ngx_hash_key_t  ngx_http_core_default_types[] = {
  3708.     { ngx_string("html"), 0, &ngx_http_core_text_html_type },
  3709.     { ngx_string("gif"), 0, &ngx_http_core_image_gif_type },
  3710.     { ngx_string("jpg"), 0, &ngx_http_core_image_jpeg_type },
  3711.     { ngx_null_string, 0, NULL }
  3712. };


  3715. static char *
  3716. ‌ngx_http_core_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  3717. {
  3718.     ngx_http_core_loc_conf_t *prev = parent;
  3719.     ngx_http_core_loc_conf_t *conf = child;

  3721.     ngx_uint_t        i;
  3722.     ngx_hash_key_t   *type;
  3723.     ngx_hash_init_t   types_hash;

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

  3727.         conf->alias = prev->alias;
  3728.         conf->root = prev->root;
  3729.         conf->root_lengths = prev->root_lengths;
  3730.         conf->root_values = prev->root_values;

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

  3735.             if (ngx_conf_full_name(cf->cycle, &conf->root, 0) != NGX_OK) {
  3736.                 return NGX_CONF_ERROR;
  3737.             }
  3738.         }
  3739.     }

  3741.     if (conf->post_action.data == NULL) {
  3742.         conf->post_action = prev->post_action;
  3743.     }

  3745.     ngx_conf_merge_uint_value(conf->types_hash_max_size,
  3746.                               prev->types_hash_max_size, 1024);

  3748.     ngx_conf_merge_uint_value(conf->types_hash_bucket_size,
  3749.                               prev->types_hash_bucket_size, 64);

  3751.     conf->types_hash_bucket_size = ngx_align(conf->types_hash_bucket_size,
  3752.                                              ngx_cacheline_size);

  3754.     /*
  3755.      * the special handling of the "types" directive in the "http" section
  3756.      * to inherit the http's conf->types_hash to all servers
  3757.      */

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

  3761.         types_hash.hash = &prev->types_hash;
  3762.         types_hash.key = ngx_hash_key_lc;
  3763.         types_hash.max_size = conf->types_hash_max_size;
  3764.         types_hash.bucket_size = conf->types_hash_bucket_size;
  3765.         types_hash.name = "types_hash";
  3766.         types_hash.pool = cf->pool;
  3767.         types_hash.temp_pool = NULL;

  3769.         if (ngx_hash_init(&types_hash, prev->types->elts, prev->types->nelts)
  3770.             != NGX_OK)
  3771.         {
  3772.             return NGX_CONF_ERROR;
  3773.         }
  3774.     }

  3776.     if (conf->types == NULL) {
  3777.         conf->types = prev->types;
  3778.         conf->types_hash = prev->types_hash;
  3779.     }

  3781.     if (conf->types == NULL) {
  3782.         conf->types = ngx_array_create(cf->pool, 3, sizeof(ngx_hash_key_t));
  3783.         if (conf->types == NULL) {
  3784.             return NGX_CONF_ERROR;
  3785.         }

  3787.         for (i = 0; ngx_http_core_default_types[i].key.len; i++) {
  3788.             type = ngx_array_push(conf->types);
  3789.             if (type == NULL) {
  3790.                 return NGX_CONF_ERROR;
  3791.             }

  3793.             type->key = ngx_http_core_default_types[i].key;
  3794.             type->key_hash =
  3795.                        ngx_hash_key_lc(ngx_http_core_default_types[i].key.data,
  3796.                                        ngx_http_core_default_types[i].key.len);
  3797.             type->value = ngx_http_core_default_types[i].value;
  3798.         }
  3799.     }

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

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

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

  3818.     if (conf->error_log == NULL) {
  3819.         if (prev->error_log) {
  3820.             conf->error_log = prev->error_log;
  3821.         } else {
  3822.             conf->error_log = &cf->cycle->new_log;
  3823.         }
  3824.     }

  3826.     if (conf->error_pages == NULL && prev->error_pages) {
  3827.         conf->error_pages = prev->error_pages;
  3828.     }

  3830.     ngx_conf_merge_str_value(conf->default_type,
  3831.                               prev->default_type, "text/plain");

  3833.     ngx_conf_merge_off_value(conf->client_max_body_size,
  3834.                               prev->client_max_body_size, 1 * 1024 * 1024);
  3835.     ngx_conf_merge_size_value(conf->client_body_buffer_size,
  3836.                               prev->client_body_buffer_size,
  3837.                               (size_t) 2 * ngx_pagesize);
  3838.     ngx_conf_merge_msec_value(conf->client_body_timeout,
  3839.                               prev->client_body_timeout, 60000);

  3841.     ngx_conf_merge_bitmask_value(conf->keepalive_disable,
  3842.                               prev->keepalive_disable,
  3843.                               (NGX_CONF_BITMASK_SET
  3844.                                |NGX_HTTP_KEEPALIVE_DISABLE_MSIE6));
  3845.     ngx_conf_merge_uint_value(conf->satisfy, prev->satisfy,
  3846.                               NGX_HTTP_SATISFY_ALL);
  3847.     ngx_conf_merge_uint_value(conf->if_modified_since, prev->if_modified_since,
  3848.                               NGX_HTTP_IMS_EXACT);
  3849.     ngx_conf_merge_uint_value(conf->max_ranges, prev->max_ranges,
  3850.                               NGX_MAX_INT32_VALUE);
  3851.     ngx_conf_merge_uint_value(conf->client_body_in_file_only,
  3852.                               prev->client_body_in_file_only,
  3853.                               NGX_HTTP_REQUEST_BODY_FILE_OFF);
  3854.     ngx_conf_merge_value(conf->client_body_in_single_buffer,
  3855.                               prev->client_body_in_single_buffer, 0);
  3856.     ngx_conf_merge_value(conf->internal, prev->internal, 0);
  3857.     ngx_conf_merge_value(conf->sendfile, prev->sendfile, 0);
  3858.     ngx_conf_merge_size_value(conf->sendfile_max_chunk,
  3859.                               prev->sendfile_max_chunk, 0);
  3860. #if (NGX_HAVE_FILE_AIO)
  3861.     ngx_conf_merge_value(conf->aio, prev->aio, NGX_HTTP_AIO_OFF);
  3862. #endif
  3863.     ngx_conf_merge_size_value(conf->read_ahead, prev->read_ahead, 0);
  3864.     ngx_conf_merge_off_value(conf->directio, prev->directio,
  3865.                               NGX_OPEN_FILE_DIRECTIO_OFF);
  3866.     ngx_conf_merge_off_value(conf->directio_alignment, prev->directio_alignment,
  3867.                               512);
  3868.     ngx_conf_merge_value(conf->tcp_nopush, prev->tcp_nopush, 0);
  3869.     ngx_conf_merge_value(conf->tcp_nodelay, prev->tcp_nodelay, 1);

  3871.     ngx_conf_merge_msec_value(conf->send_timeout, prev->send_timeout, 60000);
  3872.     ngx_conf_merge_size_value(conf->send_lowat, prev->send_lowat, 0);
  3873.     ngx_conf_merge_size_value(conf->postpone_output, prev->postpone_output,
  3874.                               1460);
  3875.     ngx_conf_merge_size_value(conf->limit_rate, prev->limit_rate, 0);
  3876.     ngx_conf_merge_size_value(conf->limit_rate_after, prev->limit_rate_after,
  3877.                               0);
  3878.     ngx_conf_merge_msec_value(conf->keepalive_timeout,
  3879.                               prev->keepalive_timeout, 75000);
  3880.     ngx_conf_merge_sec_value(conf->keepalive_header,
  3881.                               prev->keepalive_header, 0);
  3882.     ngx_conf_merge_uint_value(conf->keepalive_requests,
  3883.                               prev->keepalive_requests, 100);
  3884.     ngx_conf_merge_uint_value(conf->lingering_close,
  3885.                               prev->lingering_close, NGX_HTTP_LINGERING_ON);
  3886.     ngx_conf_merge_msec_value(conf->lingering_time,
  3887.                               prev->lingering_time, 30000);
  3888.     ngx_conf_merge_msec_value(conf->lingering_timeout,
  3889.                               prev->lingering_timeout, 5000);
  3890.     ngx_conf_merge_msec_value(conf->resolver_timeout,
  3891.                               prev->resolver_timeout, 30000);

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

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

  3897.             /*
  3898.              * create dummy resolver in http {} context
  3899.              * to inherit it in all servers
  3900.              */

  3902.             prev->resolver = ngx_resolver_create(cf, NULL, 0);
  3903.             if (prev->resolver == NULL) {
  3904.                 return NGX_CONF_ERROR;
  3905.             }
  3906.         }

  3908.         conf->resolver = prev->resolver;
  3909.     }

  3911.     if (ngx_conf_merge_path_value(cf, &conf->client_body_temp_path,
  3912.                               prev->client_body_temp_path,
  3913.                               &ngx_http_client_temp_path)
  3914.         != NGX_OK)
  3915.     {
  3916.         return NGX_CONF_ERROR;
  3917.     }

  3919.     ngx_conf_merge_value(conf->reset_timedout_connection,
  3920.                               prev->reset_timedout_connection, 0);
  3921.     ngx_conf_merge_value(conf->server_name_in_redirect,
  3922.                               prev->server_name_in_redirect, 0);
  3923.     ngx_conf_merge_value(conf->port_in_redirect, prev->port_in_redirect, 1);
  3924.     ngx_conf_merge_value(conf->msie_padding, prev->msie_padding, 1);
  3925.     ngx_conf_merge_value(conf->msie_refresh, prev->msie_refresh, 0);
  3926.     ngx_conf_merge_value(conf->log_not_found, prev->log_not_found, 1);
  3927.     ngx_conf_merge_value(conf->log_subrequest, prev->log_subrequest, 0);
  3928.     ngx_conf_merge_value(conf->recursive_error_pages,
  3929.                               prev->recursive_error_pages, 0);
  3930.     ngx_conf_merge_value(conf->server_tokens, prev->server_tokens, 1);
  3931.     ngx_conf_merge_value(conf->chunked_transfer_encoding,
  3932.                               prev->chunked_transfer_encoding, 1);
  3933.     ngx_conf_merge_value(conf->etag, prev->etag, 1);

  3935.     ngx_conf_merge_ptr_value(conf->open_file_cache,
  3936.                               prev->open_file_cache, NULL);

  3938.     ngx_conf_merge_sec_value(conf->open_file_cache_valid,
  3939.                               prev->open_file_cache_valid, 60);

  3941.     ngx_conf_merge_uint_value(conf->open_file_cache_min_uses,
  3942.                               prev->open_file_cache_min_uses, 1);

  3944.     ngx_conf_merge_sec_value(conf->open_file_cache_errors,
  3945.                               prev->open_file_cache_errors, 0);

  3947.     ngx_conf_merge_sec_value(conf->open_file_cache_events,
  3948.                               prev->open_file_cache_events, 0);
  3949. #if (NGX_HTTP_GZIP)

  3951.     ngx_conf_merge_value(conf->gzip_vary, prev->gzip_vary, 0);
  3952.     ngx_conf_merge_uint_value(conf->gzip_http_version, prev->gzip_http_version,
  3953.                               NGX_HTTP_VERSION_11);
  3954.     ngx_conf_merge_bitmask_value(conf->gzip_proxied, prev->gzip_proxied,
  3955.                               (NGX_CONF_BITMASK_SET|NGX_HTTP_GZIP_PROXIED_OFF));

  3957. #if (NGX_PCRE)
  3958.     ngx_conf_merge_ptr_value(conf->gzip_disable, prev->gzip_disable, NULL);
  3959. #endif

  3961.     if (conf->gzip_disable_msie6 == 3) {
  3962.         conf->gzip_disable_msie6 =
  3963.             (prev->gzip_disable_msie6 == 3) ? 0 : prev->gzip_disable_msie6;
  3964.     }

  3966. #if (NGX_HTTP_DEGRADATION)

  3968.     if (conf->gzip_disable_degradation == 3) {
  3969.         conf->gzip_disable_degradation =
  3970.             (prev->gzip_disable_degradation == 3) ?
  3971.                  0 : prev->gzip_disable_degradation;
  3972.     }

  3974. #endif
  3975. #endif

  3977. #if (NGX_HAVE_OPENAT)
  3978.     ngx_conf_merge_uint_value(conf->disable_symlinks, prev->disable_symlinks,
  3979.                               NGX_DISABLE_SYMLINKS_OFF);
  3980.     ngx_conf_merge_ptr_value(conf->disable_symlinks_from,
  3981.                              prev->disable_symlinks_from, NULL);
  3982. #endif

  3984.     return NGX_CONF_OK;
  3985. }


  3988. static char *
  3989. ‌ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3990. {
  3991.     ngx_http_core_srv_conf_t *cscf = conf;

  3993.     ngx_str_t              *value, size;
  3994.     ngx_url_t               u;
  3995.     ngx_uint_t              n;
  3996.     ngx_http_listen_opt_t   lsopt;

  3998.     cscf->listen = 1;

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

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

  4004.     u.url = value[1];
  4005.     u.listen = 1;
  4006.     u.default_port = 80;

  4008.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  4009.         if (u.err) {
  4010.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4011.                                "%s in \"%V\" of the \"listen\" directive",
  4012.                                u.err, &u.url);
  4013.         }

  4015.         return NGX_CONF_ERROR;
  4016.     }

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

  4020.     ngx_memcpy(&lsopt.u.sockaddr, u.sockaddr, u.socklen);

  4022.     lsopt.socklen = u.socklen;
  4023.     lsopt.backlog = NGX_LISTEN_BACKLOG;
  4024.     lsopt.rcvbuf = -1;
  4025.     lsopt.sndbuf = -1;
  4026. #if (NGX_HAVE_SETFIB)
  4027.     lsopt.setfib = -1;
  4028. #endif
  4029. #if (NGX_HAVE_TCP_FASTOPEN)
  4030.     lsopt.fastopen = -1;
  4031. #endif
  4032.     lsopt.wildcard = u.wildcard;
  4033. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  4034.     lsopt.ipv6only = 1;
  4035. #endif

  4037.     (void) ngx_sock_ntop(&lsopt.u.sockaddr, lsopt.socklen, lsopt.addr,
  4038.                          NGX_SOCKADDR_STRLEN, 1);

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

  4042.         if (ngx_strcmp(value[n].data, "default_server") == 0
  4043.             || ngx_strcmp(value[n].data, "default") == 0)
  4044.         {
  4045.             lsopt.default_server = 1;
  4046.             continue;
  4047.         }

  4049.         if (ngx_strcmp(value[n].data, "bind") == 0) {
  4050.             lsopt.set = 1;
  4051.             lsopt.bind = 1;
  4052.             continue;
  4053.         }

  4055. #if (NGX_HAVE_SETFIB)
  4056.         if (ngx_strncmp(value[n].data, "setfib=", 7) == 0) {
  4057.             lsopt.setfib = ngx_atoi(value[n].data + 7, value[n].len - 7);
  4058.             lsopt.set = 1;
  4059.             lsopt.bind = 1;

  4061.             if (lsopt.setfib == NGX_ERROR) {
  4062.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4063.                                    "invalid setfib \"%V\"", &value[n]);
  4064.                 return NGX_CONF_ERROR;
  4065.             }

  4067.             continue;
  4068.         }
  4069. #endif

  4071. #if (NGX_HAVE_TCP_FASTOPEN)
  4072.         if (ngx_strncmp(value[n].data, "fastopen=", 9) == 0) {
  4073.             lsopt.fastopen = ngx_atoi(value[n].data + 9, value[n].len - 9);
  4074.             lsopt.set = 1;
  4075.             lsopt.bind = 1;

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

  4083.             continue;
  4084.         }
  4085. #endif

  4087.         if (ngx_strncmp(value[n].data, "backlog=", 8) == 0) {
  4088.             lsopt.backlog = ngx_atoi(value[n].data + 8, value[n].len - 8);
  4089.             lsopt.set = 1;
  4090.             lsopt.bind = 1;

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

  4098.             continue;
  4099.         }

  4101.         if (ngx_strncmp(value[n].data, "rcvbuf=", 7) == 0) {
  4102.             size.len = value[n].len - 7;
  4103.             size.data = value[n].data + 7;

  4105.             lsopt.rcvbuf = ngx_parse_size(&size);
  4106.             lsopt.set = 1;
  4107.             lsopt.bind = 1;

  4109.             if (lsopt.rcvbuf == NGX_ERROR) {
  4110.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4111.                                    "invalid rcvbuf \"%V\"", &value[n]);
  4112.                 return NGX_CONF_ERROR;
  4113.             }

  4115.             continue;
  4116.         }

  4118.         if (ngx_strncmp(value[n].data, "sndbuf=", 7) == 0) {
  4119.             size.len = value[n].len - 7;
  4120.             size.data = value[n].data + 7;

  4122.             lsopt.sndbuf = ngx_parse_size(&size);
  4123.             lsopt.set = 1;
  4124.             lsopt.bind = 1;

  4126.             if (lsopt.sndbuf == NGX_ERROR) {
  4127.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4128.                                    "invalid sndbuf \"%V\"", &value[n]);
  4129.                 return NGX_CONF_ERROR;
  4130.             }

  4132.             continue;
  4133.         }

  4135.         if (ngx_strncmp(value[n].data, "accept_filter=", 14) == 0) {
  4136. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  4137.             lsopt.accept_filter = (char *) &value[n].data[14];
  4138.             lsopt.set = 1;
  4139.             lsopt.bind = 1;
  4140. #else
  4141.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4142.                                "accept filters \"%V\" are not supported "
  4143.                                "on this platform, ignored",
  4144.                                &value[n]);
  4145. #endif
  4146.             continue;
  4147.         }

  4149.         if (ngx_strcmp(value[n].data, "deferred") == 0) {
  4150. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  4151.             lsopt.deferred_accept = 1;
  4152.             lsopt.set = 1;
  4153.             lsopt.bind = 1;
  4154. #else
  4155.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4156.                                "the deferred accept is not supported "
  4157.                                "on this platform, ignored");
  4158. #endif
  4159.             continue;
  4160.         }

  4162.         if (ngx_strncmp(value[n].data, "ipv6only=o", 10) == 0) {
  4163. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  4164.             struct sockaddr  *sa;

  4166.             sa = &lsopt.u.sockaddr;

  4168.             if (sa->sa_family == AF_INET6) {

  4170.                 if (ngx_strcmp(&value[n].data[10], "n") == 0) {
  4171.                     lsopt.ipv6only = 1;

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

  4176.                 } else {
  4177.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4178.                                        "invalid ipv6only flags \"%s\"",
  4179.                                        &value[n].data[9]);
  4180.                     return NGX_CONF_ERROR;
  4181.                 }

  4183.                 lsopt.set = 1;
  4184.                 lsopt.bind = 1;

  4186.             } else {
  4187.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4188.                                    "ipv6only is not supported "
  4189.                                    "on addr \"%s\", ignored", lsopt.addr);
  4190.             }

  4192.             continue;
  4193. #else
  4194.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4195.                                "ipv6only is not supported "
  4196.                                "on this platform");
  4197.             return NGX_CONF_ERROR;
  4198. #endif
  4199.         }

  4201.         if (ngx_strcmp(value[n].data, "ssl") == 0) {
  4202. #if (NGX_HTTP_SSL)
  4203.             lsopt.ssl = 1;
  4204.             continue;
  4205. #else
  4206.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4207.                                "the \"ssl\" parameter requires "
  4208.                                "ngx_http_ssl_module");
  4209.             return NGX_CONF_ERROR;
  4210. #endif
  4211.         }

  4213.         if (ngx_strcmp(value[n].data, "spdy") == 0) {
  4214. #if (NGX_HTTP_SPDY)
  4215.             lsopt.spdy = 1;
  4216.             continue;
  4217. #else
  4218.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4219.                                "the \"spdy\" parameter requires "
  4220.                                "ngx_http_spdy_module");
  4221.             return NGX_CONF_ERROR;
  4222. #endif
  4223.         }

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

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

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

  4233.             } else {

  4235. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  4236.                 u_char     *p, *end;
  4237.                 ngx_str_t   s;

  4239.                 end = value[n].data + value[n].len;
  4240.                 s.data = value[n].data + 13;

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

  4247.                 if (p > s.data) {
  4248.                     s.len = p - s.data;

  4250.                     lsopt.tcp_keepidle = ngx_parse_time(&s, 1);
  4251.                     if (lsopt.tcp_keepidle == (time_t) NGX_ERROR) {
  4252.                         goto invalid_so_keepalive;
  4253.                     }
  4254.                 }

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

  4258.                 p = ngx_strlchr(s.data, end, ':');
  4259.                 if (p == NULL) {
  4260.                     p = end;
  4261.                 }

  4263.                 if (p > s.data) {
  4264.                     s.len = p - s.data;

  4266.                     lsopt.tcp_keepintvl = ngx_parse_time(&s, 1);
  4267.                     if (lsopt.tcp_keepintvl == (time_t) NGX_ERROR) {
  4268.                         goto invalid_so_keepalive;
  4269.                     }
  4270.                 }

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

  4274.                 if (s.data < end) {
  4275.                     s.len = end - s.data;

  4277.                     lsopt.tcp_keepcnt = ngx_atoi(s.data, s.len);
  4278.                     if (lsopt.tcp_keepcnt == NGX_ERROR) {
  4279.                         goto invalid_so_keepalive;
  4280.                     }
  4281.                 }

  4283.                 if (lsopt.tcp_keepidle == 0 && lsopt.tcp_keepintvl == 0
  4284.                     && lsopt.tcp_keepcnt == 0)
  4285.                 {
  4286.                     goto invalid_so_keepalive;
  4287.                 }

  4289.                 lsopt.so_keepalive = 1;

  4291. #else

  4293.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4294.                                    "the \"so_keepalive\" parameter accepts "
  4295.                                    "only \"on\" or \"off\" on this platform");
  4296.                 return NGX_CONF_ERROR;

  4298. #endif
  4299.             }

  4301.             lsopt.set = 1;
  4302.             lsopt.bind = 1;

  4304.             continue;

  4306. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  4307.         invalid_so_keepalive:

  4309.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4310.                                "invalid so_keepalive value: \"%s\"",
  4311.                                &value[n].data[13]);
  4312.             return NGX_CONF_ERROR;
  4313. #endif
  4314.         }

  4316.         if (ngx_strcmp(value[n].data, "proxy_protocol") == 0) {
  4317.             lsopt.proxy_protocol = 1;
  4318.             continue;
  4319.         }

  4321.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4322.                            "invalid parameter \"%V\"", &value[n]);
  4323.         return NGX_CONF_ERROR;
  4324.     }

  4326.     if (ngx_http_add_listen(cf, cscf, &lsopt) == NGX_OK) {
  4327.         return NGX_CONF_OK;
  4328.     }

  4330.     return NGX_CONF_ERROR;
  4331. }


  4334. static char *
  4335. ‌ngx_http_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4336. {
  4337.     ngx_http_core_srv_conf_t *cscf = conf;

  4339.     u_char                   ch;
  4340.     ngx_str_t               *value;
  4341.     ngx_uint_t               i;
  4342.     ngx_http_server_name_t  *sn;

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

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

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

  4350.         if ((ch == '*' && (value[i].len < 3 || value[i].data[1] != '.'))
  4351.             || (ch == '.' && value[i].len < 2))
  4352.         {
  4353.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4354.                                "server name \"%V\" is invalid", &value[i]);
  4355.             return NGX_CONF_ERROR;
  4356.         }

  4358.         if (ngx_strchr(value[i].data, '/')) {
  4359.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  4360.                                "server name \"%V\" has suspicious symbols",
  4361.                                &value[i]);
  4362.         }

  4364.         sn = ngx_array_push(&cscf->server_names);
  4365.         if (sn == NULL) {
  4366.             return NGX_CONF_ERROR;
  4367.         }

  4369. #if (NGX_PCRE)
  4370.         sn->regex = NULL;
  4371. #endif
  4372.         sn->server = cscf;

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

  4377.         } else {
  4378.             sn->name = value[i];
  4379.         }

  4381.         if (value[i].data[0] != '~') {
  4382.             ngx_strlow(sn->name.data, sn->name.data, sn->name.len);
  4383.             continue;
  4384.         }

  4386. #if (NGX_PCRE)
  4387.         {
  4388.         u_char               *p;
  4389.         ngx_regex_compile_t   rc;
  4390.         u_char                errstr[NGX_MAX_CONF_ERRSTR];

  4392.         if (value[i].len == 1) {
  4393.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4394.                                "empty regex in server name \"%V\"", &value[i]);
  4395.             return NGX_CONF_ERROR;
  4396.         }

  4398.         value[i].len--;
  4399.         value[i].data++;

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

  4403.         rc.pattern = value[i];
  4404.         rc.err.len = NGX_MAX_CONF_ERRSTR;
  4405.         rc.err.data = errstr;

  4407.         for (p = value[i].data; p < value[i].data + value[i].len; p++) {
  4408.             if (*p >= 'A' && *p <= 'Z') {
  4409.                 rc.options = NGX_REGEX_CASELESS;
  4410.                 break;
  4411.             }
  4412.         }

  4414.         sn->regex = ngx_http_regex_compile(cf, &rc);
  4415.         if (sn->regex == NULL) {
  4416.             return NGX_CONF_ERROR;
  4417.         }

  4419.         sn->name = value[i];
  4420.         cscf->captures = (rc.captures > 0);
  4421.         }
  4422. #else
  4423.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4424.                            "using regex \"%V\" "
  4425.                            "requires PCRE library", &value[i]);

  4427.         return NGX_CONF_ERROR;
  4428. #endif
  4429.     }

  4431.     return NGX_CONF_OK;
  4432. }


  4435. static char *
  4436. ‌ngx_http_core_root(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4437. {
  4438.     ngx_http_core_loc_conf_t *clcf = conf;

  4440.     ngx_str_t                  *value;
  4441.     ngx_int_t                   alias;
  4442.     ngx_uint_t                  n;
  4443.     ngx_http_script_compile_t   sc;

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

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

  4449.         if ((clcf->alias != 0) == alias) {
  4450.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4451.                                "\"%V\" directive is duplicate",
  4452.                                &cmd->name);
  4453.         } else {
  4454.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4455.                                "\"%V\" directive is duplicate, "
  4456.                                "\"%s\" directive was specified earlier",
  4457.                                &cmd->name, clcf->alias ? "alias" : "root");
  4458.         }

  4460.         return NGX_CONF_ERROR;
  4461.     }

  4463.     if (clcf->named && alias) {
  4464.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4465.                            "the \"alias\" directive cannot be used "
  4466.                            "inside the named location");

  4468.         return NGX_CONF_ERROR;
  4469.     }

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

  4473.     if (ngx_strstr(value[1].data, "$document_root")
  4474.         || ngx_strstr(value[1].data, "${document_root}"))
  4475.     {
  4476.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4477.                            "the $document_root variable cannot be used "
  4478.                            "in the \"%V\" directive",
  4479.                            &cmd->name);

  4481.         return NGX_CONF_ERROR;
  4482.     }

  4484.     if (ngx_strstr(value[1].data, "$realpath_root")
  4485.         || ngx_strstr(value[1].data, "${realpath_root}"))
  4486.     {
  4487.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4488.                            "the $realpath_root variable cannot be used "
  4489.                            "in the \"%V\" directive",
  4490.                            &cmd->name);

  4492.         return NGX_CONF_ERROR;
  4493.     }

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

  4498.     if (!alias && clcf->root.data[clcf->root.len - 1] == '/') {
  4499.         clcf->root.len--;
  4500.     }

  4502.     if (clcf->root.data[0] != '$') {
  4503.         if (ngx_conf_full_name(cf->cycle, &clcf->root, 0) != NGX_OK) {
  4504.             return NGX_CONF_ERROR;
  4505.         }
  4506.     }

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

  4510.     ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
  4511.     sc.variables = n;

  4513. #if (NGX_PCRE)
  4514.     if (alias && clcf->regex) {
  4515.         clcf->alias = NGX_MAX_SIZE_T_VALUE;
  4516.         n = 1;
  4517.     }
  4518. #endif

  4520.     if (n) {
  4521.         sc.cf = cf;
  4522.         sc.source = &clcf->root;
  4523.         sc.lengths = &clcf->root_lengths;
  4524.         sc.values = &clcf->root_values;
  4525.         sc.complete_lengths = 1;
  4526.         sc.complete_values = 1;

  4528.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  4529.             return NGX_CONF_ERROR;
  4530.         }
  4531.     }

  4533.     return NGX_CONF_OK;
  4534. }


  4537. ‌static ngx_http_method_name_t  ngx_methods_names[] = {
  4538.    { (u_char *) "GET",       (uint32_t) ~NGX_HTTP_GET },
  4539.    { (u_char *) "HEAD",      (uint32_t) ~NGX_HTTP_HEAD },
  4540.    { (u_char *) "POST",      (uint32_t) ~NGX_HTTP_POST },
  4541.    { (u_char *) "PUT",       (uint32_t) ~NGX_HTTP_PUT },
  4542.    { (u_char *) "DELETE",    (uint32_t) ~NGX_HTTP_DELETE },
  4543.    { (u_char *) "MKCOL",     (uint32_t) ~NGX_HTTP_MKCOL },
  4544.    { (u_char *) "COPY",      (uint32_t) ~NGX_HTTP_COPY },
  4545.    { (u_char *) "MOVE",      (uint32_t) ~NGX_HTTP_MOVE },
  4546.    { (u_char *) "OPTIONS",   (uint32_t) ~NGX_HTTP_OPTIONS },
  4547.    { (u_char *) "PROPFIND",  (uint32_t) ~NGX_HTTP_PROPFIND },
  4548.    { (u_char *) "PROPPATCH", (uint32_t) ~NGX_HTTP_PROPPATCH },
  4549.    { (u_char *) "LOCK",      (uint32_t) ~NGX_HTTP_LOCK },
  4550.    { (u_char *) "UNLOCK",    (uint32_t) ~NGX_HTTP_UNLOCK },
  4551.    { (u_char *) "PATCH",     (uint32_t) ~NGX_HTTP_PATCH },
  4552.    { NULL, 0 }
  4553. };


  4556. static char *
  4557. ‌ngx_http_core_limit_except(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4558. {
  4559.     ngx_http_core_loc_conf_t *pclcf = conf;

  4561.     char                      *rv;
  4562.     void                      *mconf;
  4563.     ngx_str_t                 *value;
  4564.     ngx_uint_t                 i;
  4565.     ngx_conf_t                 save;
  4566.     ngx_http_module_t         *module;
  4567.     ngx_http_conf_ctx_t       *ctx, *pctx;
  4568.     ngx_http_method_name_t    *name;
  4569.     ngx_http_core_loc_conf_t  *clcf;

  4571.     if (pclcf->limit_except) {
  4572.         return "duplicate";
  4573.     }

  4575.     pclcf->limit_except = 0xffffffff;

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

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

  4582.             if (ngx_strcasecmp(value[i].data, name->name) == 0) {
  4583.                 pclcf->limit_except &= name->method;
  4584.                 goto next;
  4585.             }
  4586.         }

  4588.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4589.                            "invalid method \"%V\"", &value[i]);
  4590.         return NGX_CONF_ERROR;

  4592.     next:
  4593.         continue;
  4594.     }

  4596.     if (!(pclcf->limit_except & NGX_HTTP_GET)) {
  4597.         pclcf->limit_except &= (uint32_t) ~NGX_HTTP_HEAD;
  4598.     }

  4600.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  4601.     if (ctx == NULL) {
  4602.         return NGX_CONF_ERROR;
  4603.     }

  4605.     pctx = cf->ctx;
  4606.     ctx->main_conf = pctx->main_conf;
  4607.     ctx->srv_conf = pctx->srv_conf;

  4609.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  4610.     if (ctx->loc_conf == NULL) {
  4611.         return NGX_CONF_ERROR;
  4612.     }

  4614.     for (i = 0; ngx_modules[i]; i++) {
  4615.         if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
  4616.             continue;
  4617.         }

  4619.         module = ngx_modules[i]->ctx;

  4621.         if (module->create_loc_conf) {

  4623.             mconf = module->create_loc_conf(cf);
  4624.             if (mconf == NULL) {
  4625.                  return NGX_CONF_ERROR;
  4626.             }

  4628.             ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
  4629.         }
  4630.     }


  4633.     clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
  4634.     pclcf->limit_except_loc_conf = ctx->loc_conf;
  4635.     clcf->loc_conf = ctx->loc_conf;
  4636.     clcf->name = pclcf->name;
  4637.     clcf->noname = 1;
  4638.     clcf->lmt_excpt = 1;

  4640.     if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
  4641.         return NGX_CONF_ERROR;
  4642.     }

  4644.     save = *cf;
  4645.     cf->ctx = ctx;
  4646.     cf->cmd_type = NGX_HTTP_LMT_CONF;

  4648.     rv = ngx_conf_parse(cf, NULL);

  4650.     *cf = save;

  4652.     return rv;
  4653. }


  4656. static char *
  4657. ‌ngx_http_core_directio(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4658. {
  4659.     ngx_http_core_loc_conf_t *clcf = conf;

  4661.     ngx_str_t  *value;

  4663.     if (clcf->directio != NGX_CONF_UNSET) {
  4664.         return "is duplicate";
  4665.     }

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

  4669.     if (ngx_strcmp(value[1].data, "off") == 0) {
  4670.         clcf->directio = NGX_OPEN_FILE_DIRECTIO_OFF;
  4671.         return NGX_CONF_OK;
  4672.     }

  4674.     clcf->directio = ngx_parse_offset(&value[1]);
  4675.     if (clcf->directio == (off_t) NGX_ERROR) {
  4676.         return "invalid value";
  4677.     }

  4679.     return NGX_CONF_OK;
  4680. }


  4683. static char *
  4684. ‌ngx_http_core_error_page(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4685. {
  4686.     ngx_http_core_loc_conf_t *clcf = conf;

  4688.     u_char                            *p;
  4689.     ngx_int_t                          overwrite;
  4690.     ngx_str_t                         *value, uri, args;
  4691.     ngx_uint_t                         i, n;
  4692.     ngx_http_err_page_t               *err;
  4693.     ngx_http_complex_value_t           cv;
  4694.     ngx_http_compile_complex_value_t   ccv;

  4696.     if (clcf->error_pages == NULL) {
  4697.         clcf->error_pages = ngx_array_create(cf->pool, 4,
  4698.                                              sizeof(ngx_http_err_page_t));
  4699.         if (clcf->error_pages == NULL) {
  4700.             return NGX_CONF_ERROR;
  4701.         }
  4702.     }

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

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

  4708.     if (value[i].data[0] == '=') {
  4709.         if (i == 1) {
  4710.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4711.                                "invalid value \"%V\"", &value[i]);
  4712.             return NGX_CONF_ERROR;
  4713.         }

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

  4718.             if (overwrite == NGX_ERROR) {
  4719.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4720.                                    "invalid value \"%V\"", &value[i]);
  4721.                 return NGX_CONF_ERROR;
  4722.             }

  4724.         } else {
  4725.             overwrite = 0;
  4726.         }

  4728.         n = 2;

  4730.     } else {
  4731.         overwrite = -1;
  4732.         n = 1;
  4733.     }

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

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

  4739.     ccv.cf = cf;
  4740.     ccv.value = &uri;
  4741.     ccv.complex_value = &cv;

  4743.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  4744.         return NGX_CONF_ERROR;
  4745.     }

  4747.     ngx_str_null(&args);

  4749.     if (cv.lengths == NULL && uri.len && uri.data[0] == '/') {
  4750.         p = (u_char *) ngx_strchr(uri.data, '?');

  4752.         if (p) {
  4753.             cv.value.len = p - uri.data;
  4754.             cv.value.data = uri.data;
  4755.             p++;
  4756.             args.len = (uri.data + uri.len) - p;
  4757.             args.data = p;
  4758.         }
  4759.     }

  4761.     for (i = 1; i < cf->args->nelts - n; i++) {
  4762.         err = ngx_array_push(clcf->error_pages);
  4763.         if (err == NULL) {
  4764.             return NGX_CONF_ERROR;
  4765.         }

  4767.         err->status = ngx_atoi(value[i].data, value[i].len);

  4769.         if (err->status == NGX_ERROR || err->status == 499) {
  4770.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4771.                                "invalid value \"%V\"", &value[i]);
  4772.             return NGX_CONF_ERROR;
  4773.         }

  4775.         if (err->status < 300 || err->status > 599) {
  4776.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4777.                                "value \"%V\" must be between 300 and 599",
  4778.                                &value[i]);
  4779.             return NGX_CONF_ERROR;
  4780.         }

  4782.         err->overwrite = overwrite;

  4784.         if (overwrite == -1) {
  4785.             switch (err->status) {
  4786.                 case NGX_HTTP_TO_HTTPS:
  4787.                 case NGX_HTTPS_CERT_ERROR:
  4788.                 case NGX_HTTPS_NO_CERT:
  4789.                     err->overwrite = NGX_HTTP_BAD_REQUEST;
  4790.                 default:
  4791.                     break;
  4792.             }
  4793.         }

  4795.         err->value = cv;
  4796.         err->args = args;
  4797.     }

  4799.     return NGX_CONF_OK;
  4800. }


  4803. static char *
  4804. ‌ngx_http_core_try_files(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;
  4809.     ngx_int_t                   code;
  4810.     ngx_uint_t                  i, n;
  4811.     ngx_http_try_file_t        *tf;
  4812.     ngx_http_script_compile_t   sc;
  4813.     ngx_http_core_main_conf_t  *cmcf;

  4815.     if (clcf->try_files) {
  4816.         return "is duplicate";
  4817.     }

  4819.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  4821.     cmcf->try_files = 1;

  4823.     tf = ngx_pcalloc(cf->pool, cf->args->nelts * sizeof(ngx_http_try_file_t));
  4824.     if (tf == NULL) {
  4825.         return NGX_CONF_ERROR;
  4826.     }

  4828.     clcf->try_files = tf;

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

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

  4834.         tf[i].name = value[i + 1];

  4836.         if (tf[i].name.len > 0
  4837.             && tf[i].name.data[tf[i].name.len - 1] == '/'
  4838.             && i + 2 < cf->args->nelts)
  4839.         {
  4840.             tf[i].test_dir = 1;
  4841.             tf[i].name.len--;
  4842.             tf[i].name.data[tf[i].name.len] = '\0';
  4843.         }

  4845.         n = ngx_http_script_variables_count(&tf[i].name);

  4847.         if (n) {
  4848.             ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  4850.             sc.cf = cf;
  4851.             sc.source = &tf[i].name;
  4852.             sc.lengths = &tf[i].lengths;
  4853.             sc.values = &tf[i].values;
  4854.             sc.variables = n;
  4855.             sc.complete_lengths = 1;
  4856.             sc.complete_values = 1;

  4858.             if (ngx_http_script_compile(&sc) != NGX_OK) {
  4859.                 return NGX_CONF_ERROR;
  4860.             }

  4862.         } else {
  4863.             /* add trailing '\0' to length */
  4864.             tf[i].name.len++;
  4865.         }
  4866.     }

  4868.     if (tf[i - 1].name.data[0] == '=') {

  4870.         code = ngx_atoi(tf[i - 1].name.data + 1, tf[i - 1].name.len - 2);

  4872.         if (code == NGX_ERROR || code > 999) {
  4873.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4874.                                "invalid code \"%*s\"",
  4875.                                tf[i - 1].name.len - 1, tf[i - 1].name.data);
  4876.             return NGX_CONF_ERROR;
  4877.         }

  4879.         tf[i].code = code;
  4880.     }

  4882.     return NGX_CONF_OK;
  4883. }


  4886. static char *
  4887. ‌ngx_http_core_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4888. {
  4889.     ngx_http_core_loc_conf_t *clcf = conf;

  4891.     time_t       inactive;
  4892.     ngx_str_t   *value, s;
  4893.     ngx_int_t    max;
  4894.     ngx_uint_t   i;

  4896.     if (clcf->open_file_cache != NGX_CONF_UNSET_PTR) {
  4897.         return "is duplicate";
  4898.     }

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

  4902.     max = 0;
  4903.     inactive = 60;

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

  4907.         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {

  4909.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  4910.             if (max <= 0) {
  4911.                 goto failed;
  4912.             }

  4914.             continue;
  4915.         }

  4917.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  4919.             s.len = value[i].len - 9;
  4920.             s.data = value[i].data + 9;

  4922.             inactive = ngx_parse_time(&s, 1);
  4923.             if (inactive == (time_t) NGX_ERROR) {
  4924.                 goto failed;
  4925.             }

  4927.             continue;
  4928.         }

  4930.         if (ngx_strcmp(value[i].data, "off") == 0) {

  4932.             clcf->open_file_cache = NULL;

  4934.             continue;
  4935.         }

  4937.     failed:

  4939.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4940.                            "invalid \"open_file_cache\" parameter \"%V\"",
  4941.                            &value[i]);
  4942.         return NGX_CONF_ERROR;
  4943.     }

  4945.     if (clcf->open_file_cache == NULL) {
  4946.         return NGX_CONF_OK;
  4947.     }

  4949.     if (max == 0) {
  4950.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4951.                         "\"open_file_cache\" must have the \"max\" parameter");
  4952.         return NGX_CONF_ERROR;
  4953.     }

  4955.     clcf->open_file_cache = ngx_open_file_cache_init(cf->pool, max, inactive);
  4956.     if (clcf->open_file_cache) {
  4957.         return NGX_CONF_OK;
  4958.     }

  4960.     return NGX_CONF_ERROR;
  4961. }


  4964. static char *
  4965. ‌ngx_http_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4966. {
  4967.     ngx_http_core_loc_conf_t *clcf = conf;

  4969.     return ngx_log_set_log(cf, &clcf->error_log);
  4970. }


  4973. static char *
  4974. ‌ngx_http_core_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4975. {
  4976.     ngx_http_core_loc_conf_t *clcf = conf;

  4978.     ngx_str_t  *value;

  4980.     if (clcf->keepalive_timeout != NGX_CONF_UNSET_MSEC) {
  4981.         return "is duplicate";
  4982.     }

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

  4986.     clcf->keepalive_timeout = ngx_parse_time(&value[1], 0);

  4988.     if (clcf->keepalive_timeout == (ngx_msec_t) NGX_ERROR) {
  4989.         return "invalid value";
  4990.     }

  4992.     if (cf->args->nelts == 2) {
  4993.         return NGX_CONF_OK;
  4994.     }

  4996.     clcf->keepalive_header = ngx_parse_time(&value[2], 1);

  4998.     if (clcf->keepalive_header == (time_t) NGX_ERROR) {
  4999.         return "invalid value";
  5000.     }

  5002.     return NGX_CONF_OK;
  5003. }


  5006. static char *
  5007. ‌ngx_http_core_internal(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5008. {
  5009.     ngx_http_core_loc_conf_t *clcf = conf;

  5011.     if (clcf->internal != NGX_CONF_UNSET) {
  5012.         return "is duplicate";
  5013.     }

  5015.     clcf->internal = 1;

  5017.     return NGX_CONF_OK;
  5018. }


  5021. static char *
  5022. ‌ngx_http_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5023. {
  5024.     ngx_http_core_loc_conf_t  *clcf = conf;

  5026.     ngx_str_t  *value;

  5028.     if (clcf->resolver) {
  5029.         return "is duplicate";
  5030.     }

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

  5034.     clcf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  5035.     if (clcf->resolver == NULL) {
  5036.         return NGX_CONF_ERROR;
  5037.     }

  5039.     return NGX_CONF_OK;
  5040. }


  5043. #if (NGX_HTTP_GZIP)

  5045. static char *
  5046. ‌ngx_http_gzip_disable(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5047. {
  5048.     ngx_http_core_loc_conf_t  *clcf = conf;

  5050. #if (NGX_PCRE)

  5052.     ngx_str_t            *value;
  5053.     ngx_uint_t            i;
  5054.     ngx_regex_elt_t      *re;
  5055.     ngx_regex_compile_t   rc;
  5056.     u_char                errstr[NGX_MAX_CONF_ERRSTR];

  5058.     if (clcf->gzip_disable == NGX_CONF_UNSET_PTR) {
  5059.         clcf->gzip_disable = ngx_array_create(cf->pool, 2,
  5060.                                               sizeof(ngx_regex_elt_t));
  5061.         if (clcf->gzip_disable == NULL) {
  5062.             return NGX_CONF_ERROR;
  5063.         }
  5064.     }

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

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

  5070.     rc.pool = cf->pool;
  5071.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  5072.     rc.err.data = errstr;

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

  5076.         if (ngx_strcmp(value[i].data, "msie6") == 0) {
  5077.             clcf->gzip_disable_msie6 = 1;
  5078.             continue;
  5079.         }

  5081. #if (NGX_HTTP_DEGRADATION)

  5083.         if (ngx_strcmp(value[i].data, "degradation") == 0) {
  5084.             clcf->gzip_disable_degradation = 1;
  5085.             continue;
  5086.         }

  5088. #endif

  5090.         re = ngx_array_push(clcf->gzip_disable);
  5091.         if (re == NULL) {
  5092.             return NGX_CONF_ERROR;
  5093.         }

  5095.         rc.pattern = value[i];
  5096.         rc.options = NGX_REGEX_CASELESS;

  5098.         if (ngx_regex_compile(&rc) != NGX_OK) {
  5099.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc.err);
  5100.             return NGX_CONF_ERROR;
  5101.         }

  5103.         re->regex = rc.regex;
  5104.         re->name = value[i].data;
  5105.     }

  5107.     return NGX_CONF_OK;

  5109. #else
  5110.     ngx_str_t   *value;
  5111.     ngx_uint_t   i;

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

  5115.     for (i = 1; i < cf->args->nelts; i++) {
  5116.         if (ngx_strcmp(value[i].data, "msie6") == 0) {
  5117.             clcf->gzip_disable_msie6 = 1;
  5118.             continue;
  5119.         }

  5121. #if (NGX_HTTP_DEGRADATION)

  5123.         if (ngx_strcmp(value[i].data, "degradation") == 0) {
  5124.             clcf->gzip_disable_degradation = 1;
  5125.             continue;
  5126.         }

  5128. #endif

  5130.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5131.                            "without PCRE library \"gzip_disable\" supports "
  5132.                            "builtin \"msie6\" and \"degradation\" mask only");

  5134.         return NGX_CONF_ERROR;
  5135.     }

  5137.     return NGX_CONF_OK;

  5139. #endif
  5140. }

  5142. #endif


  5145. #if (NGX_HAVE_OPENAT)

  5147. static char *
  5148. ‌ngx_http_disable_symlinks(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5149. {
  5150.     ngx_http_core_loc_conf_t *clcf = conf;

  5152.     ngx_str_t                         *value;
  5153.     ngx_uint_t                         i;
  5154.     ngx_http_compile_complex_value_t   ccv;

  5156.     if (clcf->disable_symlinks != NGX_CONF_UNSET_UINT) {
  5157.         return "is duplicate";
  5158.     }

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

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

  5164.         if (ngx_strcmp(value[i].data, "off") == 0) {
  5165.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_OFF;
  5166.             continue;
  5167.         }

  5169.         if (ngx_strcmp(value[i].data, "if_not_owner") == 0) {
  5170.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_NOTOWNER;
  5171.             continue;
  5172.         }

  5174.         if (ngx_strcmp(value[i].data, "on") == 0) {
  5175.             clcf->disable_symlinks = NGX_DISABLE_SYMLINKS_ON;
  5176.             continue;
  5177.         }

  5179.         if (ngx_strncmp(value[i].data, "from=", 5) == 0) {
  5180.             value[i].len -= 5;
  5181.             value[i].data += 5;

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

  5185.             ccv.cf = cf;
  5186.             ccv.value = &value[i];
  5187.             ccv.complex_value = ngx_palloc(cf->pool,
  5188.                                            sizeof(ngx_http_complex_value_t));
  5189.             if (ccv.complex_value == NULL) {
  5190.                 return NGX_CONF_ERROR;
  5191.             }

  5193.             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  5194.                 return NGX_CONF_ERROR;
  5195.             }

  5197.             clcf->disable_symlinks_from = ccv.complex_value;

  5199.             continue;
  5200.         }

  5202.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5203.                            "invalid parameter \"%V\"", &value[i]);
  5204.         return NGX_CONF_ERROR;
  5205.     }

  5207.     if (clcf->disable_symlinks == NGX_CONF_UNSET_UINT) {
  5208.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5209.                            "\"%V\" must have \"off\", \"on\" "
  5210.                            "or \"if_not_owner\" parameter",
  5211.                            &cmd->name);
  5212.         return NGX_CONF_ERROR;
  5213.     }

  5215.     if (cf->args->nelts == 2) {
  5216.         clcf->disable_symlinks_from = NULL;
  5217.         return NGX_CONF_OK;
  5218.     }

  5220.     if (clcf->disable_symlinks_from == NGX_CONF_UNSET_PTR) {
  5221.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5222.                            "duplicate parameters \"%V %V\"",
  5223.                            &value[1], &value[2]);
  5224.         return NGX_CONF_ERROR;
  5225.     }

  5227.     if (clcf->disable_symlinks == NGX_DISABLE_SYMLINKS_OFF) {
  5228.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5229.                            "\"from=\" cannot be used with \"off\" parameter");
  5230.         return NGX_CONF_ERROR;
  5231.     }

  5233.     return NGX_CONF_OK;
  5234. }

  5236. #endif


  5239. static char *
  5240. ‌ngx_http_core_lowat_check(ngx_conf_t *cf, void *post, void *data)
  5241. {
  5242. #if (NGX_FREEBSD)
  5243.     ssize_t *np = data;

  5245.     if ((u_long) *np >= ngx_freebsd_net_inet_tcp_sendspace) {
  5246.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5247.                            "\"send_lowat\" must be less than %d "
  5248.                            "(sysctl net.inet.tcp.sendspace)",
  5249.                            ngx_freebsd_net_inet_tcp_sendspace);

  5251.         return NGX_CONF_ERROR;
  5252.     }

  5254. #elif !(NGX_HAVE_SO_SNDLOWAT)
  5255.     ssize_t *np = data;

  5257.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  5258.                        "\"send_lowat\" is not supported, ignored");

  5260.     *np = 0;

  5262. #endif

  5264.     return NGX_CONF_OK;
  5265. }


  5268. static char *
  5269. ‌ngx_http_core_pool_size(ngx_conf_t *cf, void *post, void *data)
  5270. {
  5271.     size_t *sp = data;

  5273.     if (*sp < NGX_MIN_POOL_SIZE) {
  5274.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5275.                            "the pool size must be no less than %uz",
  5276.                            NGX_MIN_POOL_SIZE);
  5277.         return NGX_CONF_ERROR;
  5278.     }

  5280.     if (*sp % NGX_POOL_ALIGNMENT) {
  5281.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5282.                            "the pool size must be a multiple of %uz",
  5283.                            NGX_POOL_ALIGNMENT);
  5284.         return NGX_CONF_ERROR;
  5285.     }

  5287.     return NGX_CONF_OK;
  5288. }

One Level Up Top Level