One Level Up Top Level

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

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_find_virtual_server(ngx_connection_t *c,
  36.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  37.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp);

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

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

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

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


  64. ‌static char *ngx_http_client_errors[] = {

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

  231.     c->data = hc;

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

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

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

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

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

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

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

  256.             addr6 = port->addrs;

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

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

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

  268.             break;
  269. #endif

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

  274.             addr = port->addrs;

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

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

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

  286.             break;
  287.         }

  289.     } else {

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

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

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

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

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

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

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

  325.     c->log_error = NGX_ERROR_INFO;

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

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

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

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

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

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

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

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

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

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


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

  389.     c = rev->data;

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

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

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

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

  407.     size = cscf->client_header_buffer_size;

  409.     b = c->buffer;

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

  418.         c->buffer = b;

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

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

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

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

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

  437.     if (n == NGX_AGAIN) {

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

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

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

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

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

  461.         return;
  462.     }

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

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

  476.     b->last += n;

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

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

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

  488.         b->pos = p;

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

  499. #if (NGX_HTTP_V2)

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

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

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

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

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

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

  520. #endif

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

  524.     ngx_reusable_connection(c, 0);

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

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


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

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

  549.     c->requests++;

  551.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

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

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

  565.     return r;
  566. }


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

  579.     hc = c->data;

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

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

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

  594.     r->pool = pool;

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

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

  604.     r->read_event_handler = ngx_http_block_reading;

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

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

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

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

  630.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

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

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

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

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

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

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

  663.     r->http_state = NGX_HTTP_READING_REQUEST_STATE;

  665.     r->log_handler = ngx_http_log_error_handler;

  667.     return r;
  668. }


  671. #if (NGX_HTTP_SSL)

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

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

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

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

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

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

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

  708.     err = ngx_socket_errno;

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

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

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

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

  727.             return;
  728.         }

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

  733.         return;
  734.     }

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

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

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

  746.         size = p - buf;

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

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

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

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

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

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

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

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

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

  787.             ngx_reusable_connection(c, 0);

  789.             rc = ngx_ssl_handshake(c);

  791.             if (rc == NGX_AGAIN) {

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

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

  803.             ngx_http_ssl_handshake_handler(c);

  805.             return;
  806.         }

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

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

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

  815.         return;
  816.     }

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


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

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

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

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

  846.         hc = c->data;

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

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

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

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

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

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

  867.         ngx_reusable_connection(c, 1);

  869.         ngx_http_wait_request_handler(c->read);

  871.         return;
  872.     }

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

  878.     ngx_http_close_connection(c);
  879. }


  882. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  896.     c = ngx_ssl_get_connection(ssl_conn);

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

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

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

  912.     hc = c->data;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  969.     *hc->ssl_servername = host;

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

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

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

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

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

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

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

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

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

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

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

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

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

  1017. done:

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

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

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

  1030. error:

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

  1036. #endif


  1039. #ifdef SSL_R_CERT_CB_ERROR

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

  1051.     c = ngx_ssl_get_connection(ssl_conn);

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

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

  1062.     r->logged = 1;

  1064.     sscf = arg;

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

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

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

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

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

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

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

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

  1100. failed:

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

  1108. #endif

  1110. #endif


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

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

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

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

  1136.     rc = NGX_AGAIN;

  1138.     for ( ;; ) {

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

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

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

  1150.         if (rc == NGX_OK) {

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

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

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

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

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

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

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

  1177.             if (r->host_end) {

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

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

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

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

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

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

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

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

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


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

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

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

  1231.             break;
  1232.         }

  1234.         if (rc != NGX_AGAIN) {

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

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

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

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

  1248.             break;
  1249.         }

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

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

  1255.             rv = ngx_http_alloc_large_header_buffer(r, 1);

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

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

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

  1274.     ngx_http_run_posted_requests(c);
  1275. }


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

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

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

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

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

  1301.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

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

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

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

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

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

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

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

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

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

  1343.     while (p < last) {

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

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

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

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

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

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

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

  1375.         break;
  1376.     }

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

  1383.     }
  1384. #endif

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

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

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

  1395.     return NGX_OK;
  1396. }


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

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

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

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

  1426.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  1428.     rc = NGX_AGAIN;

  1430.     for ( ;; ) {

  1432.         if (rc == NGX_AGAIN) {

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

  1436.                 rv = ngx_http_alloc_large_header_buffer(r, 0);

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

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

  1446.                     r->lingering_close = 1;

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

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

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

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

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

  1472.             n = ngx_http_read_request_header(r);

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

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

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

  1485.         if (rc == NGX_OK) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1551.             continue;
  1552.         }

  1554.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

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

  1563.             r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  1565.             rc = ngx_http_process_request_header(r);

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

  1571.             ngx_http_process_request(r);

  1573.             break;
  1574.         }

  1576.         if (rc == NGX_AGAIN) {

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

  1580.             continue;
  1581.         }

  1583.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

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

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

  1594.     ngx_http_run_posted_requests(c);
  1595. }


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

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

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

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

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

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

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

  1633.         return NGX_AGAIN;
  1634.     }

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

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

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

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

  1651.     return n;
  1652. }


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

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

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

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

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

  1675.         return NGX_OK;
  1676.     }

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

  1680.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  1689.     hc = r->http_connection;

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

  1695.         b = cl->buf;

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

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

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

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

  1714.         cl->buf = b;

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

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

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

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

  1735.         r->header_in = b;

  1737.         return NGX_OK;
  1738.     }

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

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

  1749.     new = b->start;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1817.     r->header_in = b;

  1819.     return NGX_OK;
  1820. }


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

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

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

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

  1836.     return NGX_OK;
  1837. }


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

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

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

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

  1859.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);

  1861.     return NGX_ERROR;
  1862. }


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

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

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

  1886.     host = h->value;

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

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

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

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

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

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

  1913.     return NGX_OK;
  1914. }


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

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

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

  1932.     return NGX_OK;
  1933. }


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

  1947.     return NGX_OK;
  1948. }


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

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

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

  1963.     user_agent = h->value.data;

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

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

  1969.         r->headers_in.msie = 1;

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

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

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

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

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

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

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

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

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

  2018.     return NGX_OK;
  2019. }


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

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

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

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

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

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

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

  2076.             r->headers_in.chunked = 1;

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

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

  2095.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

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

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

  2120.     return NGX_OK;
  2121. }


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

  2129.     c = r->connection;

  2131. #if (NGX_HTTP_SSL)

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

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

  2146.         sscf = ngx_http_get_module_srv_conf(r, ngx_http_ssl_module);

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

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

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

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

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

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

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

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

  2179.                 X509_free(cert);
  2180.             }

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

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

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

  2195. #endif

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

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

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

  2212.     ngx_http_handler(r);
  2213. }


  2216. ngx_int_t
  2217. ‌ngx_http_validate_host(ngx_str_t *host, in_port_t *portp, ngx_pool_t *pool,
  2218.     ngx_uint_t alloc)
  2219. {
  2220.     u_char     *h, ch;
  2221.     size_t      i, dot_pos, host_len;
  2222.     ngx_int_t   port;

  2224. ‌    enum {
  2225.         sw_host_start = 0,
  2226.         sw_host,
  2227.         sw_host_ip_literal,
  2228.         sw_host_end,
  2229.         sw_port,
  2230.     } state;

  2232.     dot_pos = host->len;
  2233.     host_len = host->len;
  2234.     port = 0;

  2236.     h = host->data;

  2238.     state = sw_host_start;

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

  2243.         switch (state) {

  2245.         case sw_host_start:

  2247.             if (ch == '[') {
  2248.                 state = sw_host_ip_literal;
  2249.                 break;
  2250.             }

  2252.             state = sw_host;

  2254.             /* fall through */

  2256.         case sw_host:

  2258.             if (ch >= 'A' && ch <= 'Z') {
  2259.                 alloc = 1;
  2260.                 break;
  2261.             }

  2263.             if (ch >= 'a' && ch <= 'z') {
  2264.                 break;
  2265.             }

  2267.             if (ch >= '0' && ch <= '9') {
  2268.                 break;
  2269.             }

  2271.             switch (ch) {
  2272.             case ':':
  2273.                 host_len = i;
  2274.                 state = sw_port;
  2275.                 break;
  2276.             case '-':
  2277.                 break;
  2278.             case '.':
  2279.                 if (dot_pos == i - 1) {
  2280.                     return NGX_DECLINED;
  2281.                 }
  2282.                 dot_pos = i;
  2283.                 break;
  2284.             case '_':
  2285.             case '~':
  2286.                 /* unreserved */
  2287.                 break;
  2288.             case '!':
  2289.             case '$':
  2290.             case '&':
  2291.             case '\'':
  2292.             case '(':
  2293.             case ')':
  2294.             case '*':
  2295.             case '+':
  2296.             case ',':
  2297.             case ';':
  2298.             case '=':
  2299.                 /* sub-delims */
  2300.                 break;
  2301.             case '%':
  2302.                 /* pct-encoded */
  2303.                 break;
  2304.             default:
  2305.                 return NGX_DECLINED;
  2306.             }
  2307.             break;

  2309.         case sw_host_ip_literal:

  2311.             if (ch >= 'A' && ch <= 'Z') {
  2312.                 alloc = 1;
  2313.                 break;
  2314.             }

  2316.             if (ch >= 'a' && ch <= 'z') {
  2317.                 break;
  2318.             }

  2320.             if (ch >= '0' && ch <= '9') {
  2321.                 break;
  2322.             }

  2324.             switch (ch) {
  2325.             case ':':
  2326.                 break;
  2327.             case ']':
  2328.                 host_len = i + 1;
  2329.                 state = sw_host_end;
  2330.                 break;
  2331.             case '-':
  2332.                 break;
  2333.             case '.':
  2334.                 if (dot_pos == i - 1) {
  2335.                     return NGX_DECLINED;
  2336.                 }
  2337.                 dot_pos = i;
  2338.                 break;
  2339.             case '_':
  2340.             case '~':
  2341.                 /* unreserved */
  2342.                 break;
  2343.             case '!':
  2344.             case '$':
  2345.             case '&':
  2346.             case '\'':
  2347.             case '(':
  2348.             case ')':
  2349.             case '*':
  2350.             case '+':
  2351.             case ',':
  2352.             case ';':
  2353.             case '=':
  2354.                 /* sub-delims */
  2355.                 break;
  2356.             default:
  2357.                 return NGX_DECLINED;
  2358.             }
  2359.             break;

  2361.         case sw_host_end:

  2363.             if (ch == ':') {
  2364.                 state = sw_port;
  2365.                 break;
  2366.             }
  2367.             return NGX_DECLINED;

  2369.         case sw_port:

  2371.             if (ch >= '0' && ch <= '9') {
  2372.                 if (port >= 6553 && (port > 6553 || (ch - '0') > 5)) {
  2373.                     return NGX_DECLINED;
  2374.                 }

  2376.                 port = port * 10 + (ch - '0');
  2377.                 break;
  2378.             }
  2379.             return NGX_DECLINED;
  2380.         }
  2381.     }

  2383.     if (state == sw_host_ip_literal) {
  2384.         return NGX_DECLINED;
  2385.     }

  2387.     if (dot_pos == host_len - 1) {
  2388.         host_len--;
  2389.     }

  2391.     if (host_len == 0) {
  2392.         return NGX_DECLINED;
  2393.     }

  2395.     if (alloc) {
  2396.         host->data = ngx_pnalloc(pool, host_len);
  2397.         if (host->data == NULL) {
  2398.             return NGX_ERROR;
  2399.         }

  2401.         ngx_strlow(host->data, h, host_len);
  2402.     }

  2404.     host->len = host_len;

  2406.     if (portp) {
  2407.         *portp = port;
  2408.     }

  2410.     return NGX_OK;
  2411. }


  2414. ngx_int_t
  2415. ‌ngx_http_set_virtual_server(ngx_http_request_t *r, ngx_str_t *host)
  2416. {
  2417.     ngx_int_t                  rc;
  2418.     ngx_http_connection_t     *hc;
  2419.     ngx_http_core_loc_conf_t  *clcf;
  2420.     ngx_http_core_srv_conf_t  *cscf;

  2422. #if (NGX_SUPPRESS_WARN)
  2423.     cscf = NULL;
  2424. #endif

  2426.     hc = r->http_connection;

  2428. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2430.     if (hc->ssl_servername) {
  2431.         if (hc->ssl_servername->len == host->len
  2432.             && ngx_strncmp(hc->ssl_servername->data,
  2433.                            host->data, host->len) == 0)
  2434.         {
  2435. #if (NGX_PCRE)
  2436.             if (hc->ssl_servername_regex
  2437.                 && ngx_http_regex_exec(r, hc->ssl_servername_regex,
  2438.                                           hc->ssl_servername) != NGX_OK)
  2439.             {
  2440.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2441.                 return NGX_ERROR;
  2442.             }
  2443. #endif
  2444.             return NGX_OK;
  2445.         }
  2446.     }

  2448. #endif

  2450.     rc = ngx_http_find_virtual_server(r->connection,
  2451.                                       hc->addr_conf->virtual_names,
  2452.                                       host, r, &cscf);

  2454.     if (rc == NGX_ERROR) {
  2455.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2456.         return NGX_ERROR;
  2457.     }

  2459. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2461.     if (hc->ssl_servername) {
  2462.         ngx_http_ssl_srv_conf_t  *sscf;

  2464.         if (rc == NGX_DECLINED) {
  2465.             cscf = hc->addr_conf->default_server;
  2466.             rc = NGX_OK;
  2467.         }

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

  2471.         if (sscf->verify) {
  2472.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2473.                           "client attempted to request the server name "
  2474.                           "different from the one that was negotiated");
  2475.             ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  2476.             return NGX_ERROR;
  2477.         }
  2478.     }

  2480. #endif

  2482.     if (rc == NGX_DECLINED) {
  2483.         return NGX_OK;
  2484.     }

  2486.     r->srv_conf = cscf->ctx->srv_conf;
  2487.     r->loc_conf = cscf->ctx->loc_conf;

  2489.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  2493.     return NGX_OK;
  2494. }


  2497. static ngx_int_t
  2498. ‌ngx_http_find_virtual_server(ngx_connection_t *c,
  2499.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  2500.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp)
  2501. {
  2502.     ngx_http_core_srv_conf_t  *cscf;

  2504.     if (virtual_names == NULL) {
  2505.         return NGX_DECLINED;
  2506.     }

  2508.     cscf = ngx_hash_find_combined(&virtual_names->names,
  2509.                                   ngx_hash_key(host->data, host->len),
  2510.                                   host->data, host->len);

  2512.     if (cscf) {
  2513.         *cscfp = cscf;
  2514.         return NGX_OK;
  2515.     }

  2517. #if (NGX_PCRE)

  2519.     if (host->len && virtual_names->nregex) {
  2520.         ngx_int_t                n;
  2521.         ngx_uint_t               i;
  2522.         ngx_http_server_name_t  *sn;

  2524.         sn = virtual_names->regex;

  2526. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2528.         if (r == NULL) {
  2529.             ngx_http_connection_t  *hc;

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

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

  2535.                 if (n == NGX_REGEX_NO_MATCHED) {
  2536.                     continue;
  2537.                 }

  2539.                 if (n >= 0) {
  2540.                     hc = c->data;
  2541.                     hc->ssl_servername_regex = sn[i].regex;

  2543.                     *cscfp = sn[i].server;
  2544.                     return NGX_OK;
  2545.                 }

  2547.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2548.                               ngx_regex_exec_n " failed: %i "
  2549.                               "on \"%V\" using \"%V\"",
  2550.                               n, host, &sn[i].regex->name);

  2552.                 return NGX_ERROR;
  2553.             }

  2555.             return NGX_DECLINED;
  2556.         }

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

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

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

  2564.             if (n == NGX_DECLINED) {
  2565.                 continue;
  2566.             }

  2568.             if (n == NGX_OK) {
  2569.                 *cscfp = sn[i].server;
  2570.                 return NGX_OK;
  2571.             }

  2573.             return NGX_ERROR;
  2574.         }
  2575.     }

  2577. #endif /* NGX_PCRE */

  2579.     return NGX_DECLINED;
  2580. }


  2583. static void
  2584. ‌ngx_http_request_handler(ngx_event_t *ev)
  2585. {
  2586.     ngx_connection_t    *c;
  2587.     ngx_http_request_t  *r;

  2589.     c = ev->data;
  2590.     r = c->data;

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

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

  2597.     if (c->close) {
  2598.         r->main->count++;
  2599.         ngx_http_terminate_request(r, 0);
  2600.         ngx_http_run_posted_requests(c);
  2601.         return;
  2602.     }

  2604.     if (ev->delayed && ev->timedout) {
  2605.         ev->delayed = 0;
  2606.         ev->timedout = 0;
  2607.     }

  2609.     if (ev->write) {
  2610.         r->write_event_handler(r);

  2612.     } else {
  2613.         r->read_event_handler(r);
  2614.     }

  2616.     ngx_http_run_posted_requests(c);
  2617. }


  2620. void
  2621. ‌ngx_http_run_posted_requests(ngx_connection_t *c)
  2622. {
  2623.     ngx_http_request_t         *r;
  2624.     ngx_http_posted_request_t  *pr;

  2626.     for ( ;; ) {

  2628.         if (c->destroyed) {
  2629.             return;
  2630.         }

  2632.         r = c->data;
  2633.         pr = r->main->posted_requests;

  2635.         if (pr == NULL) {
  2636.             return;
  2637.         }

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

  2641.         r = pr->request;

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

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

  2648.         r->write_event_handler(r);
  2649.     }
  2650. }


  2653. ngx_int_t
  2654. ‌ngx_http_post_request(ngx_http_request_t *r, ngx_http_posted_request_t *pr)
  2655. {
  2656.     ngx_http_posted_request_t  **p;

  2658.     for (p = &r->main->posted_requests; *p; p = &(*p)->next) {
  2659.         if ((*p)->request == r) {
  2660.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2661.                            "http request already posted");
  2662.             return NGX_OK;
  2663.         }
  2664.     }

  2666.     if (pr == NULL) {
  2667.         pr = ngx_palloc(r->pool, sizeof(ngx_http_posted_request_t));
  2668.         if (pr == NULL) {
  2669.             return NGX_ERROR;
  2670.         }
  2671.     }

  2673.     pr->request = r;
  2674.     pr->next = NULL;

  2676.     *p = pr;

  2678.     return NGX_OK;
  2679. }


  2682. void
  2683. ‌ngx_http_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2684. {
  2685.     ngx_connection_t          *c;
  2686.     ngx_http_request_t        *pr;
  2687.     ngx_http_core_loc_conf_t  *clcf;

  2689.     c = r->connection;

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

  2695.     if (rc == NGX_DONE) {
  2696.         ngx_http_finalize_connection(r);
  2697.         return;
  2698.     }

  2700.     if (rc == NGX_OK && r->filter_finalize) {
  2701.         c->error = 1;
  2702.     }

  2704.     if (rc == NGX_DECLINED) {
  2705.         r->content_handler = NULL;
  2706.         r->write_event_handler = ngx_http_core_run_phases;
  2707.         ngx_http_core_run_phases(r);
  2708.         return;
  2709.     }

  2711.     if (r != r->main && r->post_subrequest) {
  2712.         rc = r->post_subrequest->handler(r, r->post_subrequest->data, rc);
  2713.     }

  2715.     if (rc == NGX_ERROR
  2716.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  2717.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST
  2718.         || c->error)
  2719.     {
  2720.         if (ngx_http_post_action(r) == NGX_OK) {
  2721.             return;
  2722.         }

  2724.         ngx_http_terminate_request(r, rc);
  2725.         return;
  2726.     }

  2728.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE
  2729.         || rc == NGX_HTTP_CREATED
  2730.         || rc == NGX_HTTP_NO_CONTENT)
  2731.     {
  2732.         if (rc == NGX_HTTP_CLOSE) {
  2733.             c->timedout = 1;
  2734.             ngx_http_terminate_request(r, rc);
  2735.             return;
  2736.         }

  2738.         if (r == r->main) {
  2739.             if (c->read->timer_set) {
  2740.                 ngx_del_timer(c->read);
  2741.             }

  2743.             if (c->write->timer_set) {
  2744.                 ngx_del_timer(c->write);
  2745.             }
  2746.         }

  2748.         c->read->handler = ngx_http_request_handler;
  2749.         c->write->handler = ngx_http_request_handler;

  2751.         ngx_http_finalize_request(r, ngx_http_special_response_handler(r, rc));
  2752.         return;
  2753.     }

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

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

  2759.             if (ngx_http_set_write_handler(r) != NGX_OK) {
  2760.                 ngx_http_terminate_request(r, 0);
  2761.             }

  2763.             return;
  2764.         }

  2766.         pr = r->parent;

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

  2770.             if (!r->logged) {

  2772.                 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2774.                 if (clcf->log_subrequest) {
  2775.                     ngx_http_log_request(r);
  2776.                 }

  2778.                 r->logged = 1;

  2780.             } else {
  2781.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2782.                               "subrequest: \"%V?%V\" logged again",
  2783.                               &r->uri, &r->args);
  2784.             }

  2786.             r->done = 1;

  2788.             if (r->background) {
  2789.                 ngx_http_finalize_connection(r);
  2790.                 return;
  2791.             }

  2793.             r->main->count--;

  2795.             r->write_event_handler = ngx_http_request_empty_handler;

  2797.             if (pr->postponed && pr->postponed->request == r) {
  2798.                 pr->postponed = pr->postponed->next;
  2799.             }

  2801.             c->data = pr;

  2803.         } else {

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

  2809.             r->write_event_handler = ngx_http_request_finalizer;

  2811.             if (r->waited) {
  2812.                 r->done = 1;
  2813.             }
  2814.         }

  2816.         if (ngx_http_post_request(pr, NULL) != NGX_OK) {
  2817.             r->main->count++;
  2818.             ngx_http_terminate_request(r, 0);
  2819.             return;
  2820.         }

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

  2826.         return;
  2827.     }

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

  2831.         if (ngx_http_set_write_handler(r) != NGX_OK) {
  2832.             ngx_http_terminate_request(r, 0);
  2833.         }

  2835.         return;
  2836.     }

  2838.     if (r != c->data) {
  2839.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2840.                       "http finalize non-active request: \"%V?%V\"",
  2841.                       &r->uri, &r->args);
  2842.         return;
  2843.     }

  2845.     r->done = 1;

  2847.     r->read_event_handler = ngx_http_block_reading;
  2848.     r->write_event_handler = ngx_http_request_empty_handler;

  2850.     if (!r->post_action) {
  2851.         r->request_complete = 1;
  2852.     }

  2854.     if (ngx_http_post_action(r) == NGX_OK) {
  2855.         return;
  2856.     }

  2858.     if (c->read->timer_set) {
  2859.         ngx_del_timer(c->read);
  2860.     }

  2862.     if (c->write->timer_set) {
  2863.         c->write->delayed = 0;
  2864.         ngx_del_timer(c->write);
  2865.     }

  2867.     ngx_http_finalize_connection(r);
  2868. }


  2871. static void
  2872. ‌ngx_http_terminate_request(ngx_http_request_t *r, ngx_int_t rc)
  2873. {
  2874.     ngx_http_cleanup_t    *cln;
  2875.     ngx_http_request_t    *mr;
  2876.     ngx_http_ephemeral_t  *e;

  2878.     mr = r->main;

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

  2883.     mr->terminated = 1;

  2885.     if (rc > 0 && (mr->headers_out.status == 0 || mr->connection->sent == 0)) {
  2886.         mr->headers_out.status = rc;
  2887.     }

  2889.     cln = mr->cleanup;
  2890.     mr->cleanup = NULL;

  2892.     while (cln) {
  2893.         if (cln->handler) {
  2894.             cln->handler(cln->data);
  2895.         }

  2897.         cln = cln->next;
  2898.     }

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

  2904.     if (mr->write_event_handler) {

  2906.         if (mr->blocked) {
  2907.             r = r->connection->data;

  2909.             r->connection->error = 1;
  2910.             r->write_event_handler = ngx_http_request_finalizer;

  2912.             return;
  2913.         }

  2915.         e = ngx_http_ephemeral(mr);
  2916.         mr->posted_requests = NULL;
  2917.         mr->write_event_handler = ngx_http_terminate_handler;
  2918.         (void) ngx_http_post_request(mr, &e->terminal_posted_request);
  2919.         return;
  2920.     }

  2922.     ngx_http_close_request(mr, rc);
  2923. }


  2926. static void
  2927. ‌ngx_http_terminate_handler(ngx_http_request_t *r)
  2928. {
  2929.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2930.                    "http terminate handler count:%d", r->count);

  2932.     r->count = 1;

  2934.     ngx_http_close_request(r, 0);
  2935. }


  2938. static void
  2939. ‌ngx_http_finalize_connection(ngx_http_request_t *r)
  2940. {
  2941.     ngx_http_core_loc_conf_t  *clcf;

  2943. #if (NGX_HTTP_V2)
  2944.     if (r->stream) {
  2945.         ngx_http_close_request(r, 0);
  2946.         return;
  2947.     }
  2948. #endif

  2950. #if (NGX_HTTP_V3)
  2951.     if (r->connection->quic) {
  2952.         ngx_http_close_request(r, 0);
  2953.         return;
  2954.     }
  2955. #endif

  2957.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  2961.         if (r->discard_body) {
  2962.             r->read_event_handler = ngx_http_discarded_request_body_handler;
  2963.             ngx_add_timer(r->connection->read, clcf->lingering_timeout);

  2965.             if (r->lingering_time == 0) {
  2966.                 r->lingering_time = ngx_time()
  2967.                                       + (time_t) (clcf->lingering_time / 1000);
  2968.             }
  2969.         }

  2971.         ngx_http_close_request(r, 0);
  2972.         return;
  2973.     }

  2975.     r = r->main;

  2977.     if (r->connection->read->eof) {
  2978.         ngx_http_close_request(r, 0);
  2979.         return;
  2980.     }

  2982.     if (r->reading_body) {
  2983.         r->keepalive = 0;
  2984.         r->lingering_close = 1;
  2985.     }

  2987.     if (r->keepalive
  2988.         && clcf->keepalive_min_timeout > 0)
  2989.     {
  2990.         ngx_http_set_keepalive(r);
  2991.         return;
  2992.     }

  2994.     if (!ngx_terminate
  2995.          && !ngx_exiting
  2996.          && r->keepalive
  2997.          && clcf->keepalive_timeout > 0)
  2998.     {
  2999.         ngx_http_set_keepalive(r);
  3000.         return;
  3001.     }

  3003.     if (clcf->lingering_close == NGX_HTTP_LINGERING_ALWAYS
  3004.         || (clcf->lingering_close == NGX_HTTP_LINGERING_ON
  3005.             && (r->lingering_close
  3006.                 || r->header_in->pos < r->header_in->last
  3007.                 || r->connection->read->ready
  3008.                 || r->connection->pipeline)))
  3009.     {
  3010.         ngx_http_set_lingering_close(r->connection);
  3011.         return;
  3012.     }

  3014.     ngx_http_close_request(r, 0);
  3015. }


  3018. static ngx_int_t
  3019. ‌ngx_http_set_write_handler(ngx_http_request_t *r)
  3020. {
  3021.     ngx_event_t               *wev;
  3022.     ngx_http_core_loc_conf_t  *clcf;

  3024.     r->http_state = NGX_HTTP_WRITING_REQUEST_STATE;

  3026.     r->read_event_handler = r->discard_body ?
  3027.                                 ngx_http_discarded_request_body_handler:
  3028.                                 ngx_http_test_reading;
  3029.     r->write_event_handler = ngx_http_writer;

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

  3033.     if (wev->ready && wev->delayed) {
  3034.         return NGX_OK;
  3035.     }

  3037.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  3038.     if (!wev->delayed) {
  3039.         ngx_add_timer(wev, clcf->send_timeout);
  3040.     }

  3042.     if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3043.         ngx_http_close_request(r, 0);
  3044.         return NGX_ERROR;
  3045.     }

  3047.     return NGX_OK;
  3048. }


  3051. static void
  3052. ‌ngx_http_writer(ngx_http_request_t *r)
  3053. {
  3054.     ngx_int_t                  rc;
  3055.     ngx_event_t               *wev;
  3056.     ngx_connection_t          *c;
  3057.     ngx_http_core_loc_conf_t  *clcf;

  3059.     c = r->connection;
  3060.     wev = c->write;

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

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

  3067.     if (wev->timedout) {
  3068.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  3069.                       "client timed out");
  3070.         c->timedout = 1;

  3072.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  3073.         return;
  3074.     }

  3076.     if (wev->delayed || r->aio) {
  3077.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0,
  3078.                        "http writer delayed");

  3080.         if (!wev->delayed) {
  3081.             ngx_add_timer(wev, clcf->send_timeout);
  3082.         }

  3084.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3085.             ngx_http_close_request(r, 0);
  3086.         }

  3088.         return;
  3089.     }

  3091.     rc = ngx_http_output_filter(r, NULL);

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

  3097.     if (rc == NGX_ERROR) {
  3098.         ngx_http_finalize_request(r, rc);
  3099.         return;
  3100.     }

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

  3104.         if (!wev->delayed) {
  3105.             ngx_add_timer(wev, clcf->send_timeout);
  3106.         }

  3108.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3109.             ngx_http_close_request(r, 0);
  3110.         }

  3112.         return;
  3113.     }

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

  3118.     r->write_event_handler = ngx_http_request_empty_handler;

  3120.     ngx_http_finalize_request(r, rc);
  3121. }


  3124. static void
  3125. ‌ngx_http_request_finalizer(ngx_http_request_t *r)
  3126. {
  3127.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3128.                    "http finalizer done: \"%V?%V\"", &r->uri, &r->args);

  3130.     ngx_http_finalize_request(r, 0);
  3131. }


  3134. void
  3135. ‌ngx_http_block_reading(ngx_http_request_t *r)
  3136. {
  3137.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3138.                    "http reading blocked");

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

  3142.     if ((ngx_event_flags & NGX_USE_LEVEL_EVENT)
  3143.         && r->connection->read->active)
  3144.     {
  3145.         if (ngx_del_event(r->connection->read, NGX_READ_EVENT, 0) != NGX_OK) {
  3146.             ngx_http_close_request(r, 0);
  3147.         }
  3148.     }
  3149. }


  3152. void
  3153. ‌ngx_http_test_reading(ngx_http_request_t *r)
  3154. {
  3155.     int                n;
  3156.     char               buf[1];
  3157.     ngx_err_t          err;
  3158.     ngx_event_t       *rev;
  3159.     ngx_connection_t  *c;

  3161.     c = r->connection;
  3162.     rev = c->read;

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

  3166. #if (NGX_HTTP_V2)

  3168.     if (r->stream) {
  3169.         if (c->error) {
  3170.             err = 0;
  3171.             goto closed;
  3172.         }

  3174.         return;
  3175.     }

  3177. #endif

  3179. #if (NGX_HTTP_V3)

  3181.     if (c->quic) {
  3182.         if (rev->error) {
  3183.             c->error = 1;
  3184.             err = 0;
  3185.             goto closed;
  3186.         }

  3188.         return;
  3189.     }

  3191. #endif

  3193. #if (NGX_HAVE_KQUEUE)

  3195.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  3197.         if (!rev->pending_eof) {
  3198.             return;
  3199.         }

  3201.         rev->eof = 1;
  3202.         c->error = 1;
  3203.         err = rev->kq_errno;

  3205.         goto closed;
  3206.     }

  3208. #endif

  3210. #if (NGX_HAVE_EPOLLRDHUP)

  3212.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  3213.         socklen_t  len;

  3215.         if (!rev->pending_eof) {
  3216.             return;
  3217.         }

  3219.         rev->eof = 1;
  3220.         c->error = 1;

  3222.         err = 0;
  3223.         len = sizeof(ngx_err_t);

  3225.         /*
  3226.          * BSDs and Linux return 0 and set a pending error in err
  3227.          * Solaris returns -1 and sets errno
  3228.          */

  3230.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  3231.             == -1)
  3232.         {
  3233.             err = ngx_socket_errno;
  3234.         }

  3236.         goto closed;
  3237.     }

  3239. #endif

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

  3243.     if (n == 0) {
  3244.         rev->eof = 1;
  3245.         c->error = 1;
  3246.         err = 0;

  3248.         goto closed;

  3250.     } else if (n == -1) {
  3251.         err = ngx_socket_errno;

  3253.         if (err != NGX_EAGAIN) {
  3254.             rev->eof = 1;
  3255.             c->error = 1;

  3257.             goto closed;
  3258.         }
  3259.     }

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

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

  3265.         if (ngx_del_event(rev, NGX_READ_EVENT, 0) != NGX_OK) {
  3266.             ngx_http_close_request(r, 0);
  3267.         }
  3268.     }

  3270.     return;

  3272. closed:

  3274.     if (err) {
  3275.         rev->error = 1;
  3276.     }

  3278. #if (NGX_HTTP_SSL)
  3279.     if (c->ssl) {
  3280.         c->ssl->no_send_shutdown = 1;
  3281.     }
  3282. #endif

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

  3287.     ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  3288. }


  3291. static void
  3292. ‌ngx_http_set_keepalive(ngx_http_request_t *r)
  3293. {
  3294.     int                        tcp_nodelay;
  3295.     ngx_buf_t                 *b, *f;
  3296.     ngx_chain_t               *cl, *ln;
  3297.     ngx_event_t               *rev, *wev;
  3298.     ngx_connection_t          *c;
  3299.     ngx_http_connection_t     *hc;
  3300.     ngx_http_core_loc_conf_t  *clcf;

  3302.     c = r->connection;
  3303.     rev = c->read;

  3305.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

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

  3311.     hc = r->http_connection;
  3312.     b = r->header_in;

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

  3316.         /* the pipelined request */

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

  3320.             /*
  3321.              * If the large header buffers were allocated while the previous
  3322.              * request processing then we do not use c->buffer for
  3323.              * the pipelined request (see ngx_http_create_request()).
  3324.              *
  3325.              * Now we would move the large header buffers to the free list.
  3326.              */

  3328.             for (cl = hc->busy; cl; /* void */) {
  3329.                 ln = cl;
  3330.                 cl = cl->next;

  3332.                 if (ln->buf == b) {
  3333.                     ngx_free_chain(c->pool, ln);
  3334.                     continue;
  3335.                 }

  3337.                 f = ln->buf;
  3338.                 f->pos = f->start;
  3339.                 f->last = f->start;

  3341.                 ln->next = hc->free;
  3342.                 hc->free = ln;
  3343.             }

  3345.             cl = ngx_alloc_chain_link(c->pool);
  3346.             if (cl == NULL) {
  3347.                 ngx_http_close_request(r, 0);
  3348.                 return;
  3349.             }

  3351.             cl->buf = b;
  3352.             cl->next = NULL;

  3354.             hc->busy = cl;
  3355.             hc->nbusy = 1;
  3356.         }
  3357.     }

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

  3362.     ngx_http_free_request(r, 0);

  3364.     c->data = hc;

  3366.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3367.         ngx_http_close_connection(c);
  3368.         return;
  3369.     }

  3371.     wev = c->write;
  3372.     wev->handler = ngx_http_empty_handler;

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

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

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

  3380.         r = ngx_http_create_request(c);
  3381.         if (r == NULL) {
  3382.             ngx_http_close_connection(c);
  3383.             return;
  3384.         }

  3386.         r->pipeline = 1;

  3388.         c->data = r;

  3390.         c->sent = 0;
  3391.         c->destroyed = 0;
  3392.         c->pipeline = 1;

  3394.         if (rev->timer_set) {
  3395.             ngx_del_timer(rev);
  3396.         }

  3398.         rev->handler = ngx_http_process_request_line;
  3399.         ngx_post_event(rev, &ngx_posted_events);
  3400.         return;
  3401.     }

  3403.     /*
  3404.      * To keep a memory footprint as small as possible for an idle keepalive
  3405.      * connection we try to free c->buffer's memory if it was allocated outside
  3406.      * the c->pool.  The large header buffers are always allocated outside the
  3407.      * c->pool and are freed too.
  3408.      */

  3410.     b = c->buffer;

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

  3414.         /*
  3415.          * the special note for ngx_http_keepalive_handler() that
  3416.          * c->buffer's memory was freed
  3417.          */

  3419.         b->pos = NULL;

  3421.     } else {
  3422.         b->pos = b->start;
  3423.         b->last = b->start;
  3424.     }

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

  3429.     if (hc->free) {
  3430.         for (cl = hc->free; cl; /* void */) {
  3431.             ln = cl;
  3432.             cl = cl->next;
  3433.             ngx_pfree(c->pool, ln->buf->start);
  3434.             ngx_free_chain(c->pool, ln);
  3435.         }

  3437.         hc->free = NULL;
  3438.     }

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

  3443.     if (hc->busy) {
  3444.         for (cl = hc->busy; cl; /* void */) {
  3445.             ln = cl;
  3446.             cl = cl->next;
  3447.             ngx_pfree(c->pool, ln->buf->start);
  3448.             ngx_free_chain(c->pool, ln);
  3449.         }

  3451.         hc->busy = NULL;
  3452.         hc->nbusy = 0;
  3453.     }

  3455. #if (NGX_HTTP_SSL)
  3456.     if (c->ssl) {
  3457.         ngx_ssl_free_buffer(c);
  3458.     }
  3459. #endif

  3461.     rev->handler = ngx_http_keepalive_handler;

  3463.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3464.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3465.             ngx_http_close_connection(c);
  3466.             return;
  3467.         }
  3468.     }

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

  3472.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  3473.         if (ngx_tcp_push(c->fd) == -1) {
  3474.             ngx_connection_error(c, ngx_socket_errno, ngx_tcp_push_n " failed");
  3475.             ngx_http_close_connection(c);
  3476.             return;
  3477.         }

  3479.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  3480.         tcp_nodelay = ngx_tcp_nodelay_and_tcp_nopush ? 1 : 0;

  3482.     } else {
  3483.         tcp_nodelay = 1;
  3484.     }

  3486.     if (tcp_nodelay && clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  3487.         ngx_http_close_connection(c);
  3488.         return;
  3489.     }

  3491. #if 0
  3492.     /* if ngx_http_request_t was freed then we need some other place */
  3493.     r->http_state = NGX_HTTP_KEEPALIVE_STATE;
  3494. #endif

  3496.     if (clcf->keepalive_min_timeout == 0) {
  3497.         c->idle = 1;
  3498.         ngx_reusable_connection(c, 1);
  3499.     }

  3501.     if (clcf->keepalive_min_timeout > 0
  3502.         && clcf->keepalive_timeout > clcf->keepalive_min_timeout)
  3503.     {
  3504.         hc->keepalive_timeout = clcf->keepalive_timeout
  3505.                                 - clcf->keepalive_min_timeout;

  3507.     } else {
  3508.         hc->keepalive_timeout = 0;
  3509.     }

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

  3513.     if (rev->ready) {
  3514.         ngx_post_event(rev, &ngx_posted_events);
  3515.     }
  3516. }


  3519. static void
  3520. ‌ngx_http_keepalive_handler(ngx_event_t *rev)
  3521. {
  3522.     size_t                  size;
  3523.     ssize_t                 n;
  3524.     ngx_buf_t              *b;
  3525.     ngx_connection_t       *c;
  3526.     ngx_http_connection_t  *hc;

  3528.     c = rev->data;
  3529.     hc = c->data;

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

  3533.     if (!ngx_terminate
  3534.          && !ngx_exiting
  3535.          && rev->timedout
  3536.          && hc->keepalive_timeout > 0)
  3537.     {
  3538.         c->idle = 1;
  3539.         ngx_reusable_connection(c, 1);

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

  3543.         hc->keepalive_timeout = 0;
  3544.         rev->timedout = 0;
  3545.         return;
  3546.     }

  3548.     if (rev->timedout || c->close) {
  3549.         ngx_http_close_connection(c);
  3550.         return;
  3551.     }

  3553. #if (NGX_HAVE_KQUEUE)

  3555.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  3556.         if (rev->pending_eof) {
  3557.             c->log->handler = NULL;
  3558.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  3559.                           "kevent() reported that client %V closed "
  3560.                           "keepalive connection", &c->addr_text);
  3561. #if (NGX_HTTP_SSL)
  3562.             if (c->ssl) {
  3563.                 c->ssl->no_send_shutdown = 1;
  3564.             }
  3565. #endif
  3566.             ngx_http_close_connection(c);
  3567.             return;
  3568.         }
  3569.     }

  3571. #endif

  3573.     b = c->buffer;
  3574.     size = b->end - b->start;

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

  3578.         /*
  3579.          * The c->buffer's memory was freed by ngx_http_set_keepalive().
  3580.          * However, the c->buffer->start and c->buffer->end were not changed
  3581.          * to keep the buffer size.
  3582.          */

  3584.         b->pos = ngx_palloc(c->pool, size);
  3585.         if (b->pos == NULL) {
  3586.             ngx_http_close_connection(c);
  3587.             return;
  3588.         }

  3590.         b->start = b->pos;
  3591.         b->last = b->pos;
  3592.         b->end = b->pos + size;
  3593.     }

  3595.     /*
  3596.      * MSIE closes a keepalive connection with RST flag
  3597.      * so we ignore ECONNRESET here.
  3598.      */

  3600.     c->log_error = NGX_ERROR_IGNORE_ECONNRESET;
  3601.     ngx_set_socket_errno(0);

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

  3606.     if (n == NGX_AGAIN) {
  3607.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3608.             ngx_http_close_connection(c);
  3609.             return;
  3610.         }

  3612.         /*
  3613.          * Like ngx_http_set_keepalive() we are trying to not hold
  3614.          * c->buffer's memory for a keepalive connection.
  3615.          */

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

  3619.             /*
  3620.              * the special note that c->buffer's memory was freed
  3621.              */

  3623.             b->pos = NULL;
  3624.         }

  3626.         return;
  3627.     }

  3629.     if (n == NGX_ERROR) {
  3630.         ngx_http_close_connection(c);
  3631.         return;
  3632.     }

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

  3636.     if (n == 0) {
  3637.         ngx_log_error(NGX_LOG_INFO, c->log, ngx_socket_errno,
  3638.                       "client %V closed keepalive connection", &c->addr_text);
  3639.         ngx_http_close_connection(c);
  3640.         return;
  3641.     }

  3643.     b->last += n;

  3645.     c->log->handler = ngx_http_log_error;
  3646.     c->log->action = "reading client request line";

  3648.     c->idle = 0;
  3649.     ngx_reusable_connection(c, 0);

  3651.     c->data = ngx_http_create_request(c);
  3652.     if (c->data == NULL) {
  3653.         ngx_http_close_connection(c);
  3654.         return;
  3655.     }

  3657.     c->sent = 0;
  3658.     c->destroyed = 0;

  3660.     ngx_del_timer(rev);

  3662.     rev->handler = ngx_http_process_request_line;
  3663.     ngx_http_process_request_line(rev);
  3664. }


  3667. static void
  3668. ‌ngx_http_set_lingering_close(ngx_connection_t *c)
  3669. {
  3670.     ngx_event_t               *rev, *wev;
  3671.     ngx_http_request_t        *r;
  3672.     ngx_http_core_loc_conf_t  *clcf;

  3674.     r = c->data;

  3676.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3678.     if (r->lingering_time == 0) {
  3679.         r->lingering_time = ngx_time() + (time_t) (clcf->lingering_time / 1000);
  3680.     }

  3682. #if (NGX_HTTP_SSL)
  3683.     if (c->ssl) {
  3684.         ngx_int_t  rc;

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

  3688.         rc = ngx_ssl_shutdown(c);

  3690.         if (rc == NGX_ERROR) {
  3691.             ngx_http_close_request(r, 0);
  3692.             return;
  3693.         }

  3695.         if (rc == NGX_AGAIN) {
  3696.             c->ssl->handler = ngx_http_set_lingering_close;
  3697.             return;
  3698.         }
  3699.     }
  3700. #endif

  3702.     rev = c->read;
  3703.     rev->handler = ngx_http_lingering_close_handler;

  3705.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3706.         ngx_http_close_request(r, 0);
  3707.         return;
  3708.     }

  3710.     wev = c->write;
  3711.     wev->handler = ngx_http_empty_handler;

  3713.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3714.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3715.             ngx_http_close_request(r, 0);
  3716.             return;
  3717.         }
  3718.     }

  3720.     if (ngx_shutdown_socket(c->fd, NGX_WRITE_SHUTDOWN) == -1) {
  3721.         ngx_connection_error(c, ngx_socket_errno,
  3722.                              ngx_shutdown_socket_n " failed");
  3723.         ngx_http_close_request(r, 0);
  3724.         return;
  3725.     }

  3727.     c->close = 0;
  3728.     ngx_reusable_connection(c, 1);

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

  3732.     if (rev->ready) {
  3733.         ngx_http_lingering_close_handler(rev);
  3734.     }
  3735. }


  3738. static void
  3739. ‌ngx_http_lingering_close_handler(ngx_event_t *rev)
  3740. {
  3741.     ssize_t                    n;
  3742.     ngx_msec_t                 timer;
  3743.     ngx_connection_t          *c;
  3744.     ngx_http_request_t        *r;
  3745.     ngx_http_core_loc_conf_t  *clcf;
  3746.     u_char                     buffer[NGX_HTTP_LINGERING_BUFFER_SIZE];

  3748.     c = rev->data;
  3749.     r = c->data;

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

  3754.     if (rev->timedout || c->close) {
  3755.         ngx_http_close_request(r, 0);
  3756.         return;
  3757.     }

  3759.     timer = (ngx_msec_t) r->lingering_time - (ngx_msec_t) ngx_time();
  3760.     if ((ngx_msec_int_t) timer <= 0) {
  3761.         ngx_http_close_request(r, 0);
  3762.         return;
  3763.     }

  3765.     do {
  3766.         n = c->recv(c, buffer, NGX_HTTP_LINGERING_BUFFER_SIZE);

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

  3770.         if (n == NGX_AGAIN) {
  3771.             break;
  3772.         }

  3774.         if (n == NGX_ERROR || n == 0) {
  3775.             ngx_http_close_request(r, 0);
  3776.             return;
  3777.         }

  3779.     } while (rev->ready);

  3781.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3782.         ngx_http_close_request(r, 0);
  3783.         return;
  3784.     }

  3786.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3788.     timer *= 1000;

  3790.     if (timer > clcf->lingering_timeout) {
  3791.         timer = clcf->lingering_timeout;
  3792.     }

  3794.     ngx_add_timer(rev, timer);
  3795. }


  3798. void
  3799. ‌ngx_http_empty_handler(ngx_event_t *wev)
  3800. {
  3801.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0, "http empty handler");

  3803.     return;
  3804. }


  3807. void
  3808. ‌ngx_http_request_empty_handler(ngx_http_request_t *r)
  3809. {
  3810.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3811.                    "http request empty handler");

  3813.     return;
  3814. }


  3817. ngx_int_t
  3818. ‌ngx_http_send_special(ngx_http_request_t *r, ngx_uint_t flags)
  3819. {
  3820.     ngx_buf_t    *b;
  3821.     ngx_chain_t   out;

  3823.     b = ngx_calloc_buf(r->pool);
  3824.     if (b == NULL) {
  3825.         return NGX_ERROR;
  3826.     }

  3828.     if (flags & NGX_HTTP_LAST) {

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

  3833.         } else {
  3834.             b->sync = 1;
  3835.             b->last_in_chain = 1;
  3836.         }
  3837.     }

  3839.     if (flags & NGX_HTTP_FLUSH) {
  3840.         b->flush = 1;
  3841.     }

  3843.     out.buf = b;
  3844.     out.next = NULL;

  3846.     return ngx_http_output_filter(r, &out);
  3847. }


  3850. static ngx_int_t
  3851. ‌ngx_http_post_action(ngx_http_request_t *r)
  3852. {
  3853.     ngx_http_core_loc_conf_t  *clcf;

  3855.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3857.     if (clcf->post_action.data == NULL) {
  3858.         return NGX_DECLINED;
  3859.     }

  3861.     if (r->post_action && r->uri_changes == 0) {
  3862.         return NGX_DECLINED;
  3863.     }

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

  3868.     r->main->count--;

  3870.     r->http_version = NGX_HTTP_VERSION_9;
  3871.     r->header_only = 1;
  3872.     r->post_action = 1;

  3874.     r->read_event_handler = ngx_http_block_reading;

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

  3879.     } else {
  3880.         ngx_http_named_location(r, &clcf->post_action);
  3881.     }

  3883.     return NGX_OK;
  3884. }


  3887. void
  3888. ‌ngx_http_close_request(ngx_http_request_t *r, ngx_int_t rc)
  3889. {
  3890.     ngx_connection_t  *c;

  3892.     r = r->main;
  3893.     c = r->connection;

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

  3898.     if (r->count == 0) {
  3899.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "http request count is zero");
  3900.     }

  3902.     r->count--;

  3904.     if (r->count || r->blocked) {
  3905.         return;
  3906.     }

  3908. #if (NGX_HTTP_V2)
  3909.     if (r->stream) {
  3910.         ngx_http_v2_close_stream(r->stream, rc);
  3911.         return;
  3912.     }
  3913. #endif

  3915.     ngx_http_free_request(r, rc);
  3916.     ngx_http_close_connection(c);
  3917. }


  3920. void
  3921. ‌ngx_http_free_request(ngx_http_request_t *r, ngx_int_t rc)
  3922. {
  3923.     ngx_log_t                 *log;
  3924.     ngx_pool_t                *pool;
  3925.     struct linger              linger;
  3926.     ngx_http_cleanup_t        *cln;
  3927.     ngx_http_log_ctx_t        *ctx;
  3928.     ngx_http_core_loc_conf_t  *clcf;

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

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

  3934.     if (r->pool == NULL) {
  3935.         ngx_log_error(NGX_LOG_ALERT, log, 0, "http request already closed");
  3936.         return;
  3937.     }

  3939.     cln = r->cleanup;
  3940.     r->cleanup = NULL;

  3942.     while (cln) {
  3943.         if (cln->handler) {
  3944.             cln->handler(cln->data);
  3945.         }

  3947.         cln = cln->next;
  3948.     }

  3950. #if (NGX_STAT_STUB)

  3952.     if (r->stat_reading) {
  3953.         (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  3954.     }

  3956.     if (r->stat_writing) {
  3957.         (void) ngx_atomic_fetch_add(ngx_stat_writing, -1);
  3958.     }

  3960. #endif

  3962.     if (rc > 0 && (r->headers_out.status == 0 || r->connection->sent == 0)) {
  3963.         r->headers_out.status = rc;
  3964.     }

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

  3969.         ngx_http_log_request(r);
  3970.     }

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

  3974.     if (r->connection->timedout
  3975. #if (NGX_HTTP_V3)
  3976.         && r->connection->quic == NULL
  3977. #endif
  3978.        )
  3979.     {
  3980.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3982.         if (clcf->reset_timedout_connection) {
  3983.             linger.l_onoff = 1;
  3984.             linger.l_linger = 0;

  3986.             if (setsockopt(r->connection->fd, SOL_SOCKET, SO_LINGER,
  3987.                            (const void *) &linger, sizeof(struct linger)) == -1)
  3988.             {
  3989.                 ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
  3990.                               "setsockopt(SO_LINGER) failed");
  3991.             }
  3992.         }
  3993.     }

  3995.     /* the various request strings were allocated from r->pool */
  3996.     ctx = log->data;
  3997.     ctx->request = NULL;

  3999.     r->request_line.len = 0;

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

  4003.     /*
  4004.      * Setting r->pool to NULL will increase probability to catch double close
  4005.      * of request since the request object is allocated from its own pool.
  4006.      */

  4008.     pool = r->pool;
  4009.     r->pool = NULL;

  4011.     ngx_destroy_pool(pool);
  4012. }


  4015. static void
  4016. ‌ngx_http_log_request(ngx_http_request_t *r)
  4017. {
  4018.     ngx_uint_t                  i, n;
  4019.     ngx_http_handler_pt        *log_handler;
  4020.     ngx_http_core_main_conf_t  *cmcf;

  4022.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  4024.     log_handler = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.elts;
  4025.     n = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.nelts;

  4027.     for (i = 0; i < n; i++) {
  4028.         log_handler[i](r);
  4029.     }
  4030. }


  4033. void
  4034. ‌ngx_http_close_connection(ngx_connection_t *c)
  4035. {
  4036.     ngx_pool_t  *pool;

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

  4041. #if (NGX_HTTP_SSL)

  4043.     if (c->ssl) {
  4044.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  4045.             c->ssl->handler = ngx_http_close_connection;
  4046.             return;
  4047.         }
  4048.     }

  4050. #endif

  4052. #if (NGX_HTTP_V3)
  4053.     if (c->quic) {
  4054.         ngx_http_v3_reset_stream(c);
  4055.     }
  4056. #endif

  4058. #if (NGX_STAT_STUB)
  4059.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  4060. #endif

  4062.     c->destroyed = 1;

  4064.     pool = c->pool;

  4066.     ngx_close_connection(c);

  4068.     ngx_destroy_pool(pool);
  4069. }


  4072. static u_char *
  4073. ‌ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len)
  4074. {
  4075.     u_char              *p;
  4076.     ngx_http_request_t  *r;
  4077.     ngx_http_log_ctx_t  *ctx;

  4079.     if (log->action) {
  4080.         p = ngx_snprintf(buf, len, " while %s", log->action);
  4081.         len -= p - buf;
  4082.         buf = p;
  4083.     }

  4085.     ctx = log->data;

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

  4090.     r = ctx->request;

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

  4095.     } else {
  4096.         p = ngx_snprintf(p, len, ", server: %V",
  4097.                          &ctx->connection->listening->addr_text);
  4098.     }

  4100.     return p;
  4101. }


  4104. static u_char *
  4105. ‌ngx_http_log_error_handler(ngx_http_request_t *r, ngx_http_request_t *sr,
  4106.     u_char *buf, size_t len)
  4107. {
  4108.     char                      *uri_separator;
  4109.     u_char                    *p;
  4110.     ngx_http_upstream_t       *u;
  4111.     ngx_http_core_srv_conf_t  *cscf;

  4113.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  4115.     p = ngx_snprintf(buf, len, ", server: %V", &cscf->server_name);
  4116.     len -= p - buf;
  4117.     buf = p;

  4119.     if (r->request_line.data == NULL && r->request_start) {
  4120.         for (p = r->request_start; p < r->header_in->last; p++) {
  4121.             if (*p == CR || *p == LF) {
  4122.                 break;
  4123.             }
  4124.         }

  4126.         r->request_line.len = p - r->request_start;
  4127.         r->request_line.data = r->request_start;
  4128.     }

  4130.     if (r->request_line.len) {
  4131.         p = ngx_snprintf(buf, len, ", request: \"%V\"", &r->request_line);
  4132.         len -= p - buf;
  4133.         buf = p;
  4134.     }

  4136.     if (r != sr) {
  4137.         p = ngx_snprintf(buf, len, ", subrequest: \"%V\"", &sr->uri);
  4138.         len -= p - buf;
  4139.         buf = p;
  4140.     }

  4142.     u = sr->upstream;

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

  4146.         uri_separator = "";

  4148. #if (NGX_HAVE_UNIX_DOMAIN)
  4149.         if (u->peer.sockaddr && u->peer.sockaddr->sa_family == AF_UNIX) {
  4150.             uri_separator = ":";
  4151.         }
  4152. #endif

  4154.         p = ngx_snprintf(buf, len, ", upstream: \"%V%V%s%V\"",
  4155.                          &u->schema, u->peer.name,
  4156.                          uri_separator, &u->uri);
  4157.         len -= p - buf;
  4158.         buf = p;
  4159.     }

  4161.     if (r->headers_in.host) {
  4162.         p = ngx_snprintf(buf, len, ", host: \"%V\"",
  4163.                          &r->headers_in.host->value);
  4164.         len -= p - buf;
  4165.         buf = p;
  4166.     }

  4168.     if (r->headers_in.referer) {
  4169.         p = ngx_snprintf(buf, len, ", referrer: \"%V\"",
  4170.                          &r->headers_in.referer->value);
  4171.         buf = p;
  4172.     }

  4174.     return buf;
  4175. }

One Level Up Top Level