One Level Up Top Level

src/http/ngx_http_request.c - nginx-1.31.7 nginx/ @ 939334eff

Global variables defined

Data types defined

Functions defined

Source code


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


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


  13. static void ngx_http_wait_request_handler(ngx_event_t *ev);
  14. static ngx_http_request_t *ngx_http_alloc_request(ngx_connection_t *c);
  15. static void ngx_http_process_request_line(ngx_event_t *rev);
  16. static void ngx_http_process_request_headers(ngx_event_t *rev);
  17. static ssize_t ngx_http_read_request_header(ngx_http_request_t *r);
  18. static ngx_int_t ngx_http_alloc_large_header_buffer(ngx_http_request_t *r,
  19.     ngx_uint_t request_line);

  21. static ngx_int_t ngx_http_process_header_line(ngx_http_request_t *r,
  22.     ngx_table_elt_t *h, ngx_uint_t offset);
  23. static ngx_int_t ngx_http_process_unique_header_line(ngx_http_request_t *r,
  24.     ngx_table_elt_t *h, ngx_uint_t offset);
  25. static ngx_int_t ngx_http_process_host(ngx_http_request_t *r,
  26.     ngx_table_elt_t *h, ngx_uint_t offset);
  27. static ngx_int_t ngx_http_process_connection(ngx_http_request_t *r,
  28.     ngx_table_elt_t *h, ngx_uint_t offset);
  29. static ngx_int_t ngx_http_process_proxy_connection(ngx_http_request_t *r,
  30.     ngx_table_elt_t *h, ngx_uint_t offset);
  31. static ngx_int_t ngx_http_process_user_agent(ngx_http_request_t *r,
  32.     ngx_table_elt_t *h, ngx_uint_t offset);

  34. static ngx_int_t ngx_http_process_request_header(ngx_http_request_t *r);
  35. static ngx_int_t ngx_http_read_early_body(ngx_http_request_t *r);
  36. static ngx_int_t ngx_http_find_virtual_server(ngx_connection_t *c,
  37.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  38.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp);

  40. static void ngx_http_request_handler(ngx_event_t *ev);
  41. static void ngx_http_terminate_request(ngx_http_request_t *r, ngx_int_t rc);
  42. static void ngx_http_terminate_handler(ngx_http_request_t *r);
  43. static void ngx_http_finalize_connection(ngx_http_request_t *r);
  44. static ngx_int_t ngx_http_set_write_handler(ngx_http_request_t *r);
  45. static void ngx_http_writer(ngx_http_request_t *r);
  46. static void ngx_http_request_finalizer(ngx_http_request_t *r);

  48. static void ngx_http_set_keepalive(ngx_http_request_t *r);
  49. static void ngx_http_keepalive_handler(ngx_event_t *ev);
  50. static void ngx_http_set_lingering_close(ngx_connection_t *c);
  51. static void ngx_http_lingering_close_handler(ngx_event_t *ev);
  52. static ngx_int_t ngx_http_post_action(ngx_http_request_t *r);
  53. static void ngx_http_log_request(ngx_http_request_t *r);

  55. static u_char *ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len);
  56. static u_char *ngx_http_log_error_handler(ngx_http_request_t *r,
  57.     ngx_http_request_t *sr, u_char *buf, size_t len);

  59. #if (NGX_HTTP_SSL)
  60. static void ngx_http_ssl_handshake(ngx_event_t *rev);
  61. static void ngx_http_ssl_handshake_handler(ngx_connection_t *c);
  62. #endif


  65. ‌static char *ngx_http_client_errors[] = {

  67.     /* NGX_HTTP_PARSE_INVALID_METHOD */
  68.     "client sent invalid method",

  70.     /* NGX_HTTP_PARSE_INVALID_REQUEST */
  71.     "client sent invalid request",

  73.     /* NGX_HTTP_PARSE_INVALID_VERSION */
  74.     "client sent invalid version",

  76.     /* NGX_HTTP_PARSE_INVALID_09_METHOD */
  77.     "client sent invalid method in HTTP/0.9 request"
  78. };


  81. ‌ngx_http_header_t  ngx_http_headers_in[] = {
  82.     { ngx_string("Host"), offsetof(ngx_http_headers_in_t, host),
  83.                  ngx_http_process_host },

  85.     { ngx_string("Connection"), offsetof(ngx_http_headers_in_t, connection),
  86.                  ngx_http_process_connection },

  88.     { ngx_string("Proxy-Connection"), 0,
  89.                  ngx_http_process_proxy_connection },

  91.     { ngx_string("If-Modified-Since"),
  92.                  offsetof(ngx_http_headers_in_t, if_modified_since),
  93.                  ngx_http_process_unique_header_line },

  95.     { ngx_string("If-Unmodified-Since"),
  96.                  offsetof(ngx_http_headers_in_t, if_unmodified_since),
  97.                  ngx_http_process_unique_header_line },

  99.     { ngx_string("If-Match"),
  100.                  offsetof(ngx_http_headers_in_t, if_match),
  101.                  ngx_http_process_unique_header_line },

  103.     { ngx_string("If-None-Match"),
  104.                  offsetof(ngx_http_headers_in_t, if_none_match),
  105.                  ngx_http_process_unique_header_line },

  107.     { ngx_string("User-Agent"), offsetof(ngx_http_headers_in_t, user_agent),
  108.                  ngx_http_process_user_agent },

  110.     { ngx_string("Referer"), offsetof(ngx_http_headers_in_t, referer),
  111.                  ngx_http_process_header_line },

  113.     { ngx_string("Content-Length"),
  114.                  offsetof(ngx_http_headers_in_t, content_length),
  115.                  ngx_http_process_unique_header_line },

  117.     { ngx_string("Content-Range"),
  118.                  offsetof(ngx_http_headers_in_t, content_range),
  119.                  ngx_http_process_unique_header_line },

  121.     { ngx_string("Content-Type"),
  122.                  offsetof(ngx_http_headers_in_t, content_type),
  123.                  ngx_http_process_header_line },

  125.     { ngx_string("Range"), offsetof(ngx_http_headers_in_t, range),
  126.                  ngx_http_process_header_line },

  128.     { ngx_string("If-Range"),
  129.                  offsetof(ngx_http_headers_in_t, if_range),
  130.                  ngx_http_process_unique_header_line },

  132.     { ngx_string("Transfer-Encoding"),
  133.                  offsetof(ngx_http_headers_in_t, transfer_encoding),
  134.                  ngx_http_process_unique_header_line },

  136.     { ngx_string("TE"),
  137.                  offsetof(ngx_http_headers_in_t, te),
  138.                  ngx_http_process_header_line },

  140.     { ngx_string("Expect"),
  141.                  offsetof(ngx_http_headers_in_t, expect),
  142.                  ngx_http_process_unique_header_line },

  144.     { ngx_string("Upgrade"),
  145.                  offsetof(ngx_http_headers_in_t, upgrade),
  146.                  ngx_http_process_header_line },

  148. #if (NGX_HTTP_GZIP || NGX_HTTP_HEADERS)
  149.     { ngx_string("Accept-Encoding"),
  150.                  offsetof(ngx_http_headers_in_t, accept_encoding),
  151.                  ngx_http_process_header_line },

  153.     { ngx_string("Via"), offsetof(ngx_http_headers_in_t, via),
  154.                  ngx_http_process_header_line },
  155. #endif

  157.     { ngx_string("Authorization"),
  158.                  offsetof(ngx_http_headers_in_t, authorization),
  159.                  ngx_http_process_unique_header_line },

  161.     { ngx_string("Proxy-Authorization"),
  162.                  offsetof(ngx_http_headers_in_t, proxy_authorization),
  163.                  ngx_http_process_unique_header_line },

  165.     { ngx_string("Keep-Alive"), offsetof(ngx_http_headers_in_t, keep_alive),
  166.                  ngx_http_process_header_line },

  168. #if (NGX_HTTP_X_FORWARDED_FOR)
  169.     { ngx_string("X-Forwarded-For"),
  170.                  offsetof(ngx_http_headers_in_t, x_forwarded_for),
  171.                  ngx_http_process_header_line },
  172. #endif

  174. #if (NGX_HTTP_REALIP)
  175.     { ngx_string("X-Real-IP"),
  176.                  offsetof(ngx_http_headers_in_t, x_real_ip),
  177.                  ngx_http_process_header_line },
  178. #endif

  180. #if (NGX_HTTP_HEADERS)
  181.     { ngx_string("Accept"), offsetof(ngx_http_headers_in_t, accept),
  182.                  ngx_http_process_header_line },

  184.     { ngx_string("Accept-Language"),
  185.                  offsetof(ngx_http_headers_in_t, accept_language),
  186.                  ngx_http_process_header_line },
  187. #endif

  189. #if (NGX_HTTP_DAV)
  190.     { ngx_string("Depth"), offsetof(ngx_http_headers_in_t, depth),
  191.                  ngx_http_process_header_line },

  193.     { ngx_string("Destination"), offsetof(ngx_http_headers_in_t, destination),
  194.                  ngx_http_process_header_line },

  196.     { ngx_string("Overwrite"), offsetof(ngx_http_headers_in_t, overwrite),
  197.                  ngx_http_process_header_line },

  199.     { ngx_string("Date"), offsetof(ngx_http_headers_in_t, date),
  200.                  ngx_http_process_header_line },
  201. #endif

  203.     { ngx_string("Cookie"), offsetof(ngx_http_headers_in_t, cookie),
  204.                  ngx_http_process_header_line },

  206.     { ngx_null_string, 0, NULL }
  207. };


  210. void
  211. ‌ngx_http_init_connection(ngx_connection_t *c)
  212. {
  213.     ngx_uint_t                 i;
  214.     ngx_event_t               *rev;
  215.     struct sockaddr_in        *sin;
  216.     ngx_http_port_t           *port;
  217.     ngx_http_in_addr_t        *addr;
  218.     ngx_http_log_ctx_t        *ctx;
  219.     ngx_http_connection_t     *hc;
  220.     ngx_http_core_srv_conf_t  *cscf;
  221. #if (NGX_HAVE_INET6)
  222.     struct sockaddr_in6       *sin6;
  223.     ngx_http_in6_addr_t       *addr6;
  224. #endif

  226.     hc = ngx_pcalloc(c->pool, sizeof(ngx_http_connection_t));
  227.     if (hc == NULL) {
  228.         ngx_http_close_connection(c);
  229.         return;
  230.     }

  232.     c->data = hc;

  234.     /* find the server configuration for the address:port */

  236.     port = c->listening->servers;

  238.     if (port->naddrs > 1) {

  240.         /*
  241.          * there are several addresses on this port and one of them
  242.          * is an "*:port" wildcard so getsockname() in ngx_http_server_addr()
  243.          * is required to determine a server address
  244.          */

  246.         if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
  247.             ngx_http_close_connection(c);
  248.             return;
  249.         }

  251.         switch (c->local_sockaddr->sa_family) {

  253. #if (NGX_HAVE_INET6)
  254.         case AF_INET6:
  255.             sin6 = (struct sockaddr_in6 *) c->local_sockaddr;

  257.             addr6 = port->addrs;

  259.             /* the last address is "*" */

  261.             for (i = 0; i < port->naddrs - 1; i++) {
  262.                 if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16) == 0) {
  263.                     break;
  264.                 }
  265.             }

  267.             hc->addr_conf = &addr6[i].conf;

  269.             break;
  270. #endif

  272.         default: /* AF_INET */
  273.             sin = (struct sockaddr_in *) c->local_sockaddr;

  275.             addr = port->addrs;

  277.             /* the last address is "*" */

  279.             for (i = 0; i < port->naddrs - 1; i++) {
  280.                 if (addr[i].addr == sin->sin_addr.s_addr) {
  281.                     break;
  282.                 }
  283.             }

  285.             hc->addr_conf = &addr[i].conf;

  287.             break;
  288.         }

  290.     } else {

  292.         switch (c->local_sockaddr->sa_family) {

  294. #if (NGX_HAVE_INET6)
  295.         case AF_INET6:
  296.             addr6 = port->addrs;
  297.             hc->addr_conf = &addr6[0].conf;
  298.             break;
  299. #endif

  301.         default: /* AF_INET */
  302.             addr = port->addrs;
  303.             hc->addr_conf = &addr[0].conf;
  304.             break;
  305.         }
  306.     }

  308.     /* the default server configuration for the address:port */
  309.     hc->conf_ctx = hc->addr_conf->default_server->ctx;

  311.     ctx = ngx_palloc(c->pool, sizeof(ngx_http_log_ctx_t));
  312.     if (ctx == NULL) {
  313.         ngx_http_close_connection(c);
  314.         return;
  315.     }

  317.     ctx->connection = c;
  318.     ctx->request = NULL;
  319.     ctx->current_request = NULL;

  321.     c->log->connection = c->number;
  322.     c->log->handler = ngx_http_log_error;
  323.     c->log->data = ctx;
  324.     c->log->action = "waiting for request";

  326.     c->log_error = NGX_ERROR_INFO;

  328.     rev = c->read;
  329.     rev->handler = ngx_http_wait_request_handler;
  330.     c->write->handler = ngx_http_empty_handler;

  332. #if (NGX_HTTP_V3)
  333.     if (hc->addr_conf->quic) {
  334.         ngx_http_v3_init_stream(c);
  335.         return;
  336.     }
  337. #endif

  339. #if (NGX_HTTP_SSL)
  340.     if (hc->addr_conf->ssl) {
  341.         hc->ssl = 1;
  342.         c->log->action = "SSL handshaking";
  343.         rev->handler = ngx_http_ssl_handshake;
  344.     }
  345. #endif

  347.     if (hc->addr_conf->proxy_protocol) {
  348.         hc->proxy_protocol = 1;
  349.         c->log->action = "reading PROXY protocol";
  350.     }

  352.     if (rev->ready) {
  353.         /* the deferred accept(), iocp */

  355.         if (ngx_use_accept_mutex) {
  356.             ngx_post_event(rev, &ngx_posted_events);
  357.             return;
  358.         }

  360.         rev->handler(rev);
  361.         return;
  362.     }

  364.     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_core_module);

  366.     ngx_add_timer(rev, cscf->client_header_timeout);
  367.     ngx_reusable_connection(c, 1);

  369.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  370.         ngx_http_close_connection(c);
  371.         return;
  372.     }
  373. }


  376. static void
  377. ‌ngx_http_wait_request_handler(ngx_event_t *rev)
  378. {
  379.     u_char                    *p;
  380.     size_t                     size;
  381.     ssize_t                    n;
  382.     ngx_buf_t                 *b;
  383.     ngx_connection_t          *c;
  384.     ngx_http_connection_t     *hc;
  385. #if (NGX_HTTP_V2)
  386.     ngx_http_v2_srv_conf_t    *h2scf;
  387. #endif
  388.     ngx_http_core_srv_conf_t  *cscf;

  390.     c = rev->data;

  392.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http wait request handler");

  394.     if (rev->timedout) {
  395.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  396.         ngx_http_close_connection(c);
  397.         return;
  398.     }

  400.     if (c->close) {
  401.         ngx_http_close_connection(c);
  402.         return;
  403.     }

  405.     hc = c->data;
  406.     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_core_module);

  408.     size = cscf->client_header_buffer_size;

  410.     b = c->buffer;

  412.     if (b == NULL) {
  413.         b = ngx_create_temp_buf(c->pool, size);
  414.         if (b == NULL) {
  415.             ngx_http_close_connection(c);
  416.             return;
  417.         }

  419.         c->buffer = b;

  421.     } else if (b->start == NULL) {

  423.         b->start = ngx_palloc(c->pool, size);
  424.         if (b->start == NULL) {
  425.             ngx_http_close_connection(c);
  426.             return;
  427.         }

  429.         b->pos = b->start;
  430.         b->last = b->start;
  431.         b->end = b->last + size;
  432.     }

  434.     size = b->end - b->last;

  436.     n = c->recv(c, b->last, size);

  438.     if (n == NGX_AGAIN) {

  440.         if (!rev->timer_set) {
  441.             ngx_add_timer(rev, cscf->client_header_timeout);
  442.             ngx_reusable_connection(c, 1);
  443.         }

  445.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  446.             ngx_http_close_connection(c);
  447.             return;
  448.         }

  450.         if (b->pos == b->last) {

  452.             /*
  453.              * We are trying to not hold c->buffer's memory for an
  454.              * idle connection.
  455.              */

  457.             if (ngx_pfree(c->pool, b->start) == NGX_OK) {
  458.                 b->start = NULL;
  459.             }
  460.         }

  462.         return;
  463.     }

  465.     if (n == NGX_ERROR) {
  466.         ngx_http_close_connection(c);
  467.         return;
  468.     }

  470.     if (n == 0) {
  471.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  472.                       "client closed connection");
  473.         ngx_http_close_connection(c);
  474.         return;
  475.     }

  477.     b->last += n;

  479.     if (hc->proxy_protocol) {
  480.         hc->proxy_protocol = 0;

  482.         p = ngx_proxy_protocol_read(c, b->pos, b->last);

  484.         if (p == NULL) {
  485.             ngx_http_close_connection(c);
  486.             return;
  487.         }

  489.         b->pos = p;

  491.         if (b->pos == b->last) {
  492.             c->log->action = "waiting for request";
  493.             b->pos = b->start;
  494.             b->last = b->start;
  495.             ngx_post_event(rev, &ngx_posted_events);
  496.             return;
  497.         }
  498.     }

  500. #if (NGX_HTTP_V2)

  502.     h2scf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_v2_module);

  504.     if (!hc->ssl && (h2scf->enable || hc->addr_conf->http2)) {

  506.         size = ngx_min(sizeof(NGX_HTTP_V2_PREFACE) - 1,
  507.                        (size_t) (b->last - b->pos));

  509.         if (ngx_memcmp(b->pos, NGX_HTTP_V2_PREFACE, size) == 0) {

  511.             if (size == sizeof(NGX_HTTP_V2_PREFACE) - 1) {
  512.                 ngx_http_v2_init(rev);
  513.                 return;
  514.             }

  516.             ngx_post_event(rev, &ngx_posted_events);
  517.             return;
  518.         }
  519.     }

  521. #endif

  523.     c->log->action = "reading client request line";

  525.     ngx_reusable_connection(c, 0);

  527.     c->data = ngx_http_create_request(c);
  528.     if (c->data == NULL) {
  529.         ngx_http_close_connection(c);
  530.         return;
  531.     }

  533.     rev->handler = ngx_http_process_request_line;
  534.     ngx_http_process_request_line(rev);
  535. }


  538. ngx_http_request_t *
  539. ‌ngx_http_create_request(ngx_connection_t *c)
  540. {
  541.     ngx_http_request_t        *r;
  542.     ngx_http_log_ctx_t        *ctx;
  543.     ngx_http_core_loc_conf_t  *clcf;

  545.     r = ngx_http_alloc_request(c);
  546.     if (r == NULL) {
  547.         return NULL;
  548.     }

  550.     c->requests++;

  552.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  554.     ngx_set_connection_log(c, clcf->error_log);

  556.     ctx = c->log->data;
  557.     ctx->request = r;
  558.     ctx->current_request = r;

  560. #if (NGX_STAT_STUB)
  561.     (void) ngx_atomic_fetch_add(ngx_stat_reading, 1);
  562.     r->stat_reading = 1;
  563.     (void) ngx_atomic_fetch_add(ngx_stat_requests, 1);
  564. #endif

  566.     return r;
  567. }


  570. static ngx_http_request_t *
  571. ‌ngx_http_alloc_request(ngx_connection_t *c)
  572. {
  573.     ngx_pool_t                 *pool;
  574.     ngx_time_t                 *tp;
  575.     ngx_http_request_t         *r;
  576.     ngx_http_connection_t      *hc;
  577.     ngx_http_core_srv_conf_t   *cscf;
  578.     ngx_http_core_main_conf_t  *cmcf;

  580.     hc = c->data;

  582.     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_core_module);

  584.     pool = ngx_create_pool(cscf->request_pool_size, c->log);
  585.     if (pool == NULL) {
  586.         return NULL;
  587.     }

  589.     r = ngx_pcalloc(pool, sizeof(ngx_http_request_t));
  590.     if (r == NULL) {
  591.         ngx_destroy_pool(pool);
  592.         return NULL;
  593.     }

  595.     r->pool = pool;

  597.     r->http_connection = hc;
  598.     r->signature = NGX_HTTP_MODULE;
  599.     r->connection = c;

  601.     r->main_conf = hc->conf_ctx->main_conf;
  602.     r->srv_conf = hc->conf_ctx->srv_conf;
  603.     r->loc_conf = hc->conf_ctx->loc_conf;

  605.     r->read_event_handler = ngx_http_block_reading;

  607.     r->header_in = hc->busy ? hc->busy->buf : c->buffer;

  609.     if (ngx_list_init(&r->headers_out.headers, r->pool, 20,
  610.                       sizeof(ngx_table_elt_t))
  611.         != NGX_OK)
  612.     {
  613.         ngx_destroy_pool(r->pool);
  614.         return NULL;
  615.     }

  617.     if (ngx_list_init(&r->headers_out.trailers, r->pool, 4,
  618.                       sizeof(ngx_table_elt_t))
  619.         != NGX_OK)
  620.     {
  621.         ngx_destroy_pool(r->pool);
  622.         return NULL;
  623.     }

  625.     r->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);
  626.     if (r->ctx == NULL) {
  627.         ngx_destroy_pool(r->pool);
  628.         return NULL;
  629.     }

  631.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  633.     r->variables = ngx_pcalloc(r->pool, cmcf->variables.nelts
  634.                                         * sizeof(ngx_http_variable_value_t));
  635.     if (r->variables == NULL) {
  636.         ngx_destroy_pool(r->pool);
  637.         return NULL;
  638.     }

  640. #if (NGX_HTTP_SSL)
  641.     if (c->ssl && !c->ssl->sendfile) {
  642.         r->main_filter_need_in_memory = 1;
  643.     }
  644. #endif

  646.     r->main = r;
  647.     r->count = 1;

  649.     tp = ngx_timeofday();
  650.     r->start_sec = tp->sec;
  651.     r->start_msec = tp->msec;

  653.     r->method = NGX_HTTP_UNKNOWN;
  654.     r->http_version = NGX_HTTP_VERSION_10;

  656.     r->headers_in.content_length_n = -1;
  657.     r->headers_in.keep_alive_n = -1;
  658.     r->headers_out.content_length_n = -1;
  659.     r->headers_out.last_modified_time = -1;

  661.     r->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;
  662.     r->subrequests = NGX_HTTP_MAX_SUBREQUESTS + 1;

  664.     r->http_state = NGX_HTTP_READING_REQUEST_STATE;

  666.     r->log_handler = ngx_http_log_error_handler;

  668.     return r;
  669. }


  672. #if (NGX_HTTP_SSL)

  674. static void
  675. ‌ngx_http_ssl_handshake(ngx_event_t *rev)
  676. {
  677.     u_char                    *p, buf[NGX_PROXY_PROTOCOL_MAX_HEADER + 1];
  678.     size_t                     size;
  679.     ssize_t                    n;
  680.     ngx_err_t                  err;
  681.     ngx_int_t                  rc;
  682.     ngx_connection_t          *c;
  683.     ngx_http_connection_t     *hc;
  684.     ngx_http_ssl_srv_conf_t   *sscf;
  685.     ngx_http_core_loc_conf_t  *clcf;
  686.     ngx_http_core_srv_conf_t  *cscf;

  688.     c = rev->data;
  689.     hc = c->data;

  691.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0,
  692.                    "http check ssl handshake");

  694.     if (rev->timedout) {
  695.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  696.         ngx_http_close_connection(c);
  697.         return;
  698.     }

  700.     if (c->close) {
  701.         ngx_http_close_connection(c);
  702.         return;
  703.     }

  705.     size = hc->proxy_protocol ? sizeof(buf) : 1;

  707.     n = recv(c->fd, (char *) buf, size, MSG_PEEK);

  709.     err = ngx_socket_errno;

  711.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, rev->log, 0, "http recv(): %z", n);

  713.     if (n == -1) {
  714.         if (err == NGX_EAGAIN) {
  715.             rev->ready = 0;

  717.             if (!rev->timer_set) {
  718.                 cscf = ngx_http_get_module_srv_conf(hc->conf_ctx,
  719.                                                     ngx_http_core_module);
  720.                 ngx_add_timer(rev, cscf->client_header_timeout);
  721.                 ngx_reusable_connection(c, 1);
  722.             }

  724.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  725.                 ngx_http_close_connection(c);
  726.             }

  728.             return;
  729.         }

  731.         ngx_connection_error(c, err, "recv() failed");
  732.         ngx_http_close_connection(c);

  734.         return;
  735.     }

  737.     if (hc->proxy_protocol) {
  738.         hc->proxy_protocol = 0;

  740.         p = ngx_proxy_protocol_read(c, buf, buf + n);

  742.         if (p == NULL) {
  743.             ngx_http_close_connection(c);
  744.             return;
  745.         }

  747.         size = p - buf;

  749.         if (c->recv(c, buf, size) != (ssize_t) size) {
  750.             ngx_http_close_connection(c);
  751.             return;
  752.         }

  754.         c->log->action = "SSL handshaking";

  756.         if (n == (ssize_t) size) {
  757.             ngx_post_event(rev, &ngx_posted_events);
  758.             return;
  759.         }

  761.         n = 1;
  762.         buf[0] = *p;
  763.     }

  765.     if (n == 1) {
  766.         if (buf[0] & 0x80 /* SSLv2 */ || buf[0] == 0x16 /* SSLv3/TLSv1 */) {
  767.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, rev->log, 0,
  768.                            "https ssl handshake: 0x%02Xd", buf[0]);

  770.             clcf = ngx_http_get_module_loc_conf(hc->conf_ctx,
  771.                                                 ngx_http_core_module);

  773.             if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  774.                 ngx_http_close_connection(c);
  775.                 return;
  776.             }

  778.             sscf = ngx_http_get_module_srv_conf(hc->conf_ctx,
  779.                                                 ngx_http_ssl_module);

  781.             if (ngx_ssl_create_connection(&sscf->ssl, c, NGX_SSL_BUFFER)
  782.                 != NGX_OK)
  783.             {
  784.                 ngx_http_close_connection(c);
  785.                 return;
  786.             }

  788.             ngx_reusable_connection(c, 0);

  790.             rc = ngx_ssl_handshake(c);

  792.             if (rc == NGX_AGAIN) {

  794.                 if (!rev->timer_set) {
  795.                     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx,
  796.                                                         ngx_http_core_module);
  797.                     ngx_add_timer(rev, cscf->client_header_timeout);
  798.                 }

  800.                 c->ssl->handler = ngx_http_ssl_handshake_handler;
  801.                 return;
  802.             }

  804.             ngx_http_ssl_handshake_handler(c);

  806.             return;
  807.         }

  809.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0, "plain http");

  811.         c->log->action = "waiting for request";

  813.         rev->handler = ngx_http_wait_request_handler;
  814.         ngx_http_wait_request_handler(rev);

  816.         return;
  817.     }

  819.     ngx_log_error(NGX_LOG_INFO, c->log, 0, "client closed connection");
  820.     ngx_http_close_connection(c);
  821. }


  824. static void
  825. ‌ngx_http_ssl_handshake_handler(ngx_connection_t *c)
  826. {
  827.     if (c->ssl->handshaked) {

  829.         /*
  830.          * The majority of browsers do not send the "close notify" alert.
  831.          * Among them are MSIE, old Mozilla, Netscape 4, Konqueror,
  832.          * and Links.  And what is more, MSIE ignores the server's alert.
  833.          *
  834.          * Opera and recent Mozilla send the alert.
  835.          */

  837.         c->ssl->no_wait_shutdown = 1;

  839. #if (NGX_HTTP_V2                                                              \
  840.      && defined TLSEXT_TYPE_application_layer_protocol_negotiation)
  841.         {
  842.         unsigned int             len;
  843.         const unsigned char     *data;
  844.         ngx_http_connection_t   *hc;
  845.         ngx_http_v2_srv_conf_t  *h2scf;

  847.         hc = c->data;

  849.         h2scf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_v2_module);

  851.         if (h2scf->enable || hc->addr_conf->http2) {

  853.             SSL_get0_alpn_selected(c->ssl->connection, &data, &len);

  855.             if (len == 2 && data[0] == 'h' && data[1] == '2') {
  856.                 ngx_http_v2_init(c->read);
  857.                 return;
  858.             }
  859.         }
  860.         }
  861. #endif

  863.         c->log->action = "waiting for request";

  865.         c->read->handler = ngx_http_wait_request_handler;
  866.         /* STUB: epoll edge */ c->write->handler = ngx_http_empty_handler;

  868.         ngx_reusable_connection(c, 1);

  870.         ngx_http_wait_request_handler(c->read);

  872.         return;
  873.     }

  875.     if (c->read->timedout) {
  876.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  877.     }

  879.     ngx_http_close_connection(c);
  880. }


  883. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  885. int
  886. ‌ngx_http_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg)
  887. {
  888.     ngx_int_t                  rc;
  889.     ngx_str_t                  host;
  890.     const char                *servername;
  891.     ngx_connection_t          *c;
  892.     ngx_http_connection_t     *hc;
  893.     ngx_http_ssl_srv_conf_t   *sscf;
  894.     ngx_http_core_loc_conf_t  *clcf;
  895.     ngx_http_core_srv_conf_t  *cscf;

  897.     c = ngx_ssl_get_connection(ssl_conn);

  899.     if (c->ssl->handshaked) {
  900.         *ad = SSL_AD_NO_RENEGOTIATION;
  901.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  902.     }

  904.     if (c->ssl->sni_accepted) {
  905.         return SSL_TLSEXT_ERR_OK;
  906.     }

  908.     if (c->ssl->handshake_rejected) {
  909.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  910.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  911.     }

  913.     hc = c->data;

  915.     if (arg != NULL) {
  916.         host = *(ngx_str_t *) arg;

  918.         if (host.data == NULL) {
  919.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  920.                            "SSL server name: null");
  921.             goto done;
  922.         }

  924.     } else {
  925.         servername = SSL_get_servername(ssl_conn, TLSEXT_NAMETYPE_host_name);

  927.         if (servername == NULL) {
  928.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  929.                            "SSL server name: null");
  930.             goto done;
  931.         }

  933.         host.len = ngx_strlen(servername);
  934.         host.data = (u_char *) servername;
  935.     }

  937.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  938.                    "SSL server name: \"%V\"", &host);

  940.     if (host.len == 0) {
  941.         goto done;
  942.     }

  944.     rc = ngx_http_validate_host(&host, NULL, c->pool, 1);

  946.     if (rc == NGX_ERROR) {
  947.         goto error;
  948.     }

  950.     if (rc == NGX_DECLINED) {
  951.         goto done;
  952.     }

  954.     rc = ngx_http_find_virtual_server(c, hc->addr_conf->virtual_names, &host,
  955.                                       NULL, &cscf);

  957.     if (rc == NGX_ERROR) {
  958.         goto error;
  959.     }

  961.     if (rc == NGX_DECLINED) {
  962.         goto done;
  963.     }

  965.     hc->ssl_servername = ngx_palloc(c->pool, sizeof(ngx_str_t));
  966.     if (hc->ssl_servername == NULL) {
  967.         goto error;
  968.     }

  970.     *hc->ssl_servername = host;

  972.     hc->conf_ctx = cscf->ctx;

  974.     clcf = ngx_http_get_module_loc_conf(hc->conf_ctx, ngx_http_core_module);

  976.     ngx_set_connection_log(c, clcf->error_log);

  978.     sscf = ngx_http_get_module_srv_conf(cscf->ctx, ngx_http_ssl_module);

  980.     c->ssl->buffer_size = sscf->buffer_size;

  982.     if (sscf->ssl.ctx) {
  983.         if (SSL_set_SSL_CTX(ssl_conn, sscf->ssl.ctx) == NULL) {
  984.             goto error;
  985.         }

  987.         /*
  988.          * SSL_set_SSL_CTX() only changes certs as of 1.0.0d
  989.          * adjust other things we care about
  990.          */

  992.         SSL_set_verify(ssl_conn, SSL_CTX_get_verify_mode(sscf->ssl.ctx),
  993.                        SSL_CTX_get_verify_callback(sscf->ssl.ctx));

  995.         SSL_set_verify_depth(ssl_conn, SSL_CTX_get_verify_depth(sscf->ssl.ctx));

  997. #if OPENSSL_VERSION_NUMBER >= 0x009080dfL
  998.         /* only in 0.9.8m+ */
  999.         SSL_clear_options(ssl_conn, SSL_get_options(ssl_conn) &
  1000.                                     ~SSL_CTX_get_options(sscf->ssl.ctx));
  1001. #endif

  1003.         SSL_set_options(ssl_conn, SSL_CTX_get_options(sscf->ssl.ctx));

  1005. #ifdef SSL_OP_NO_RENEGOTIATION
  1006.         SSL_set_options(ssl_conn, SSL_OP_NO_RENEGOTIATION);
  1007. #endif

  1009. #ifdef SSL_OP_ENABLE_MIDDLEBOX_COMPAT
  1010. #if (NGX_HTTP_V3)
  1011.         if (c->listening->quic) {
  1012.             SSL_clear_options(ssl_conn, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
  1013.         }
  1014. #endif
  1015. #endif
  1016.     }

  1018. done:

  1020.     sscf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_ssl_module);

  1022.     if (sscf->reject_handshake) {
  1023.         c->ssl->handshake_rejected = 1;
  1024.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  1025.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  1026.     }

  1028.     c->ssl->sni_accepted = 1;
  1029.     return SSL_TLSEXT_ERR_OK;

  1031. error:

  1033.     *ad = SSL_AD_INTERNAL_ERROR;
  1034.     return SSL_TLSEXT_ERR_ALERT_FATAL;
  1035. }

  1037. #endif


  1040. #ifdef SSL_R_CERT_CB_ERROR

  1042. int
  1043. ‌ngx_http_ssl_certificate(ngx_ssl_conn_t *ssl_conn, void *arg)
  1044. {
  1045.     ngx_str_t                  cert, key;
  1046.     ngx_uint_t                 i, nelts;
  1047.     ngx_connection_t          *c;
  1048.     ngx_http_request_t        *r;
  1049.     ngx_http_ssl_srv_conf_t   *sscf;
  1050.     ngx_http_complex_value_t  *certs, *keys;

  1052.     c = ngx_ssl_get_connection(ssl_conn);

  1054.     if (c->ssl->handshaked) {
  1055.         return 0;
  1056.     }

  1058.     r = ngx_http_alloc_request(c);
  1059.     if (r == NULL) {
  1060.         return 0;
  1061.     }

  1063.     r->logged = 1;

  1065.     sscf = arg;

  1067.     nelts = sscf->certificate_values->nelts;
  1068.     certs = sscf->certificate_values->elts;
  1069.     keys = sscf->certificate_key_values->elts;

  1071.     for (i = 0; i < nelts; i++) {

  1073.         if (ngx_http_complex_value(r, &certs[i], &cert) != NGX_OK) {
  1074.             goto failed;
  1075.         }

  1077.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1078.                        "ssl cert: \"%s\"", cert.data);

  1080.         if (ngx_http_complex_value(r, &keys[i], &key) != NGX_OK) {
  1081.             goto failed;
  1082.         }

  1084.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1085.                        "ssl key: \"%s\"", key.data);

  1087.         if (ngx_ssl_connection_certificate(c, r->pool, &cert, &key,
  1088.                                            sscf->certificate_cache,
  1089.                                            sscf->passwords)
  1090.             != NGX_OK)
  1091.         {
  1092.             goto failed;
  1093.         }
  1094.     }

  1096.     ngx_http_free_request(r, 0);
  1097.     c->log->action = "SSL handshaking";
  1098.     c->destroyed = 0;
  1099.     return 1;

  1101. failed:

  1103.     ngx_http_free_request(r, 0);
  1104.     c->log->action = "SSL handshaking";
  1105.     c->destroyed = 0;
  1106.     return 0;
  1107. }

  1109. #endif

  1111. #endif


  1114. static void
  1115. ‌ngx_http_process_request_line(ngx_event_t *rev)
  1116. {
  1117.     ssize_t              n;
  1118.     ngx_int_t            rc, rv;
  1119.     ngx_str_t            host;
  1120.     in_port_t            port;
  1121.     ngx_connection_t    *c;
  1122.     ngx_http_request_t  *r;

  1124.     c = rev->data;
  1125.     r = c->data;

  1127.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0,
  1128.                    "http process request line");

  1130.     if (rev->timedout) {
  1131.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  1132.         c->timedout = 1;
  1133.         ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  1134.         return;
  1135.     }

  1137.     rc = NGX_AGAIN;

  1139.     for ( ;; ) {

  1141.         if (rc == NGX_AGAIN) {
  1142.             n = ngx_http_read_request_header(r);

  1144.             if (n == NGX_AGAIN || n == NGX_ERROR) {
  1145.                 break;
  1146.             }
  1147.         }

  1149.         rc = ngx_http_parse_request_line(r, r->header_in);

  1151.         if (rc == NGX_OK) {

  1153.             /* the request line has been parsed successfully */

  1155.             r->request_line.len = r->request_end - r->request_start;
  1156.             r->request_line.data = r->request_start;
  1157.             r->request_length = r->header_in->pos - r->request_start;

  1159.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1160.                            "http request line: \"%V\"", &r->request_line);

  1162.             r->method_name.len = r->method_end - r->request_start + 1;
  1163.             r->method_name.data = r->request_line.data;

  1165.             if (r->http_protocol.data) {
  1166.                 r->http_protocol.len = r->request_end - r->http_protocol.data;
  1167.             }

  1169.             if (ngx_http_process_request_uri(r) != NGX_OK) {
  1170.                 break;
  1171.             }

  1173.             if (r->schema_end) {
  1174.                 r->schema.len = r->schema_end - r->schema_start;
  1175.                 r->schema.data = r->schema_start;
  1176.             }

  1178.             if (r->host_end) {

  1180.                 host.len = r->host_end - r->host_start;
  1181.                 host.data = r->host_start;

  1183.                 rc = ngx_http_validate_host(&host, &port, r->pool, 0);

  1185.                 if (rc == NGX_DECLINED) {
  1186.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1187.                                   "client sent invalid host in request line");
  1188.                     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1189.                     break;
  1190.                 }

  1192.                 if (rc == NGX_ERROR) {
  1193.                     ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1194.                     break;
  1195.                 }

  1197.                 if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
  1198.                     break;
  1199.                 }

  1201.                 r->headers_in.server = host;
  1202.                 r->port = port;
  1203.             }

  1205.             if (r->http_version < NGX_HTTP_VERSION_10) {

  1207.                 if (r->headers_in.server.len == 0
  1208.                     && ngx_http_set_virtual_server(r, &r->headers_in.server)
  1209.                        == NGX_ERROR)
  1210.                 {
  1211.                     break;
  1212.                 }

  1214.                 ngx_http_process_request(r);
  1215.                 break;
  1216.             }


  1219.             if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  1220.                               sizeof(ngx_table_elt_t))
  1221.                 != NGX_OK)
  1222.             {
  1223.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1224.                 break;
  1225.             }

  1227.             c->log->action = "reading client request headers";

  1229.             rev->handler = ngx_http_process_request_headers;
  1230.             ngx_http_process_request_headers(rev);

  1232.             break;
  1233.         }

  1235.         if (rc != NGX_AGAIN) {

  1237.             /* there was error while a request line parsing */

  1239.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1240.                           ngx_http_client_errors[rc - NGX_HTTP_CLIENT_ERROR]);

  1242.             if (rc == NGX_HTTP_PARSE_INVALID_VERSION) {
  1243.                 ngx_http_finalize_request(r, NGX_HTTP_VERSION_NOT_SUPPORTED);

  1245.             } else {
  1246.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1247.             }

  1249.             break;
  1250.         }

  1252.         /* NGX_AGAIN: a request line parsing is still incomplete */

  1254.         if (r->header_in->pos == r->header_in->end) {

  1256.             rv = ngx_http_alloc_large_header_buffer(r, 1);

  1258.             if (rv == NGX_ERROR) {
  1259.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1260.                 break;
  1261.             }

  1263.             if (rv == NGX_DECLINED) {
  1264.                 r->request_line.len = r->header_in->end - r->request_start;
  1265.                 r->request_line.data = r->request_start;

  1267.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1268.                               "client sent too long URI");
  1269.                 ngx_http_finalize_request(r, NGX_HTTP_REQUEST_URI_TOO_LARGE);
  1270.                 break;
  1271.             }
  1272.         }
  1273.     }

  1275.     ngx_http_run_posted_requests(c);
  1276. }


  1279. ngx_int_t
  1280. ‌ngx_http_process_request_uri(ngx_http_request_t *r)
  1281. {
  1282.     ngx_http_core_srv_conf_t  *cscf;

  1284.     if (r->args_start) {
  1285.         r->uri.len = r->args_start - 1 - r->uri_start;
  1286.     } else {
  1287.         r->uri.len = r->uri_end - r->uri_start;
  1288.     }

  1290.     if (r->complex_uri || r->quoted_uri || r->empty_path_in_uri) {

  1292.         if (r->empty_path_in_uri) {
  1293.             r->uri.len++;
  1294.         }

  1296.         r->uri.data = ngx_pnalloc(r->pool, r->uri.len);
  1297.         if (r->uri.data == NULL) {
  1298.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1299.             return NGX_ERROR;
  1300.         }

  1302.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1304.         if (ngx_http_parse_complex_uri(r, cscf->merge_slashes) != NGX_OK) {
  1305.             r->uri.len = 0;

  1307.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1308.                           "client sent invalid request");
  1309.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1310.             return NGX_ERROR;
  1311.         }

  1313.     } else {
  1314.         r->uri.data = r->uri_start;
  1315.     }

  1317.     r->unparsed_uri.len = r->uri_end - r->uri_start;
  1318.     r->unparsed_uri.data = r->uri_start;

  1320.     r->valid_unparsed_uri = r->empty_path_in_uri ? 0 : 1;

  1322.     if (r->uri_ext) {
  1323.         if (r->args_start) {
  1324.             r->exten.len = r->args_start - 1 - r->uri_ext;
  1325.         } else {
  1326.             r->exten.len = r->uri_end - r->uri_ext;
  1327.         }

  1329.         r->exten.data = r->uri_ext;
  1330.     }

  1332.     if (r->args_start && r->uri_end > r->args_start) {
  1333.         r->args.len = r->uri_end - r->args_start;
  1334.         r->args.data = r->args_start;
  1335.     }

  1337. #if (NGX_WIN32)
  1338.     {
  1339.     u_char  *p, *last;

  1341.     p = r->uri.data;
  1342.     last = r->uri.data + r->uri.len;

  1344.     while (p < last) {

  1346.         if (*p++ == ':') {

  1348.             /*
  1349.              * this check covers "::$data", "::$index_allocation" and
  1350.              * ":$i30:$index_allocation"
  1351.              */

  1353.             if (p < last && *p == '$') {
  1354.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1355.                               "client sent unsafe win32 URI");
  1356.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1357.                 return NGX_ERROR;
  1358.             }
  1359.         }
  1360.     }

  1362.     p = r->uri.data + r->uri.len - 1;

  1364.     while (p > r->uri.data) {

  1366.         if (*p == ' ') {
  1367.             p--;
  1368.             continue;
  1369.         }

  1371.         if (*p == '.') {
  1372.             p--;
  1373.             continue;
  1374.         }

  1376.         break;
  1377.     }

  1379.     if (p != r->uri.data + r->uri.len - 1) {
  1380.         r->uri.len = p + 1 - r->uri.data;
  1381.         ngx_http_set_exten(r);
  1382.     }

  1384.     }
  1385. #endif

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

  1390.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1391.                    "http args: \"%V\"", &r->args);

  1393.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1394.                    "http exten: \"%V\"", &r->exten);

  1396.     return NGX_OK;
  1397. }


  1400. static void
  1401. ‌ngx_http_process_request_headers(ngx_event_t *rev)
  1402. {
  1403.     u_char                     *p;
  1404.     size_t                      len;
  1405.     ssize_t                     n;
  1406.     ngx_int_t                   rc, rv;
  1407.     ngx_table_elt_t            *h;
  1408.     ngx_connection_t           *c;
  1409.     ngx_http_header_t          *hh;
  1410.     ngx_http_request_t         *r;
  1411.     ngx_http_core_srv_conf_t   *cscf;
  1412.     ngx_http_core_main_conf_t  *cmcf;

  1414.     c = rev->data;
  1415.     r = c->data;

  1417.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0,
  1418.                    "http process request header line");

  1420.     if (rev->timedout) {
  1421.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  1422.         c->timedout = 1;
  1423.         ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  1424.         return;
  1425.     }

  1427.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  1429.     rc = NGX_AGAIN;

  1431.     for ( ;; ) {

  1433.         if (rc == NGX_AGAIN) {

  1435.             if (r->header_in->pos == r->header_in->end) {

  1437.                 rv = ngx_http_alloc_large_header_buffer(r, 0);

  1439.                 if (rv == NGX_ERROR) {
  1440.                     ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1441.                     break;
  1442.                 }

  1444.                 if (rv == NGX_DECLINED) {
  1445.                     p = r->header_name_start;

  1447.                     r->lingering_close = 1;

  1449.                     if (p == NULL) {
  1450.                         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1451.                                       "client sent too large request");
  1452.                         ngx_http_finalize_request(r,
  1453.                                             NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  1454.                         break;
  1455.                     }

  1457.                     len = r->header_in->end - p;

  1459.                     if (len > NGX_MAX_ERROR_STR - 300) {
  1460.                         len = NGX_MAX_ERROR_STR - 300;
  1461.                     }

  1463.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1464.                                 "client sent too long header line: \"%*s...\"",
  1465.                                 len, r->header_name_start);

  1467.                     ngx_http_finalize_request(r,
  1468.                                             NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  1469.                     break;
  1470.                 }
  1471.             }

  1473.             n = ngx_http_read_request_header(r);

  1475.             if (n == NGX_AGAIN || n == NGX_ERROR) {
  1476.                 break;
  1477.             }
  1478.         }

  1480.         /* the host header could change the server configuration context */
  1481.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1483.         rc = ngx_http_parse_header_line(r, r->header_in,
  1484.                                         cscf->underscores_in_headers);

  1486.         if (rc == NGX_OK) {

  1488.             r->request_length += r->header_in->pos - r->header_name_start;

  1490.             if (r->invalid_header && cscf->ignore_invalid_headers) {

  1492.                 /* there was error while a header line parsing */

  1494.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1495.                               "client sent invalid header line: \"%*s\"",
  1496.                               r->header_end - r->header_name_start,
  1497.                               r->header_name_start);
  1498.                 continue;
  1499.             }

  1501.             /* a header line has been parsed successfully */

  1503.             if (r->headers_in.count++ >= cscf->max_headers) {
  1504.                 r->lingering_close = 1;
  1505.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1506.                               "client sent too many header lines");
  1507.                 ngx_http_finalize_request(r,
  1508.                                           NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  1509.                 break;
  1510.             }

  1512.             h = ngx_list_push(&r->headers_in.headers);
  1513.             if (h == NULL) {
  1514.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1515.                 break;
  1516.             }

  1518.             h->hash = r->header_hash;

  1520.             h->key.len = r->header_name_end - r->header_name_start;
  1521.             h->key.data = r->header_name_start;
  1522.             h->key.data[h->key.len] = '\0';

  1524.             h->value.len = r->header_end - r->header_start;
  1525.             h->value.data = r->header_start;
  1526.             h->value.data[h->value.len] = '\0';

  1528.             h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
  1529.             if (h->lowcase_key == NULL) {
  1530.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1531.                 break;
  1532.             }

  1534.             if (h->key.len == r->lowcase_index) {
  1535.                 ngx_memcpy(h->lowcase_key, r->lowcase_header, h->key.len);

  1537.             } else {
  1538.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1539.             }

  1541.             hh = ngx_hash_find(&cmcf->headers_in_hash, h->hash,
  1542.                                h->lowcase_key, h->key.len);

  1544.             if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1545.                 break;
  1546.             }

  1548.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1549.                            "http header: \"%V: %V\"",
  1550.                            &h->key, &h->value);

  1552.             continue;
  1553.         }

  1555.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

  1557.             /* a whole header has been parsed successfully */

  1559.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1560.                            "http header done");

  1562.             r->request_length += r->header_in->pos - r->header_name_start;

  1564.             r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  1566.             rc = ngx_http_process_request_header(r);

  1568.             if (rc != NGX_OK) {
  1569.                 break;
  1570.             }

  1572.             ngx_http_process_request(r);

  1574.             break;
  1575.         }

  1577.         if (rc == NGX_AGAIN) {

  1579.             /* a header line parsing is still not complete */

  1581.             continue;
  1582.         }

  1584.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  1586.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1587.                       "client sent invalid header line: \"%*s\\x%02xd...\"",
  1588.                       r->header_end - r->header_name_start,
  1589.                       r->header_name_start, *r->header_end);

  1591.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1592.         break;
  1593.     }

  1595.     ngx_http_run_posted_requests(c);
  1596. }


  1599. static ssize_t
  1600. ‌ngx_http_read_request_header(ngx_http_request_t *r)
  1601. {
  1602.     ssize_t                    n;
  1603.     ngx_event_t               *rev;
  1604.     ngx_connection_t          *c;
  1605.     ngx_http_core_srv_conf_t  *cscf;

  1607.     c = r->connection;
  1608.     rev = c->read;

  1610.     n = r->header_in->last - r->header_in->pos;

  1612.     if (n > 0) {
  1613.         return n;
  1614.     }

  1616.     if (rev->ready) {
  1617.         n = c->recv(c, r->header_in->last,
  1618.                     r->header_in->end - r->header_in->last);
  1619.     } else {
  1620.         n = NGX_AGAIN;
  1621.     }

  1623.     if (n == NGX_AGAIN) {
  1624.         if (!rev->timer_set) {
  1625.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  1626.             ngx_add_timer(rev, cscf->client_header_timeout);
  1627.         }

  1629.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  1630.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1631.             return NGX_ERROR;
  1632.         }

  1634.         return NGX_AGAIN;
  1635.     }

  1637.     if (n == 0) {
  1638.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1639.                       "client prematurely closed connection");
  1640.     }

  1642.     if (n == 0 || n == NGX_ERROR) {
  1643.         c->error = 1;
  1644.         c->log->action = "reading client request headers";

  1646.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1647.         return NGX_ERROR;
  1648.     }

  1650.     r->header_in->last += n;

  1652.     return n;
  1653. }


  1656. static ngx_int_t
  1657. ‌ngx_http_alloc_large_header_buffer(ngx_http_request_t *r,
  1658.     ngx_uint_t request_line)
  1659. {
  1660.     u_char                    *old, *new;
  1661.     ngx_buf_t                 *b;
  1662.     ngx_chain_t               *cl;
  1663.     ngx_http_connection_t     *hc;
  1664.     ngx_http_core_srv_conf_t  *cscf;

  1666.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1667.                    "http alloc large header buffer");

  1669.     if (request_line && r->state == 0) {

  1671.         /* the client fills up the buffer with "\r\n" */

  1673.         r->header_in->pos = r->header_in->start;
  1674.         r->header_in->last = r->header_in->start;

  1676.         return NGX_OK;
  1677.     }

  1679.     old = request_line ? r->request_start : r->header_name_start;

  1681.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1683.     if (r->state != 0
  1684.         && (size_t) (r->header_in->pos - old)
  1685.                                      >= cscf->large_client_header_buffers.size)
  1686.     {
  1687.         return NGX_DECLINED;
  1688.     }

  1690.     hc = r->http_connection;

  1692.     if (hc->free) {
  1693.         cl = hc->free;
  1694.         hc->free = cl->next;

  1696.         b = cl->buf;

  1698.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1699.                        "http large header free: %p %uz",
  1700.                        b->pos, b->end - b->last);

  1702.     } else if (hc->nbusy < cscf->large_client_header_buffers.num) {

  1704.         b = ngx_create_temp_buf(r->connection->pool,
  1705.                                 cscf->large_client_header_buffers.size);
  1706.         if (b == NULL) {
  1707.             return NGX_ERROR;
  1708.         }

  1710.         cl = ngx_alloc_chain_link(r->connection->pool);
  1711.         if (cl == NULL) {
  1712.             return NGX_ERROR;
  1713.         }

  1715.         cl->buf = b;

  1717.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1718.                        "http large header alloc: %p %uz",
  1719.                        b->pos, b->end - b->last);

  1721.     } else {
  1722.         return NGX_DECLINED;
  1723.     }

  1725.     cl->next = hc->busy;
  1726.     hc->busy = cl;
  1727.     hc->nbusy++;

  1729.     if (r->state == 0) {
  1730.         /*
  1731.          * r->state == 0 means that a header line was parsed successfully
  1732.          * and we do not need to copy incomplete header line and
  1733.          * to relocate the parser header pointers
  1734.          */

  1736.         r->header_in = b;

  1738.         return NGX_OK;
  1739.     }

  1741.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1742.                    "http large header copy: %uz", r->header_in->pos - old);

  1744.     if (r->header_in->pos - old > b->end - b->start) {
  1745.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1746.                       "too large header to copy");
  1747.         return NGX_ERROR;
  1748.     }

  1750.     new = b->start;

  1752.     ngx_memcpy(new, old, r->header_in->pos - old);

  1754.     b->pos = new + (r->header_in->pos - old);
  1755.     b->last = new + (r->header_in->pos - old);

  1757.     if (request_line) {
  1758.         r->request_start = new;

  1760.         if (r->request_end) {
  1761.             r->request_end = new + (r->request_end - old);
  1762.         }

  1764.         if (r->method_end) {
  1765.             r->method_end = new + (r->method_end - old);
  1766.         }

  1768.         if (r->uri_start) {
  1769.             r->uri_start = new + (r->uri_start - old);
  1770.         }

  1772.         if (r->uri_end) {
  1773.             r->uri_end = new + (r->uri_end - old);
  1774.         }

  1776.         if (r->schema_start) {
  1777.             r->schema_start = new + (r->schema_start - old);
  1778.             if (r->schema_end) {
  1779.                 r->schema_end = new + (r->schema_end - old);
  1780.             }
  1781.         }

  1783.         if (r->host_start) {
  1784.             r->host_start = new + (r->host_start - old);
  1785.             if (r->host_end) {
  1786.                 r->host_end = new + (r->host_end - old);
  1787.             }
  1788.         }

  1790.         if (r->uri_ext) {
  1791.             r->uri_ext = new + (r->uri_ext - old);
  1792.         }

  1794.         if (r->args_start) {
  1795.             r->args_start = new + (r->args_start - old);
  1796.         }

  1798.         if (r->http_protocol.data) {
  1799.             r->http_protocol.data = new + (r->http_protocol.data - old);
  1800.         }

  1802.     } else {
  1803.         r->header_name_start = new;

  1805.         if (r->header_name_end) {
  1806.             r->header_name_end = new + (r->header_name_end - old);
  1807.         }

  1809.         if (r->header_start) {
  1810.             r->header_start = new + (r->header_start - old);
  1811.         }

  1813.         if (r->header_end) {
  1814.             r->header_end = new + (r->header_end - old);
  1815.         }
  1816.     }

  1818.     r->header_in = b;

  1820.     return NGX_OK;
  1821. }


  1824. static ngx_int_t
  1825. ‌ngx_http_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  1826.     ngx_uint_t offset)
  1827. {
  1828.     ngx_table_elt_t  **ph;

  1830.     ph = (ngx_table_elt_t **) ((char *) &r->headers_in + offset);

  1832.     while (*ph) { ph = &(*ph)->next; }

  1834.     *ph = h;
  1835.     h->next = NULL;

  1837.     return NGX_OK;
  1838. }


  1841. static ngx_int_t
  1842. ‌ngx_http_process_unique_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  1843.     ngx_uint_t offset)
  1844. {
  1845.     ngx_table_elt_t  **ph;

  1847.     ph = (ngx_table_elt_t **) ((char *) &r->headers_in + offset);

  1849.     if (*ph == NULL) {
  1850.         *ph = h;
  1851.         h->next = NULL;
  1852.         return NGX_OK;
  1853.     }

  1855.     ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1856.                   "client sent duplicate header line: \"%V: %V\", "
  1857.                   "previous value: \"%V: %V\"",
  1858.                   &h->key, &h->value, &(*ph)->key, &(*ph)->value);

  1860.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);

  1862.     return NGX_ERROR;
  1863. }


  1866. static ngx_int_t
  1867. ‌ngx_http_process_host(ngx_http_request_t *r, ngx_table_elt_t *h,
  1868.     ngx_uint_t offset)
  1869. {
  1870.     ngx_int_t  rc;
  1871.     ngx_str_t  host;
  1872.     in_port_t  port;

  1874.     if (r->headers_in.host) {
  1875.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1876.                       "client sent duplicate host header: \"%V: %V\", "
  1877.                       "previous value: \"%V: %V\"",
  1878.                       &h->key, &h->value, &r->headers_in.host->key,
  1879.                       &r->headers_in.host->value);
  1880.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1881.         return NGX_ERROR;
  1882.     }

  1884.     r->headers_in.host = h;
  1885.     h->next = NULL;

  1887.     host = h->value;

  1889.     rc = ngx_http_validate_host(&host, &port, r->pool, 0);

  1891.     if (rc == NGX_DECLINED) {
  1892.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1893.                       "client sent invalid host header");
  1894.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1895.         return NGX_ERROR;
  1896.     }

  1898.     if (rc == NGX_ERROR) {
  1899.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1900.         return NGX_ERROR;
  1901.     }

  1903.     if (r->headers_in.server.len) {
  1904.         return NGX_OK;
  1905.     }

  1907.     if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
  1908.         return NGX_ERROR;
  1909.     }

  1911.     r->headers_in.server = host;
  1912.     r->port = port;

  1914.     return NGX_OK;
  1915. }


  1918. static ngx_int_t
  1919. ‌ngx_http_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  1920.     ngx_uint_t offset)
  1921. {
  1922.     if (ngx_http_process_header_line(r, h, offset) != NGX_OK) {
  1923.         return NGX_ERROR;
  1924.     }

  1926.     if (ngx_strcasestrn(h->value.data, "close", 5 - 1)) {
  1927.         r->headers_in.connection_type = NGX_HTTP_CONNECTION_CLOSE;

  1929.     } else if (ngx_strcasestrn(h->value.data, "keep-alive", 10 - 1)) {
  1930.         r->headers_in.connection_type = NGX_HTTP_CONNECTION_KEEP_ALIVE;
  1931.     }

  1933.     return NGX_OK;
  1934. }


  1937. static ngx_int_t
  1938. ‌ngx_http_process_proxy_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  1939.     ngx_uint_t offset)
  1940. {
  1941.     if (r->http_version >= NGX_HTTP_VERSION_20) {
  1942.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1943.                       "client sent \"Proxy-Connection\" header");
  1944.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1945.         return NGX_ERROR;
  1946.     }

  1948.     return NGX_OK;
  1949. }


  1952. static ngx_int_t
  1953. ‌ngx_http_process_user_agent(ngx_http_request_t *r, ngx_table_elt_t *h,
  1954.     ngx_uint_t offset)
  1955. {
  1956.     u_char  *user_agent, *msie;

  1958.     if (ngx_http_process_header_line(r, h, offset) != NGX_OK) {
  1959.         return NGX_ERROR;
  1960.     }

  1962.     /* check some widespread browsers while the header is in CPU cache */

  1964.     user_agent = h->value.data;

  1966.     msie = ngx_strstrn(user_agent, "MSIE ", 5 - 1);

  1968.     if (msie && msie + 7 < user_agent + h->value.len) {

  1970.         r->headers_in.msie = 1;

  1972.         if (msie[6] == '.') {

  1974.             switch (msie[5]) {
  1975.             case '4':
  1976.             case '5':
  1977.                 r->headers_in.msie6 = 1;
  1978.                 break;
  1979.             case '6':
  1980.                 if (ngx_strstrn(msie + 8, "SV1", 3 - 1) == NULL) {
  1981.                     r->headers_in.msie6 = 1;
  1982.                 }
  1983.                 break;
  1984.             }
  1985.         }

  1987. #if 0
  1988.         /* MSIE ignores the SSL "close notify" alert */
  1989.         if (c->ssl) {
  1990.             c->ssl->no_send_shutdown = 1;
  1991.         }
  1992. #endif
  1993.     }

  1995.     if (ngx_strstrn(user_agent, "Opera", 5 - 1)) {
  1996.         r->headers_in.opera = 1;
  1997.         r->headers_in.msie = 0;
  1998.         r->headers_in.msie6 = 0;
  1999.     }

  2001.     if (!r->headers_in.msie && !r->headers_in.opera) {

  2003.         if (ngx_strstrn(user_agent, "Gecko/", 6 - 1)) {
  2004.             r->headers_in.gecko = 1;

  2006.         } else if (ngx_strstrn(user_agent, "Chrome/", 7 - 1)) {
  2007.             r->headers_in.chrome = 1;

  2009.         } else if (ngx_strstrn(user_agent, "Safari/", 7 - 1)
  2010.                    && ngx_strstrn(user_agent, "Mac OS X", 8 - 1))
  2011.         {
  2012.             r->headers_in.safari = 1;

  2014.         } else if (ngx_strstrn(user_agent, "Konqueror", 9 - 1)) {
  2015.             r->headers_in.konqueror = 1;
  2016.         }
  2017.     }

  2019.     return NGX_OK;
  2020. }


  2023. static ngx_int_t
  2024. ‌ngx_http_process_request_header(ngx_http_request_t *r)
  2025. {
  2026.     ngx_http_core_srv_conf_t  *cscf;

  2028.     if (r->headers_in.server.len == 0
  2029.         && ngx_http_set_virtual_server(r, &r->headers_in.server)
  2030.            == NGX_ERROR)
  2031.     {
  2032.         return NGX_ERROR;
  2033.     }

  2035.     if (r->headers_in.host == NULL && r->http_version > NGX_HTTP_VERSION_10) {
  2036.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2037.                    "client sent HTTP/1.1 request without \"Host\" header");
  2038.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  2039.         return NGX_ERROR;
  2040.     }

  2042.     if (r->headers_in.content_length) {
  2043.         r->headers_in.content_length_n =
  2044.                             ngx_atoof(r->headers_in.content_length->value.data,
  2045.                                       r->headers_in.content_length->value.len);

  2047.         if (r->headers_in.content_length_n == NGX_ERROR) {
  2048.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2049.                           "client sent invalid \"Content-Length\" header");
  2050.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  2051.             return NGX_ERROR;
  2052.         }
  2053.     }

  2055.     if (r->headers_in.transfer_encoding) {
  2056.         if (r->http_version < NGX_HTTP_VERSION_11) {
  2057.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2058.                           "client sent HTTP/1.0 request with "
  2059.                           "\"Transfer-Encoding\" header");
  2060.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  2061.             return NGX_ERROR;
  2062.         }

  2064.         if (r->headers_in.transfer_encoding->value.len == 7
  2065.             && ngx_strncasecmp(r->headers_in.transfer_encoding->value.data,
  2066.                                (u_char *) "chunked", 7) == 0)
  2067.         {
  2068.             if (r->headers_in.content_length) {
  2069.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2070.                               "client sent \"Content-Length\" and "
  2071.                               "\"Transfer-Encoding\" headers "
  2072.                               "at the same time");
  2073.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  2074.                 return NGX_ERROR;
  2075.             }

  2077.             r->headers_in.chunked = 1;

  2079.         } else {
  2080.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2081.                           "client sent unknown \"Transfer-Encoding\": \"%V\"",
  2082.                           &r->headers_in.transfer_encoding->value);
  2083.             ngx_http_finalize_request(r, NGX_HTTP_NOT_IMPLEMENTED);
  2084.             return NGX_ERROR;
  2085.         }
  2086.     }

  2088.     if (r->headers_in.connection_type == NGX_HTTP_CONNECTION_KEEP_ALIVE) {
  2089.         if (r->headers_in.keep_alive) {
  2090.             r->headers_in.keep_alive_n =
  2091.                             ngx_atotm(r->headers_in.keep_alive->value.data,
  2092.                                       r->headers_in.keep_alive->value.len);
  2093.         }
  2094.     }

  2096.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  2098.     if (r->method == NGX_HTTP_CONNECT) {
  2099.         if (r->http_version != NGX_HTTP_VERSION_11 || !cscf->allow_connect) {
  2100.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2101.                           "client sent CONNECT method");
  2102.             ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  2103.             return NGX_ERROR;
  2104.         }

  2106.         if (r->headers_in.content_length_n > 0 || r->headers_in.chunked) {
  2107.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2108.                           "client sent CONNECT request with body");
  2109.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  2110.             return NGX_ERROR;
  2111.         }
  2112.     }

  2114.     if (r->method == NGX_HTTP_TRACE) {
  2115.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2116.                       "client sent TRACE method");
  2117.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  2118.         return NGX_ERROR;
  2119.     }

  2121.     return NGX_OK;
  2122. }


  2125. void
  2126. ‌ngx_http_process_request(ngx_http_request_t *r)
  2127. {
  2128.     ngx_connection_t  *c;

  2130.     c = r->connection;

  2132. #if (NGX_HTTP_SSL)

  2134.     if (r->http_connection->ssl) {
  2135.         long                      rc;
  2136.         X509                     *cert;
  2137.         const char               *s;
  2138.         ngx_http_ssl_srv_conf_t  *sscf;

  2140.         if (c->ssl == NULL) {
  2141.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2142.                           "client sent plain HTTP request to HTTPS port");
  2143.             ngx_http_finalize_request(r, NGX_HTTP_TO_HTTPS);
  2144.             return;
  2145.         }

  2147.         sscf = ngx_http_get_module_srv_conf(r, ngx_http_ssl_module);

  2149.         if (sscf->verify) {
  2150.             rc = SSL_get_verify_result(c->ssl->connection);

  2152.             if (rc != X509_V_OK
  2153.                 && (sscf->verify != 3 || !ngx_ssl_verify_error_optional(rc)))
  2154.             {
  2155.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2156.                               "client SSL certificate verify error: (%l:%s)",
  2157.                               rc, X509_verify_cert_error_string(rc));

  2159.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2160.                                        (SSL_get0_session(c->ssl->connection)));

  2162.                 ngx_http_finalize_request(r, NGX_HTTPS_CERT_ERROR);
  2163.                 return;
  2164.             }

  2166.             if (sscf->verify == 1) {
  2167.                 cert = SSL_get_peer_certificate(c->ssl->connection);

  2169.                 if (cert == NULL) {
  2170.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2171.                                   "client sent no required SSL certificate");

  2173.                     ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2174.                                        (SSL_get0_session(c->ssl->connection)));

  2176.                     ngx_http_finalize_request(r, NGX_HTTPS_NO_CERT);
  2177.                     return;
  2178.                 }

  2180.                 X509_free(cert);
  2181.             }

  2183.             if (ngx_ssl_ocsp_get_status(c, &s) != NGX_OK) {
  2184.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2185.                               "client SSL certificate verify error: %s", s);

  2187.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2188.                                        (SSL_get0_session(c->ssl->connection)));

  2190.                 ngx_http_finalize_request(r, NGX_HTTPS_CERT_ERROR);
  2191.                 return;
  2192.             }
  2193.         }
  2194.     }

  2196. #endif

  2198.     if (c->read->timer_set) {
  2199.         ngx_del_timer(c->read);
  2200.     }

  2202. #if (NGX_STAT_STUB)
  2203.     (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  2204.     r->stat_reading = 0;
  2205.     (void) ngx_atomic_fetch_add(ngx_stat_writing, 1);
  2206.     r->stat_writing = 1;
  2207. #endif

  2209.     c->read->handler = ngx_http_request_handler;
  2210.     c->write->handler = ngx_http_request_handler;
  2211.     r->read_event_handler = ngx_http_block_reading;

  2213.     if (ngx_http_read_early_body(r) != NGX_OK) {
  2214.         return;
  2215.     }

  2217.     ngx_http_handler(r);
  2218. }


  2221. static ngx_int_t
  2222. ‌ngx_http_read_early_body(ngx_http_request_t *r)
  2223. {
  2224.     ngx_int_t                  rc;
  2225.     ngx_http_core_loc_conf_t  *clcf;
  2226.     ngx_http_core_srv_conf_t  *cscf;

  2228.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  2230.     rc = ngx_http_test_predicates(r, cscf->client_body_early_read);

  2232.     if (rc == NGX_ERROR) {
  2233.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2234.         return NGX_DONE;
  2235.     }

  2237.     if (rc == NGX_OK) {
  2238.         return NGX_OK;
  2239.     }

  2241.     /* rc == NGX_DECLINED */

  2243.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2244.                    "http client request body early read");

  2246.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2248.     if (r->headers_in.content_length_n != -1
  2249.         && !r->discard_body
  2250.         && clcf->client_max_body_size
  2251.         && clcf->client_max_body_size < r->headers_in.content_length_n)
  2252.     {
  2253.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2254.                       "client intended to send too large body: %O bytes",
  2255.                       r->headers_in.content_length_n);

  2257.         r->expect_tested = 1;
  2258.         (void) ngx_http_discard_request_body(r);
  2259.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_ENTITY_TOO_LARGE);
  2260.         return NGX_DONE;
  2261.     }

  2263.     rc = ngx_http_read_client_request_body(r, ngx_http_handler);

  2265.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2266.         ngx_http_finalize_request(r, rc);
  2267.         return NGX_DONE;
  2268.     }

  2270.     ngx_http_finalize_request(r, NGX_DONE);

  2272.     return NGX_DONE;
  2273. }


  2276. ngx_int_t
  2277. ‌ngx_http_validate_host(ngx_str_t *host, in_port_t *portp, ngx_pool_t *pool,
  2278.     ngx_uint_t alloc)
  2279. {
  2280.     u_char     *h, ch;
  2281.     size_t      i, dot_pos, host_len;
  2282.     ngx_int_t   port;

  2284. ‌    enum {
  2285.         sw_host_start = 0,
  2286.         sw_host,
  2287.         sw_host_ip_literal,
  2288.         sw_host_end,
  2289.         sw_port,
  2290.     } state;

  2292.     dot_pos = host->len;
  2293.     host_len = host->len;
  2294.     port = 0;

  2296.     h = host->data;

  2298.     state = sw_host_start;

  2300.     for (i = 0; i < host->len; i++) {
  2301.         ch = h[i];

  2303.         switch (state) {

  2305.         case sw_host_start:

  2307.             if (ch == '[') {
  2308.                 state = sw_host_ip_literal;
  2309.                 break;
  2310.             }

  2312.             state = sw_host;

  2314.             /* fall through */

  2316.         case sw_host:

  2318.             if (ch >= 'A' && ch <= 'Z') {
  2319.                 alloc = 1;
  2320.                 break;
  2321.             }

  2323.             if (ch >= 'a' && ch <= 'z') {
  2324.                 break;
  2325.             }

  2327.             if (ch >= '0' && ch <= '9') {
  2328.                 break;
  2329.             }

  2331.             switch (ch) {
  2332.             case ':':
  2333.                 host_len = i;
  2334.                 state = sw_port;
  2335.                 break;
  2336.             case '-':
  2337.                 break;
  2338.             case '.':
  2339.                 if (dot_pos == i - 1) {
  2340.                     return NGX_DECLINED;
  2341.                 }
  2342.                 dot_pos = i;
  2343.                 break;
  2344.             case '_':
  2345.             case '~':
  2346.                 /* unreserved */
  2347.                 break;
  2348.             case '!':
  2349.             case '$':
  2350.             case '&':
  2351.             case '\'':
  2352.             case '(':
  2353.             case ')':
  2354.             case '*':
  2355.             case '+':
  2356.             case ',':
  2357.             case ';':
  2358.             case '=':
  2359.                 /* sub-delims */
  2360.                 break;
  2361.             case '%':
  2362.                 /* pct-encoded */
  2363.                 break;
  2364.             default:
  2365.                 return NGX_DECLINED;
  2366.             }
  2367.             break;

  2369.         case sw_host_ip_literal:

  2371.             if (ch >= 'A' && ch <= 'Z') {
  2372.                 alloc = 1;
  2373.                 break;
  2374.             }

  2376.             if (ch >= 'a' && ch <= 'z') {
  2377.                 break;
  2378.             }

  2380.             if (ch >= '0' && ch <= '9') {
  2381.                 break;
  2382.             }

  2384.             switch (ch) {
  2385.             case ':':
  2386.                 break;
  2387.             case ']':
  2388.                 host_len = i + 1;
  2389.                 state = sw_host_end;
  2390.                 break;
  2391.             case '-':
  2392.                 break;
  2393.             case '.':
  2394.                 if (dot_pos == i - 1) {
  2395.                     return NGX_DECLINED;
  2396.                 }
  2397.                 dot_pos = i;
  2398.                 break;
  2399.             case '_':
  2400.             case '~':
  2401.                 /* unreserved */
  2402.                 break;
  2403.             case '!':
  2404.             case '$':
  2405.             case '&':
  2406.             case '\'':
  2407.             case '(':
  2408.             case ')':
  2409.             case '*':
  2410.             case '+':
  2411.             case ',':
  2412.             case ';':
  2413.             case '=':
  2414.                 /* sub-delims */
  2415.                 break;
  2416.             default:
  2417.                 return NGX_DECLINED;
  2418.             }
  2419.             break;

  2421.         case sw_host_end:

  2423.             if (ch == ':') {
  2424.                 state = sw_port;
  2425.                 break;
  2426.             }
  2427.             return NGX_DECLINED;

  2429.         case sw_port:

  2431.             if (ch >= '0' && ch <= '9') {
  2432.                 if (port >= 6553 && (port > 6553 || (ch - '0') > 5)) {
  2433.                     return NGX_DECLINED;
  2434.                 }

  2436.                 port = port * 10 + (ch - '0');
  2437.                 break;
  2438.             }
  2439.             return NGX_DECLINED;
  2440.         }
  2441.     }

  2443.     if (state == sw_host_ip_literal) {
  2444.         return NGX_DECLINED;
  2445.     }

  2447.     if (dot_pos == host_len - 1) {
  2448.         host_len--;
  2449.     }

  2451.     if (host_len == 0) {
  2452.         return NGX_DECLINED;
  2453.     }

  2455.     if (alloc) {
  2456.         host->data = ngx_pnalloc(pool, host_len);
  2457.         if (host->data == NULL) {
  2458.             return NGX_ERROR;
  2459.         }

  2461.         ngx_strlow(host->data, h, host_len);
  2462.     }

  2464.     host->len = host_len;

  2466.     if (portp) {
  2467.         *portp = port;
  2468.     }

  2470.     return NGX_OK;
  2471. }


  2474. ngx_int_t
  2475. ‌ngx_http_set_virtual_server(ngx_http_request_t *r, ngx_str_t *host)
  2476. {
  2477.     ngx_int_t                  rc;
  2478.     ngx_http_connection_t     *hc;
  2479.     ngx_http_core_loc_conf_t  *clcf;
  2480.     ngx_http_core_srv_conf_t  *cscf;

  2482. #if (NGX_SUPPRESS_WARN)
  2483.     cscf = NULL;
  2484. #endif

  2486.     hc = r->http_connection;

  2488. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2490.     if (hc->ssl_servername) {
  2491.         if (hc->ssl_servername->len == host->len
  2492.             && ngx_strncmp(hc->ssl_servername->data,
  2493.                            host->data, host->len) == 0)
  2494.         {
  2495. #if (NGX_PCRE)
  2496.             if (hc->ssl_servername_regex
  2497.                 && ngx_http_regex_exec(r, hc->ssl_servername_regex,
  2498.                                           hc->ssl_servername) != NGX_OK)
  2499.             {
  2500.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2501.                 return NGX_ERROR;
  2502.             }
  2503. #endif
  2504.             return NGX_OK;
  2505.         }
  2506.     }

  2508. #endif

  2510.     rc = ngx_http_find_virtual_server(r->connection,
  2511.                                       hc->addr_conf->virtual_names,
  2512.                                       host, r, &cscf);

  2514.     if (rc == NGX_ERROR) {
  2515.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2516.         return NGX_ERROR;
  2517.     }

  2519. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2521.     if (hc->ssl_servername) {
  2522.         ngx_http_ssl_srv_conf_t  *sscf;

  2524.         if (rc == NGX_DECLINED) {
  2525.             cscf = hc->addr_conf->default_server;
  2526.             rc = NGX_OK;
  2527.         }

  2529.         sscf = ngx_http_get_module_srv_conf(cscf->ctx, ngx_http_ssl_module);

  2531.         if (sscf->verify) {
  2532.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2533.                           "client attempted to request the server name "
  2534.                           "different from the one that was negotiated");
  2535.             ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  2536.             return NGX_ERROR;
  2537.         }
  2538.     }

  2540. #endif

  2542.     if (rc == NGX_DECLINED) {
  2543.         return NGX_OK;
  2544.     }

  2546.     r->srv_conf = cscf->ctx->srv_conf;
  2547.     r->loc_conf = cscf->ctx->loc_conf;

  2549.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2551.     ngx_set_connection_log(r->connection, clcf->error_log);

  2553.     return NGX_OK;
  2554. }


  2557. static ngx_int_t
  2558. ‌ngx_http_find_virtual_server(ngx_connection_t *c,
  2559.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  2560.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp)
  2561. {
  2562.     ngx_http_core_srv_conf_t  *cscf;

  2564.     if (virtual_names == NULL) {
  2565.         return NGX_DECLINED;
  2566.     }

  2568.     cscf = ngx_hash_find_combined(&virtual_names->names,
  2569.                                   ngx_hash_key(host->data, host->len),
  2570.                                   host->data, host->len);

  2572.     if (cscf) {
  2573.         *cscfp = cscf;
  2574.         return NGX_OK;
  2575.     }

  2577. #if (NGX_PCRE)

  2579.     if (host->len && virtual_names->nregex) {
  2580.         ngx_int_t                n;
  2581.         ngx_uint_t               i;
  2582.         ngx_http_server_name_t  *sn;

  2584.         sn = virtual_names->regex;

  2586. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2588.         if (r == NULL) {
  2589.             ngx_http_connection_t  *hc;

  2591.             for (i = 0; i < virtual_names->nregex; i++) {

  2593.                 n = ngx_regex_exec(sn[i].regex->regex, host, NULL, 0);

  2595.                 if (n == NGX_REGEX_NO_MATCHED) {
  2596.                     continue;
  2597.                 }

  2599.                 if (n >= 0) {
  2600.                     hc = c->data;
  2601.                     hc->ssl_servername_regex = sn[i].regex;

  2603.                     *cscfp = sn[i].server;
  2604.                     return NGX_OK;
  2605.                 }

  2607.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2608.                               ngx_regex_exec_n " failed: %i "
  2609.                               "on \"%V\" using \"%V\"",
  2610.                               n, host, &sn[i].regex->name);

  2612.                 return NGX_ERROR;
  2613.             }

  2615.             return NGX_DECLINED;
  2616.         }

  2618. #endif /* NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME */

  2620.         for (i = 0; i < virtual_names->nregex; i++) {

  2622.             n = ngx_http_regex_exec(r, sn[i].regex, host);

  2624.             if (n == NGX_DECLINED) {
  2625.                 continue;
  2626.             }

  2628.             if (n == NGX_OK) {
  2629.                 *cscfp = sn[i].server;
  2630.                 return NGX_OK;
  2631.             }

  2633.             return NGX_ERROR;
  2634.         }
  2635.     }

  2637. #endif /* NGX_PCRE */

  2639.     return NGX_DECLINED;
  2640. }


  2643. static void
  2644. ‌ngx_http_request_handler(ngx_event_t *ev)
  2645. {
  2646.     ngx_connection_t    *c;
  2647.     ngx_http_request_t  *r;

  2649.     c = ev->data;
  2650.     r = c->data;

  2652.     ngx_http_set_log_request(c->log, r);

  2654.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2655.                    "http run request: \"%V?%V\"", &r->uri, &r->args);

  2657.     if (c->close) {
  2658.         r->main->count++;
  2659.         ngx_http_terminate_request(r, 0);
  2660.         ngx_http_run_posted_requests(c);
  2661.         return;
  2662.     }

  2664.     if (ev->delayed && ev->timedout) {
  2665.         ev->delayed = 0;
  2666.         ev->timedout = 0;
  2667.     }

  2669.     if (ev->write) {
  2670.         r->write_event_handler(r);

  2672.     } else {
  2673.         r->read_event_handler(r);
  2674.     }

  2676.     ngx_http_run_posted_requests(c);
  2677. }


  2680. void
  2681. ‌ngx_http_run_posted_requests(ngx_connection_t *c)
  2682. {
  2683.     ngx_http_request_t         *r;
  2684.     ngx_http_posted_request_t  *pr;

  2686.     for ( ;; ) {

  2688.         if (c->destroyed) {
  2689.             return;
  2690.         }

  2692.         r = c->data;
  2693.         pr = r->main->posted_requests;

  2695.         if (pr == NULL) {
  2696.             return;
  2697.         }

  2699.         r->main->posted_requests = pr->next;

  2701.         r = pr->request;

  2703.         ngx_http_set_log_request(c->log, r);

  2705.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2706.                        "http posted request: \"%V?%V\"", &r->uri, &r->args);

  2708.         r->write_event_handler(r);
  2709.     }
  2710. }


  2713. ngx_int_t
  2714. ‌ngx_http_post_request(ngx_http_request_t *r, ngx_http_posted_request_t *pr)
  2715. {
  2716.     ngx_http_posted_request_t  **p;

  2718.     for (p = &r->main->posted_requests; *p; p = &(*p)->next) {
  2719.         if ((*p)->request == r) {
  2720.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2721.                            "http request already posted");
  2722.             return NGX_OK;
  2723.         }
  2724.     }

  2726.     if (pr == NULL) {
  2727.         pr = ngx_palloc(r->pool, sizeof(ngx_http_posted_request_t));
  2728.         if (pr == NULL) {
  2729.             return NGX_ERROR;
  2730.         }
  2731.     }

  2733.     pr->request = r;
  2734.     pr->next = NULL;

  2736.     *p = pr;

  2738.     return NGX_OK;
  2739. }


  2742. void
  2743. ‌ngx_http_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2744. {
  2745.     ngx_connection_t          *c;
  2746.     ngx_http_request_t        *pr;
  2747.     ngx_http_core_loc_conf_t  *clcf;

  2749.     c = r->connection;

  2751.     ngx_log_debug5(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2752.                    "http finalize request: %i, \"%V?%V\" a:%d, c:%d",
  2753.                    rc, &r->uri, &r->args, r == c->data, r->main->count);

  2755.     if (rc == NGX_DONE) {
  2756.         ngx_http_finalize_connection(r);
  2757.         return;
  2758.     }

  2760.     if (rc == NGX_OK && r->filter_finalize) {
  2761.         c->error = 1;
  2762.     }

  2764.     if (rc == NGX_DECLINED) {
  2765.         r->content_handler = NULL;
  2766.         r->write_event_handler = ngx_http_core_run_phases;
  2767.         ngx_http_core_run_phases(r);
  2768.         return;
  2769.     }

  2771.     if (r != r->main && r->post_subrequest) {
  2772.         rc = r->post_subrequest->handler(r, r->post_subrequest->data, rc);
  2773.     }

  2775.     if (rc == NGX_ERROR
  2776.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  2777.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST
  2778.         || c->error)
  2779.     {
  2780.         if (ngx_http_post_action(r) == NGX_OK) {
  2781.             return;
  2782.         }

  2784.         ngx_http_terminate_request(r, rc);
  2785.         return;
  2786.     }

  2788.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE
  2789.         || rc == NGX_HTTP_CREATED
  2790.         || rc == NGX_HTTP_NO_CONTENT)
  2791.     {
  2792.         if (rc == NGX_HTTP_CLOSE) {
  2793.             c->timedout = 1;
  2794.             ngx_http_terminate_request(r, rc);
  2795.             return;
  2796.         }

  2798.         if (r == r->main) {
  2799.             if (c->read->timer_set) {
  2800.                 ngx_del_timer(c->read);
  2801.             }

  2803.             if (c->write->timer_set) {
  2804.                 ngx_del_timer(c->write);
  2805.             }
  2806.         }

  2808.         c->read->handler = ngx_http_request_handler;
  2809.         c->write->handler = ngx_http_request_handler;

  2811.         ngx_http_finalize_request(r, ngx_http_special_response_handler(r, rc));
  2812.         return;
  2813.     }

  2815.     if (r != r->main) {

  2817.         if (r->buffered || r->postponed) {

  2819.             if (ngx_http_set_write_handler(r) != NGX_OK) {
  2820.                 ngx_http_terminate_request(r, 0);
  2821.             }

  2823.             return;
  2824.         }

  2826.         pr = r->parent;

  2828.         if (r == c->data || r->background) {

  2830.             if (!r->logged) {

  2832.                 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2834.                 if (clcf->log_subrequest) {
  2835.                     ngx_http_log_request(r);
  2836.                 }

  2838.                 r->logged = 1;

  2840.             } else {
  2841.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2842.                               "subrequest: \"%V?%V\" logged again",
  2843.                               &r->uri, &r->args);
  2844.             }

  2846.             r->done = 1;

  2848.             if (r->background) {
  2849.                 ngx_http_finalize_connection(r);
  2850.                 return;
  2851.             }

  2853.             r->main->count--;

  2855.             r->write_event_handler = ngx_http_request_empty_handler;

  2857.             if (pr->postponed && pr->postponed->request == r) {
  2858.                 pr->postponed = pr->postponed->next;
  2859.             }

  2861.             c->data = pr;

  2863.         } else {

  2865.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2866.                            "http finalize non-active request: \"%V?%V\"",
  2867.                            &r->uri, &r->args);

  2869.             r->write_event_handler = ngx_http_request_finalizer;

  2871.             if (r->waited) {
  2872.                 r->done = 1;
  2873.             }
  2874.         }

  2876.         if (ngx_http_post_request(pr, NULL) != NGX_OK) {
  2877.             r->main->count++;
  2878.             ngx_http_terminate_request(r, 0);
  2879.             return;
  2880.         }

  2882.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2883.                        "http wake parent request: \"%V?%V\"",
  2884.                        &pr->uri, &pr->args);

  2886.         return;
  2887.     }

  2889.     if (r->buffered || c->buffered || r->postponed) {

  2891.         if (ngx_http_set_write_handler(r) != NGX_OK) {
  2892.             ngx_http_terminate_request(r, 0);
  2893.         }

  2895.         return;
  2896.     }

  2898.     if (r != c->data) {
  2899.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2900.                       "http finalize non-active request: \"%V?%V\"",
  2901.                       &r->uri, &r->args);
  2902.         return;
  2903.     }

  2905.     r->done = 1;

  2907.     r->read_event_handler = ngx_http_block_reading;
  2908.     r->write_event_handler = ngx_http_request_empty_handler;

  2910.     if (!r->post_action) {
  2911.         r->request_complete = 1;
  2912.     }

  2914.     if (ngx_http_post_action(r) == NGX_OK) {
  2915.         return;
  2916.     }

  2918.     if (c->read->timer_set) {
  2919.         ngx_del_timer(c->read);
  2920.     }

  2922.     if (c->write->timer_set) {
  2923.         c->write->delayed = 0;
  2924.         ngx_del_timer(c->write);
  2925.     }

  2927.     ngx_http_finalize_connection(r);
  2928. }


  2931. static void
  2932. ‌ngx_http_terminate_request(ngx_http_request_t *r, ngx_int_t rc)
  2933. {
  2934.     ngx_http_cleanup_t    *cln;
  2935.     ngx_http_request_t    *mr;
  2936.     ngx_http_ephemeral_t  *e;

  2938.     mr = r->main;

  2940.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2941.                    "http terminate request count:%d", mr->count);

  2943.     mr->terminated = 1;

  2945.     if (rc > 0 && (mr->headers_out.status == 0 || mr->connection->sent == 0)) {
  2946.         mr->headers_out.status = rc;
  2947.     }

  2949.     cln = mr->cleanup;
  2950.     mr->cleanup = NULL;

  2952.     while (cln) {
  2953.         if (cln->handler) {
  2954.             cln->handler(cln->data);
  2955.         }

  2957.         cln = cln->next;
  2958.     }

  2960.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2961.                    "http terminate cleanup count:%d blk:%d",
  2962.                    mr->count, mr->blocked);

  2964.     if (mr->write_event_handler) {

  2966.         if (mr->blocked) {
  2967.             r = r->connection->data;

  2969.             r->connection->error = 1;
  2970.             r->write_event_handler = ngx_http_request_finalizer;

  2972.             return;
  2973.         }

  2975.         e = ngx_http_ephemeral(mr);
  2976.         mr->posted_requests = NULL;
  2977.         mr->write_event_handler = ngx_http_terminate_handler;
  2978.         (void) ngx_http_post_request(mr, &e->terminal_posted_request);
  2979.         return;
  2980.     }

  2982.     ngx_http_close_request(mr, rc);
  2983. }


  2986. static void
  2987. ‌ngx_http_terminate_handler(ngx_http_request_t *r)
  2988. {
  2989.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2990.                    "http terminate handler count:%d", r->count);

  2992.     r->count = 1;

  2994.     ngx_http_close_request(r, 0);
  2995. }


  2998. static void
  2999. ‌ngx_http_finalize_connection(ngx_http_request_t *r)
  3000. {
  3001.     ngx_http_core_loc_conf_t  *clcf;

  3003. #if (NGX_HTTP_V2)
  3004.     if (r->stream) {
  3005.         ngx_http_close_request(r, 0);
  3006.         return;
  3007.     }
  3008. #endif

  3010. #if (NGX_HTTP_V3)
  3011.     if (r->connection->quic) {
  3012.         ngx_http_close_request(r, 0);
  3013.         return;
  3014.     }
  3015. #endif

  3017.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3019.     if (r->main->count != 1) {

  3021.         if (r->discard_body) {
  3022.             r->read_event_handler = ngx_http_discarded_request_body_handler;
  3023.             ngx_add_timer(r->connection->read, clcf->lingering_timeout);

  3025.             if (r->lingering_time == 0) {
  3026.                 r->lingering_time = ngx_time()
  3027.                                       + (time_t) (clcf->lingering_time / 1000);
  3028.             }
  3029.         }

  3031.         ngx_http_close_request(r, 0);
  3032.         return;
  3033.     }

  3035.     r = r->main;

  3037.     if (r->connection->read->eof) {
  3038.         ngx_http_close_request(r, 0);
  3039.         return;
  3040.     }

  3042.     if (r->reading_body) {
  3043.         r->keepalive = 0;
  3044.         r->lingering_close = 1;
  3045.     }

  3047.     if (r->keepalive
  3048.         && clcf->keepalive_min_timeout > 0)
  3049.     {
  3050.         ngx_http_set_keepalive(r);
  3051.         return;
  3052.     }

  3054.     if (!ngx_terminate
  3055.          && !ngx_exiting
  3056.          && r->keepalive
  3057.          && clcf->keepalive_timeout > 0)
  3058.     {
  3059.         ngx_http_set_keepalive(r);
  3060.         return;
  3061.     }

  3063.     if (clcf->lingering_close == NGX_HTTP_LINGERING_ALWAYS
  3064.         || (clcf->lingering_close == NGX_HTTP_LINGERING_ON
  3065.             && (r->lingering_close
  3066.                 || r->header_in->pos < r->header_in->last
  3067.                 || r->connection->read->ready
  3068.                 || r->connection->pipeline)))
  3069.     {
  3070.         ngx_http_set_lingering_close(r->connection);
  3071.         return;
  3072.     }

  3074.     ngx_http_close_request(r, 0);
  3075. }


  3078. static ngx_int_t
  3079. ‌ngx_http_set_write_handler(ngx_http_request_t *r)
  3080. {
  3081.     ngx_event_t               *wev;
  3082.     ngx_http_core_loc_conf_t  *clcf;

  3084.     r->http_state = NGX_HTTP_WRITING_REQUEST_STATE;

  3086.     r->read_event_handler = r->discard_body ?
  3087.                                 ngx_http_discarded_request_body_handler:
  3088.                                 ngx_http_test_reading;
  3089.     r->write_event_handler = ngx_http_writer;

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

  3093.     if (wev->ready && wev->delayed) {
  3094.         return NGX_OK;
  3095.     }

  3097.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  3098.     if (!wev->delayed) {
  3099.         ngx_add_timer(wev, clcf->send_timeout);
  3100.     }

  3102.     if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3103.         ngx_http_close_request(r, 0);
  3104.         return NGX_ERROR;
  3105.     }

  3107.     return NGX_OK;
  3108. }


  3111. static void
  3112. ‌ngx_http_writer(ngx_http_request_t *r)
  3113. {
  3114.     ngx_int_t                  rc;
  3115.     ngx_event_t               *wev;
  3116.     ngx_connection_t          *c;
  3117.     ngx_http_core_loc_conf_t  *clcf;

  3119.     c = r->connection;
  3120.     wev = c->write;

  3122.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, wev->log, 0,
  3123.                    "http writer handler: \"%V?%V\"", &r->uri, &r->args);

  3125.     clcf = ngx_http_get_module_loc_conf(r->main, ngx_http_core_module);

  3127.     if (wev->timedout) {
  3128.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  3129.                       "client timed out");
  3130.         c->timedout = 1;

  3132.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  3133.         return;
  3134.     }

  3136.     if (wev->delayed || r->aio) {
  3137.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0,
  3138.                        "http writer delayed");

  3140.         if (!wev->delayed) {
  3141.             ngx_add_timer(wev, clcf->send_timeout);
  3142.         }

  3144.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3145.             ngx_http_close_request(r, 0);
  3146.         }

  3148.         return;
  3149.     }

  3151.     rc = ngx_http_output_filter(r, NULL);

  3153.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3154.                    "http writer output filter: %i, \"%V?%V\"",
  3155.                    rc, &r->uri, &r->args);

  3157.     if (rc == NGX_ERROR) {
  3158.         ngx_http_finalize_request(r, rc);
  3159.         return;
  3160.     }

  3162.     if (r->buffered || r->postponed || (r == r->main && c->buffered)) {

  3164.         if (!wev->delayed) {
  3165.             ngx_add_timer(wev, clcf->send_timeout);
  3166.         }

  3168.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3169.             ngx_http_close_request(r, 0);
  3170.         }

  3172.         return;
  3173.     }

  3175.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, wev->log, 0,
  3176.                    "http writer done: \"%V?%V\"", &r->uri, &r->args);

  3178.     r->write_event_handler = ngx_http_request_empty_handler;

  3180.     ngx_http_finalize_request(r, rc);
  3181. }


  3184. static void
  3185. ‌ngx_http_request_finalizer(ngx_http_request_t *r)
  3186. {
  3187.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3188.                    "http finalizer done: \"%V?%V\"", &r->uri, &r->args);

  3190.     ngx_http_finalize_request(r, 0);
  3191. }


  3194. void
  3195. ‌ngx_http_block_reading(ngx_http_request_t *r)
  3196. {
  3197.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3198.                    "http reading blocked");

  3200.     /* aio does not call this handler */

  3202.     if ((ngx_event_flags & NGX_USE_LEVEL_EVENT)
  3203.         && r->connection->read->active)
  3204.     {
  3205.         if (ngx_del_event(r->connection->read, NGX_READ_EVENT, 0) != NGX_OK) {
  3206.             ngx_http_close_request(r, 0);
  3207.         }
  3208.     }
  3209. }


  3212. void
  3213. ‌ngx_http_test_reading(ngx_http_request_t *r)
  3214. {
  3215.     int                n;
  3216.     char               buf[1];
  3217.     ngx_err_t          err;
  3218.     ngx_event_t       *rev;
  3219.     ngx_connection_t  *c;

  3221.     c = r->connection;
  3222.     rev = c->read;

  3224.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http test reading");

  3226. #if (NGX_HTTP_V2)

  3228.     if (r->stream) {
  3229.         if (c->error) {
  3230.             err = 0;
  3231.             goto closed;
  3232.         }

  3234.         return;
  3235.     }

  3237. #endif

  3239. #if (NGX_HTTP_V3)

  3241.     if (c->quic) {
  3242.         if (rev->error) {
  3243.             c->error = 1;
  3244.             err = 0;
  3245.             goto closed;
  3246.         }

  3248.         return;
  3249.     }

  3251. #endif

  3253. #if (NGX_HAVE_KQUEUE)

  3255.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  3257.         if (!rev->pending_eof) {
  3258.             return;
  3259.         }

  3261.         rev->eof = 1;
  3262.         c->error = 1;
  3263.         err = rev->kq_errno;

  3265.         goto closed;
  3266.     }

  3268. #endif

  3270. #if (NGX_HAVE_EPOLLRDHUP)

  3272.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  3273.         socklen_t  len;

  3275.         if (!rev->pending_eof) {
  3276.             return;
  3277.         }

  3279.         rev->eof = 1;
  3280.         c->error = 1;

  3282.         err = 0;
  3283.         len = sizeof(ngx_err_t);

  3285.         /*
  3286.          * BSDs and Linux return 0 and set a pending error in err
  3287.          * Solaris returns -1 and sets errno
  3288.          */

  3290.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  3291.             == -1)
  3292.         {
  3293.             err = ngx_socket_errno;
  3294.         }

  3296.         goto closed;
  3297.     }

  3299. #endif

  3301.     n = recv(c->fd, buf, 1, MSG_PEEK);

  3303.     if (n == 0) {
  3304.         rev->eof = 1;
  3305.         c->error = 1;
  3306.         err = 0;

  3308.         goto closed;

  3310.     } else if (n == -1) {
  3311.         err = ngx_socket_errno;

  3313.         if (err != NGX_EAGAIN) {
  3314.             rev->eof = 1;
  3315.             c->error = 1;

  3317.             goto closed;
  3318.         }
  3319.     }

  3321.     /* aio does not call this handler */

  3323.     if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && rev->active) {

  3325.         if (ngx_del_event(rev, NGX_READ_EVENT, 0) != NGX_OK) {
  3326.             ngx_http_close_request(r, 0);
  3327.         }
  3328.     }

  3330.     return;

  3332. closed:

  3334.     if (err) {
  3335.         rev->error = 1;
  3336.     }

  3338. #if (NGX_HTTP_SSL)
  3339.     if (c->ssl) {
  3340.         c->ssl->no_send_shutdown = 1;
  3341.     }
  3342. #endif

  3344.     ngx_log_error(NGX_LOG_INFO, c->log, err,
  3345.                   "client prematurely closed connection");

  3347.     ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  3348. }


  3351. static void
  3352. ‌ngx_http_set_keepalive(ngx_http_request_t *r)
  3353. {
  3354.     int                        tcp_nodelay;
  3355.     ngx_buf_t                 *b, *f;
  3356.     ngx_chain_t               *cl, *ln;
  3357.     ngx_event_t               *rev, *wev;
  3358.     ngx_connection_t          *c;
  3359.     ngx_http_connection_t     *hc;
  3360.     ngx_http_core_loc_conf_t  *clcf;

  3362.     c = r->connection;
  3363.     rev = c->read;

  3365.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3367.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "set http keepalive handler");

  3369.     c->log->action = "closing request";

  3371.     hc = r->http_connection;
  3372.     b = r->header_in;

  3374.     if (b->pos < b->last) {

  3376.         /* the pipelined request */

  3378.         if (b != c->buffer) {

  3380.             /*
  3381.              * If the large header buffers were allocated while the previous
  3382.              * request processing then we do not use c->buffer for
  3383.              * the pipelined request (see ngx_http_create_request()).
  3384.              *
  3385.              * Now we would move the large header buffers to the free list.
  3386.              */

  3388.             for (cl = hc->busy; cl; /* void */) {
  3389.                 ln = cl;
  3390.                 cl = cl->next;

  3392.                 if (ln->buf == b) {
  3393.                     ngx_free_chain(c->pool, ln);
  3394.                     continue;
  3395.                 }

  3397.                 f = ln->buf;
  3398.                 f->pos = f->start;
  3399.                 f->last = f->start;

  3401.                 ln->next = hc->free;
  3402.                 hc->free = ln;
  3403.             }

  3405.             cl = ngx_alloc_chain_link(c->pool);
  3406.             if (cl == NULL) {
  3407.                 ngx_http_close_request(r, 0);
  3408.                 return;
  3409.             }

  3411.             cl->buf = b;
  3412.             cl->next = NULL;

  3414.             hc->busy = cl;
  3415.             hc->nbusy = 1;
  3416.         }
  3417.     }

  3419.     /* guard against recursive call from ngx_http_finalize_connection() */
  3420.     r->keepalive = 0;

  3422.     ngx_http_free_request(r, 0);

  3424.     c->data = hc;

  3426.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3427.         ngx_http_close_connection(c);
  3428.         return;
  3429.     }

  3431.     wev = c->write;
  3432.     wev->handler = ngx_http_empty_handler;

  3434.     if (b->pos < b->last) {

  3436.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "pipelined request");

  3438.         c->log->action = "reading client pipelined request line";

  3440.         r = ngx_http_create_request(c);
  3441.         if (r == NULL) {
  3442.             ngx_http_close_connection(c);
  3443.             return;
  3444.         }

  3446.         r->pipeline = 1;

  3448.         c->data = r;

  3450.         c->sent = 0;
  3451.         c->destroyed = 0;
  3452.         c->pipeline = 1;

  3454.         if (rev->timer_set) {
  3455.             ngx_del_timer(rev);
  3456.         }

  3458.         rev->handler = ngx_http_process_request_line;
  3459.         ngx_post_event(rev, &ngx_posted_events);
  3460.         return;
  3461.     }

  3463.     /*
  3464.      * To keep a memory footprint as small as possible for an idle keepalive
  3465.      * connection we try to free c->buffer's memory if it was allocated outside
  3466.      * the c->pool.  The large header buffers are always allocated outside the
  3467.      * c->pool and are freed too.
  3468.      */

  3470.     b = c->buffer;

  3472.     if (ngx_pfree(c->pool, b->start) == NGX_OK) {

  3474.         /*
  3475.          * the special note for ngx_http_keepalive_handler() that
  3476.          * c->buffer's memory was freed
  3477.          */

  3479.         b->pos = NULL;

  3481.     } else {
  3482.         b->pos = b->start;
  3483.         b->last = b->start;
  3484.     }

  3486.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, "hc free: %p",
  3487.                    hc->free);

  3489.     if (hc->free) {
  3490.         for (cl = hc->free; cl; /* void */) {
  3491.             ln = cl;
  3492.             cl = cl->next;
  3493.             ngx_pfree(c->pool, ln->buf->start);
  3494.             ngx_free_chain(c->pool, ln);
  3495.         }

  3497.         hc->free = NULL;
  3498.     }

  3500.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, "hc busy: %p %i",
  3501.                    hc->busy, hc->nbusy);

  3503.     if (hc->busy) {
  3504.         for (cl = hc->busy; cl; /* void */) {
  3505.             ln = cl;
  3506.             cl = cl->next;
  3507.             ngx_pfree(c->pool, ln->buf->start);
  3508.             ngx_free_chain(c->pool, ln);
  3509.         }

  3511.         hc->busy = NULL;
  3512.         hc->nbusy = 0;
  3513.     }

  3515. #if (NGX_HTTP_SSL)
  3516.     if (c->ssl) {
  3517.         ngx_ssl_free_buffer(c);
  3518.     }
  3519. #endif

  3521.     rev->handler = ngx_http_keepalive_handler;

  3523.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3524.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3525.             ngx_http_close_connection(c);
  3526.             return;
  3527.         }
  3528.     }

  3530.     c->log->action = "keepalive";

  3532.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  3533.         if (ngx_tcp_push(c->fd) == -1) {
  3534.             ngx_connection_error(c, ngx_socket_errno, ngx_tcp_push_n " failed");
  3535.             ngx_http_close_connection(c);
  3536.             return;
  3537.         }

  3539.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  3540.         tcp_nodelay = ngx_tcp_nodelay_and_tcp_nopush ? 1 : 0;

  3542.     } else {
  3543.         tcp_nodelay = 1;
  3544.     }

  3546.     if (tcp_nodelay && clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  3547.         ngx_http_close_connection(c);
  3548.         return;
  3549.     }

  3551. #if 0
  3552.     /* if ngx_http_request_t was freed then we need some other place */
  3553.     r->http_state = NGX_HTTP_KEEPALIVE_STATE;
  3554. #endif

  3556.     if (clcf->keepalive_min_timeout == 0) {
  3557.         c->idle = 1;
  3558.         ngx_reusable_connection(c, 1);
  3559.     }

  3561.     if (clcf->keepalive_min_timeout > 0
  3562.         && clcf->keepalive_timeout > clcf->keepalive_min_timeout)
  3563.     {
  3564.         hc->keepalive_timeout = clcf->keepalive_timeout
  3565.                                 - clcf->keepalive_min_timeout;

  3567.     } else {
  3568.         hc->keepalive_timeout = 0;
  3569.     }

  3571.     ngx_add_timer(rev, clcf->keepalive_timeout - hc->keepalive_timeout);

  3573.     if (rev->ready) {
  3574.         ngx_post_event(rev, &ngx_posted_events);
  3575.     }
  3576. }


  3579. static void
  3580. ‌ngx_http_keepalive_handler(ngx_event_t *rev)
  3581. {
  3582.     size_t                  size;
  3583.     ssize_t                 n;
  3584.     ngx_buf_t              *b;
  3585.     ngx_connection_t       *c;
  3586.     ngx_http_connection_t  *hc;

  3588.     c = rev->data;
  3589.     hc = c->data;

  3591.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http keepalive handler");

  3593.     if (!ngx_terminate
  3594.          && !ngx_exiting
  3595.          && rev->timedout
  3596.          && hc->keepalive_timeout > 0)
  3597.     {
  3598.         c->idle = 1;
  3599.         ngx_reusable_connection(c, 1);

  3601.         ngx_add_timer(rev, hc->keepalive_timeout);

  3603.         hc->keepalive_timeout = 0;
  3604.         rev->timedout = 0;
  3605.         return;
  3606.     }

  3608.     if (rev->timedout || c->close) {
  3609.         ngx_http_close_connection(c);
  3610.         return;
  3611.     }

  3613. #if (NGX_HAVE_KQUEUE)

  3615.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  3616.         if (rev->pending_eof) {
  3617.             c->log->handler = NULL;
  3618.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  3619.                           "kevent() reported that client %V closed "
  3620.                           "keepalive connection", &c->addr_text);
  3621. #if (NGX_HTTP_SSL)
  3622.             if (c->ssl) {
  3623.                 c->ssl->no_send_shutdown = 1;
  3624.             }
  3625. #endif
  3626.             ngx_http_close_connection(c);
  3627.             return;
  3628.         }
  3629.     }

  3631. #endif

  3633.     b = c->buffer;
  3634.     size = b->end - b->start;

  3636.     if (b->pos == NULL) {

  3638.         /*
  3639.          * The c->buffer's memory was freed by ngx_http_set_keepalive().
  3640.          * However, the c->buffer->start and c->buffer->end were not changed
  3641.          * to keep the buffer size.
  3642.          */

  3644.         b->pos = ngx_palloc(c->pool, size);
  3645.         if (b->pos == NULL) {
  3646.             ngx_http_close_connection(c);
  3647.             return;
  3648.         }

  3650.         b->start = b->pos;
  3651.         b->last = b->pos;
  3652.         b->end = b->pos + size;
  3653.     }

  3655.     /*
  3656.      * MSIE closes a keepalive connection with RST flag
  3657.      * so we ignore ECONNRESET here.
  3658.      */

  3660.     c->log_error = NGX_ERROR_IGNORE_ECONNRESET;
  3661.     ngx_set_socket_errno(0);

  3663.     n = c->recv(c, b->last, size);
  3664.     c->log_error = NGX_ERROR_INFO;

  3666.     if (n == NGX_AGAIN) {
  3667.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3668.             ngx_http_close_connection(c);
  3669.             return;
  3670.         }

  3672.         /*
  3673.          * Like ngx_http_set_keepalive() we are trying to not hold
  3674.          * c->buffer's memory for a keepalive connection.
  3675.          */

  3677.         if (ngx_pfree(c->pool, b->start) == NGX_OK) {

  3679.             /*
  3680.              * the special note that c->buffer's memory was freed
  3681.              */

  3683.             b->pos = NULL;
  3684.         }

  3686.         return;
  3687.     }

  3689.     if (n == NGX_ERROR) {
  3690.         ngx_http_close_connection(c);
  3691.         return;
  3692.     }

  3694.     c->log->handler = NULL;

  3696.     if (n == 0) {
  3697.         ngx_log_error(NGX_LOG_INFO, c->log, ngx_socket_errno,
  3698.                       "client %V closed keepalive connection", &c->addr_text);
  3699.         ngx_http_close_connection(c);
  3700.         return;
  3701.     }

  3703.     b->last += n;

  3705.     c->log->handler = ngx_http_log_error;
  3706.     c->log->action = "reading client request line";

  3708.     c->idle = 0;
  3709.     ngx_reusable_connection(c, 0);

  3711.     c->data = ngx_http_create_request(c);
  3712.     if (c->data == NULL) {
  3713.         ngx_http_close_connection(c);
  3714.         return;
  3715.     }

  3717.     c->sent = 0;
  3718.     c->destroyed = 0;

  3720.     ngx_del_timer(rev);

  3722.     rev->handler = ngx_http_process_request_line;
  3723.     ngx_http_process_request_line(rev);
  3724. }


  3727. static void
  3728. ‌ngx_http_set_lingering_close(ngx_connection_t *c)
  3729. {
  3730.     ngx_event_t               *rev, *wev;
  3731.     ngx_http_request_t        *r;
  3732.     ngx_http_core_loc_conf_t  *clcf;

  3734.     r = c->data;

  3736.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3738.     if (r->lingering_time == 0) {
  3739.         r->lingering_time = ngx_time() + (time_t) (clcf->lingering_time / 1000);
  3740.     }

  3742. #if (NGX_HTTP_SSL)
  3743.     if (c->ssl) {
  3744.         ngx_int_t  rc;

  3746.         c->ssl->shutdown_without_free = 1;

  3748.         rc = ngx_ssl_shutdown(c);

  3750.         if (rc == NGX_ERROR) {
  3751.             ngx_http_close_request(r, 0);
  3752.             return;
  3753.         }

  3755.         if (rc == NGX_AGAIN) {
  3756.             c->ssl->handler = ngx_http_set_lingering_close;
  3757.             return;
  3758.         }
  3759.     }
  3760. #endif

  3762.     rev = c->read;
  3763.     rev->handler = ngx_http_lingering_close_handler;

  3765.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3766.         ngx_http_close_request(r, 0);
  3767.         return;
  3768.     }

  3770.     wev = c->write;
  3771.     wev->handler = ngx_http_empty_handler;

  3773.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3774.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3775.             ngx_http_close_request(r, 0);
  3776.             return;
  3777.         }
  3778.     }

  3780.     if (ngx_shutdown_socket(c->fd, NGX_WRITE_SHUTDOWN) == -1) {
  3781.         ngx_connection_error(c, ngx_socket_errno,
  3782.                              ngx_shutdown_socket_n " failed");
  3783.         ngx_http_close_request(r, 0);
  3784.         return;
  3785.     }

  3787.     c->close = 0;
  3788.     ngx_reusable_connection(c, 1);

  3790.     ngx_add_timer(rev, clcf->lingering_timeout);

  3792.     if (rev->ready) {
  3793.         ngx_http_lingering_close_handler(rev);
  3794.     }
  3795. }


  3798. static void
  3799. ‌ngx_http_lingering_close_handler(ngx_event_t *rev)
  3800. {
  3801.     ssize_t                    n;
  3802.     ngx_msec_t                 timer;
  3803.     ngx_connection_t          *c;
  3804.     ngx_http_request_t        *r;
  3805.     ngx_http_core_loc_conf_t  *clcf;
  3806.     u_char                     buffer[NGX_HTTP_LINGERING_BUFFER_SIZE];

  3808.     c = rev->data;
  3809.     r = c->data;

  3811.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3812.                    "http lingering close handler");

  3814.     if (rev->timedout || c->close) {
  3815.         ngx_http_close_request(r, 0);
  3816.         return;
  3817.     }

  3819.     timer = (ngx_msec_t) r->lingering_time - (ngx_msec_t) ngx_time();
  3820.     if ((ngx_msec_int_t) timer <= 0) {
  3821.         ngx_http_close_request(r, 0);
  3822.         return;
  3823.     }

  3825.     do {
  3826.         n = c->recv(c, buffer, NGX_HTTP_LINGERING_BUFFER_SIZE);

  3828.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, "lingering read: %z", n);

  3830.         if (n == NGX_AGAIN) {
  3831.             break;
  3832.         }

  3834.         if (n == NGX_ERROR || n == 0) {
  3835.             ngx_http_close_request(r, 0);
  3836.             return;
  3837.         }

  3839.     } while (rev->ready);

  3841.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3842.         ngx_http_close_request(r, 0);
  3843.         return;
  3844.     }

  3846.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3848.     timer *= 1000;

  3850.     if (timer > clcf->lingering_timeout) {
  3851.         timer = clcf->lingering_timeout;
  3852.     }

  3854.     ngx_add_timer(rev, timer);
  3855. }


  3858. void
  3859. ‌ngx_http_empty_handler(ngx_event_t *wev)
  3860. {
  3861.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0, "http empty handler");

  3863.     return;
  3864. }


  3867. void
  3868. ‌ngx_http_request_empty_handler(ngx_http_request_t *r)
  3869. {
  3870.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3871.                    "http request empty handler");

  3873.     return;
  3874. }


  3877. ngx_int_t
  3878. ‌ngx_http_send_special(ngx_http_request_t *r, ngx_uint_t flags)
  3879. {
  3880.     ngx_buf_t    *b;
  3881.     ngx_chain_t   out;

  3883.     b = ngx_calloc_buf(r->pool);
  3884.     if (b == NULL) {
  3885.         return NGX_ERROR;
  3886.     }

  3888.     if (flags & NGX_HTTP_LAST) {

  3890.         if (r == r->main && !r->post_action) {
  3891.             b->last_buf = 1;

  3893.         } else {
  3894.             b->sync = 1;
  3895.             b->last_in_chain = 1;
  3896.         }
  3897.     }

  3899.     if (flags & NGX_HTTP_FLUSH) {
  3900.         b->flush = 1;
  3901.     }

  3903.     out.buf = b;
  3904.     out.next = NULL;

  3906.     return ngx_http_output_filter(r, &out);
  3907. }


  3910. static ngx_int_t
  3911. ‌ngx_http_post_action(ngx_http_request_t *r)
  3912. {
  3913.     ngx_http_core_loc_conf_t  *clcf;

  3915.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3917.     if (clcf->post_action.data == NULL) {
  3918.         return NGX_DECLINED;
  3919.     }

  3921.     if (r->post_action && r->uri_changes == 0) {
  3922.         return NGX_DECLINED;
  3923.     }

  3925.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3926.                    "post action: \"%V\"", &clcf->post_action);

  3928.     r->main->count--;

  3930.     r->http_version = NGX_HTTP_VERSION_9;
  3931.     r->header_only = 1;
  3932.     r->post_action = 1;

  3934.     r->read_event_handler = ngx_http_block_reading;

  3936.     if (clcf->post_action.data[0] == '/') {
  3937.         ngx_http_internal_redirect(r, &clcf->post_action, NULL);

  3939.     } else {
  3940.         ngx_http_named_location(r, &clcf->post_action);
  3941.     }

  3943.     return NGX_OK;
  3944. }


  3947. void
  3948. ‌ngx_http_close_request(ngx_http_request_t *r, ngx_int_t rc)
  3949. {
  3950.     ngx_connection_t  *c;

  3952.     r = r->main;
  3953.     c = r->connection;

  3955.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3956.                    "http request count:%d blk:%d", r->count, r->blocked);

  3958.     if (r->count == 0) {
  3959.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "http request count is zero");
  3960.     }

  3962.     r->count--;

  3964.     if (r->count || r->blocked) {
  3965.         return;
  3966.     }

  3968. #if (NGX_HTTP_V2)
  3969.     if (r->stream) {
  3970.         ngx_http_v2_close_stream(r->stream, rc);
  3971.         return;
  3972.     }
  3973. #endif

  3975.     ngx_http_free_request(r, rc);
  3976.     ngx_http_close_connection(c);
  3977. }


  3980. void
  3981. ‌ngx_http_free_request(ngx_http_request_t *r, ngx_int_t rc)
  3982. {
  3983.     ngx_log_t                 *log;
  3984.     ngx_pool_t                *pool;
  3985.     struct linger              linger;
  3986.     ngx_http_cleanup_t        *cln;
  3987.     ngx_http_log_ctx_t        *ctx;
  3988.     ngx_http_core_loc_conf_t  *clcf;

  3990.     log = r->connection->log;

  3992.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0, "http close request");

  3994.     if (r->pool == NULL) {
  3995.         ngx_log_error(NGX_LOG_ALERT, log, 0, "http request already closed");
  3996.         return;
  3997.     }

  3999.     cln = r->cleanup;
  4000.     r->cleanup = NULL;

  4002.     while (cln) {
  4003.         if (cln->handler) {
  4004.             cln->handler(cln->data);
  4005.         }

  4007.         cln = cln->next;
  4008.     }

  4010. #if (NGX_STAT_STUB)

  4012.     if (r->stat_reading) {
  4013.         (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  4014.     }

  4016.     if (r->stat_writing) {
  4017.         (void) ngx_atomic_fetch_add(ngx_stat_writing, -1);
  4018.     }

  4020. #endif

  4022.     if (rc > 0 && (r->headers_out.status == 0 || r->connection->sent == 0)) {
  4023.         r->headers_out.status = rc;
  4024.     }

  4026.     if (!r->logged) {
  4027.         log->action = "logging request";

  4029.         ngx_http_log_request(r);
  4030.     }

  4032.     log->action = "closing request";

  4034.     if (r->connection->timedout
  4035. #if (NGX_HTTP_V3)
  4036.         && r->connection->quic == NULL
  4037. #endif
  4038.        )
  4039.     {
  4040.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4042.         if (clcf->reset_timedout_connection) {
  4043.             linger.l_onoff = 1;
  4044.             linger.l_linger = 0;

  4046.             if (setsockopt(r->connection->fd, SOL_SOCKET, SO_LINGER,
  4047.                            (const void *) &linger, sizeof(struct linger)) == -1)
  4048.             {
  4049.                 ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
  4050.                               "setsockopt(SO_LINGER) failed");
  4051.             }
  4052.         }
  4053.     }

  4055.     /* the various request strings were allocated from r->pool */
  4056.     ctx = log->data;
  4057.     ctx->request = NULL;

  4059.     r->request_line.len = 0;

  4061.     r->connection->destroyed = 1;

  4063.     /*
  4064.      * Setting r->pool to NULL will increase probability to catch double close
  4065.      * of request since the request object is allocated from its own pool.
  4066.      */

  4068.     pool = r->pool;
  4069.     r->pool = NULL;

  4071.     ngx_destroy_pool(pool);
  4072. }


  4075. static void
  4076. ‌ngx_http_log_request(ngx_http_request_t *r)
  4077. {
  4078.     ngx_uint_t                  i, n;
  4079.     ngx_http_handler_pt        *log_handler;
  4080.     ngx_http_core_main_conf_t  *cmcf;

  4082.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  4084.     log_handler = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.elts;
  4085.     n = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.nelts;

  4087.     for (i = 0; i < n; i++) {
  4088.         log_handler[i](r);
  4089.     }
  4090. }


  4093. void
  4094. ‌ngx_http_close_connection(ngx_connection_t *c)
  4095. {
  4096.     ngx_pool_t  *pool;

  4098.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  4099.                    "close http connection: %d", c->fd);

  4101. #if (NGX_HTTP_SSL)

  4103.     if (c->ssl) {
  4104.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  4105.             c->ssl->handler = ngx_http_close_connection;
  4106.             return;
  4107.         }
  4108.     }

  4110. #endif

  4112. #if (NGX_HTTP_V3)
  4113.     if (c->quic) {
  4114.         ngx_http_v3_reset_stream(c);
  4115.     }
  4116. #endif

  4118. #if (NGX_STAT_STUB)
  4119.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  4120. #endif

  4122.     c->destroyed = 1;

  4124.     pool = c->pool;

  4126.     ngx_close_connection(c);

  4128.     ngx_destroy_pool(pool);
  4129. }


  4132. static u_char *
  4133. ‌ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len)
  4134. {
  4135.     u_char              *p;
  4136.     ngx_http_request_t  *r;
  4137.     ngx_http_log_ctx_t  *ctx;

  4139.     if (log->action) {
  4140.         p = ngx_snprintf(buf, len, " while %s", log->action);
  4141.         len -= p - buf;
  4142.         buf = p;
  4143.     }

  4145.     ctx = log->data;

  4147.     p = ngx_snprintf(buf, len, ", client: %V", &ctx->connection->addr_text);
  4148.     len -= p - buf;

  4150.     r = ctx->request;

  4152.     if (r) {
  4153.         return r->log_handler(r, ctx->current_request, p, len);

  4155.     } else {
  4156.         p = ngx_snprintf(p, len, ", server: %V",
  4157.                          &ctx->connection->listening->addr_text);
  4158.     }

  4160.     return p;
  4161. }


  4164. static u_char *
  4165. ‌ngx_http_log_error_handler(ngx_http_request_t *r, ngx_http_request_t *sr,
  4166.     u_char *buf, size_t len)
  4167. {
  4168.     char                      *uri_separator;
  4169.     u_char                    *p;
  4170.     ngx_http_upstream_t       *u;
  4171.     ngx_http_core_srv_conf_t  *cscf;

  4173.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  4175.     p = ngx_snprintf(buf, len, ", server: %V", &cscf->server_name);
  4176.     len -= p - buf;
  4177.     buf = p;

  4179.     if (r->request_line.data == NULL && r->request_start) {
  4180.         for (p = r->request_start; p < r->header_in->last; p++) {
  4181.             if (*p == CR || *p == LF) {
  4182.                 break;
  4183.             }
  4184.         }

  4186.         r->request_line.len = p - r->request_start;
  4187.         r->request_line.data = r->request_start;
  4188.     }

  4190.     if (r->request_line.len) {
  4191.         p = ngx_snprintf(buf, len, ", request: \"%V\"", &r->request_line);
  4192.         len -= p - buf;
  4193.         buf = p;
  4194.     }

  4196.     if (r != sr) {
  4197.         p = ngx_snprintf(buf, len, ", subrequest: \"%V\"", &sr->uri);
  4198.         len -= p - buf;
  4199.         buf = p;
  4200.     }

  4202.     u = sr->upstream;

  4204.     if (u && u->peer.name) {

  4206.         uri_separator = "";

  4208. #if (NGX_HAVE_UNIX_DOMAIN)
  4209.         if (u->peer.sockaddr && u->peer.sockaddr->sa_family == AF_UNIX) {
  4210.             uri_separator = ":";
  4211.         }
  4212. #endif

  4214.         p = ngx_snprintf(buf, len, ", upstream: \"%V%V%s%V\"",
  4215.                          &u->schema, u->peer.name,
  4216.                          uri_separator, &u->uri);
  4217.         len -= p - buf;
  4218.         buf = p;
  4219.     }

  4221.     if (r->headers_in.host) {
  4222.         p = ngx_snprintf(buf, len, ", host: \"%V\"",
  4223.                          &r->headers_in.host->value);
  4224.         len -= p - buf;
  4225.         buf = p;
  4226.     }

  4228.     if (r->headers_in.referer) {
  4229.         p = ngx_snprintf(buf, len, ", referrer: \"%V\"",
  4230.                          &r->headers_in.referer->value);
  4231.         buf = p;
  4232.     }

  4234.     return buf;
  4235. }

One Level Up Top Level