One Level Up Top Level

src/http/ngx_http_request.c - nginx source code

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_user_agent(ngx_http_request_t *r,
  30.     ngx_table_elt_t *h, ngx_uint_t offset);

  32. static ngx_int_t ngx_http_find_virtual_server(ngx_connection_t *c,
  33.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  34.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp);

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

  44. static void ngx_http_set_keepalive(ngx_http_request_t *r);
  45. static void ngx_http_keepalive_handler(ngx_event_t *ev);
  46. static void ngx_http_set_lingering_close(ngx_connection_t *c);
  47. static void ngx_http_lingering_close_handler(ngx_event_t *ev);
  48. static ngx_int_t ngx_http_post_action(ngx_http_request_t *r);
  49. static void ngx_http_log_request(ngx_http_request_t *r);

  51. static u_char *ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len);
  52. static u_char *ngx_http_log_error_handler(ngx_http_request_t *r,
  53.     ngx_http_request_t *sr, u_char *buf, size_t len);

  55. #if (NGX_HTTP_SSL)
  56. static void ngx_http_ssl_handshake(ngx_event_t *rev);
  57. static void ngx_http_ssl_handshake_handler(ngx_connection_t *c);
  58. #endif


  61. ‌static char *ngx_http_client_errors[] = {

  63.     /* NGX_HTTP_PARSE_INVALID_METHOD */
  64.     "client sent invalid method",

  66.     /* NGX_HTTP_PARSE_INVALID_REQUEST */
  67.     "client sent invalid request",

  69.     /* NGX_HTTP_PARSE_INVALID_VERSION */
  70.     "client sent invalid version",

  72.     /* NGX_HTTP_PARSE_INVALID_09_METHOD */
  73.     "client sent invalid method in HTTP/0.9 request"
  74. };


  77. ‌ngx_http_header_t  ngx_http_headers_in[] = {
  78.     { ngx_string("Host"), offsetof(ngx_http_headers_in_t, host),
  79.                  ngx_http_process_host },

  81.     { ngx_string("Connection"), offsetof(ngx_http_headers_in_t, connection),
  82.                  ngx_http_process_connection },

  84.     { ngx_string("If-Modified-Since"),
  85.                  offsetof(ngx_http_headers_in_t, if_modified_since),
  86.                  ngx_http_process_unique_header_line },

  88.     { ngx_string("If-Unmodified-Since"),
  89.                  offsetof(ngx_http_headers_in_t, if_unmodified_since),
  90.                  ngx_http_process_unique_header_line },

  92.     { ngx_string("If-Match"),
  93.                  offsetof(ngx_http_headers_in_t, if_match),
  94.                  ngx_http_process_unique_header_line },

  96.     { ngx_string("If-None-Match"),
  97.                  offsetof(ngx_http_headers_in_t, if_none_match),
  98.                  ngx_http_process_unique_header_line },

  100.     { ngx_string("User-Agent"), offsetof(ngx_http_headers_in_t, user_agent),
  101.                  ngx_http_process_user_agent },

  103.     { ngx_string("Referer"), offsetof(ngx_http_headers_in_t, referer),
  104.                  ngx_http_process_header_line },

  106.     { ngx_string("Content-Length"),
  107.                  offsetof(ngx_http_headers_in_t, content_length),
  108.                  ngx_http_process_unique_header_line },

  110.     { ngx_string("Content-Range"),
  111.                  offsetof(ngx_http_headers_in_t, content_range),
  112.                  ngx_http_process_unique_header_line },

  114.     { ngx_string("Content-Type"),
  115.                  offsetof(ngx_http_headers_in_t, content_type),
  116.                  ngx_http_process_header_line },

  118.     { ngx_string("Range"), offsetof(ngx_http_headers_in_t, range),
  119.                  ngx_http_process_header_line },

  121.     { ngx_string("If-Range"),
  122.                  offsetof(ngx_http_headers_in_t, if_range),
  123.                  ngx_http_process_unique_header_line },

  125.     { ngx_string("Transfer-Encoding"),
  126.                  offsetof(ngx_http_headers_in_t, transfer_encoding),
  127.                  ngx_http_process_unique_header_line },

  129.     { ngx_string("TE"),
  130.                  offsetof(ngx_http_headers_in_t, te),
  131.                  ngx_http_process_header_line },

  133.     { ngx_string("Expect"),
  134.                  offsetof(ngx_http_headers_in_t, expect),
  135.                  ngx_http_process_unique_header_line },

  137.     { ngx_string("Upgrade"),
  138.                  offsetof(ngx_http_headers_in_t, upgrade),
  139.                  ngx_http_process_header_line },

  141. #if (NGX_HTTP_GZIP || NGX_HTTP_HEADERS)
  142.     { ngx_string("Accept-Encoding"),
  143.                  offsetof(ngx_http_headers_in_t, accept_encoding),
  144.                  ngx_http_process_header_line },

  146.     { ngx_string("Via"), offsetof(ngx_http_headers_in_t, via),
  147.                  ngx_http_process_header_line },
  148. #endif

  150.     { ngx_string("Authorization"),
  151.                  offsetof(ngx_http_headers_in_t, authorization),
  152.                  ngx_http_process_unique_header_line },

  154.     { ngx_string("Keep-Alive"), offsetof(ngx_http_headers_in_t, keep_alive),
  155.                  ngx_http_process_header_line },

  157. #if (NGX_HTTP_X_FORWARDED_FOR)
  158.     { ngx_string("X-Forwarded-For"),
  159.                  offsetof(ngx_http_headers_in_t, x_forwarded_for),
  160.                  ngx_http_process_header_line },
  161. #endif

  163. #if (NGX_HTTP_REALIP)
  164.     { ngx_string("X-Real-IP"),
  165.                  offsetof(ngx_http_headers_in_t, x_real_ip),
  166.                  ngx_http_process_header_line },
  167. #endif

  169. #if (NGX_HTTP_HEADERS)
  170.     { ngx_string("Accept"), offsetof(ngx_http_headers_in_t, accept),
  171.                  ngx_http_process_header_line },

  173.     { ngx_string("Accept-Language"),
  174.                  offsetof(ngx_http_headers_in_t, accept_language),
  175.                  ngx_http_process_header_line },
  176. #endif

  178. #if (NGX_HTTP_DAV)
  179.     { ngx_string("Depth"), offsetof(ngx_http_headers_in_t, depth),
  180.                  ngx_http_process_header_line },

  182.     { ngx_string("Destination"), offsetof(ngx_http_headers_in_t, destination),
  183.                  ngx_http_process_header_line },

  185.     { ngx_string("Overwrite"), offsetof(ngx_http_headers_in_t, overwrite),
  186.                  ngx_http_process_header_line },

  188.     { ngx_string("Date"), offsetof(ngx_http_headers_in_t, date),
  189.                  ngx_http_process_header_line },
  190. #endif

  192.     { ngx_string("Cookie"), offsetof(ngx_http_headers_in_t, cookie),
  193.                  ngx_http_process_header_line },

  195.     { ngx_null_string, 0, NULL }
  196. };


  199. void
  200. ‌ngx_http_init_connection(ngx_connection_t *c)
  201. {
  202.     ngx_uint_t                 i;
  203.     ngx_event_t               *rev;
  204.     struct sockaddr_in        *sin;
  205.     ngx_http_port_t           *port;
  206.     ngx_http_in_addr_t        *addr;
  207.     ngx_http_log_ctx_t        *ctx;
  208.     ngx_http_connection_t     *hc;
  209.     ngx_http_core_srv_conf_t  *cscf;
  210. #if (NGX_HAVE_INET6)
  211.     struct sockaddr_in6       *sin6;
  212.     ngx_http_in6_addr_t       *addr6;
  213. #endif

  215.     hc = ngx_pcalloc(c->pool, sizeof(ngx_http_connection_t));
  216.     if (hc == NULL) {
  217.         ngx_http_close_connection(c);
  218.         return;
  219.     }

  221.     c->data = hc;

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

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

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

  229.         /*
  230.          * there are several addresses on this port and one of them
  231.          * is an "*:port" wildcard so getsockname() in ngx_http_server_addr()
  232.          * is required to determine a server address
  233.          */

  235.         if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
  236.             ngx_http_close_connection(c);
  237.             return;
  238.         }

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

  242. #if (NGX_HAVE_INET6)
  243.         case AF_INET6:
  244.             sin6 = (struct sockaddr_in6 *) c->local_sockaddr;

  246.             addr6 = port->addrs;

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

  250.             for (i = 0; i < port->naddrs - 1; i++) {
  251.                 if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16) == 0) {
  252.                     break;
  253.                 }
  254.             }

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

  258.             break;
  259. #endif

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

  264.             addr = port->addrs;

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

  268.             for (i = 0; i < port->naddrs - 1; i++) {
  269.                 if (addr[i].addr == sin->sin_addr.s_addr) {
  270.                     break;
  271.                 }
  272.             }

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

  276.             break;
  277.         }

  279.     } else {

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

  283. #if (NGX_HAVE_INET6)
  284.         case AF_INET6:
  285.             addr6 = port->addrs;
  286.             hc->addr_conf = &addr6[0].conf;
  287.             break;
  288. #endif

  290.         default: /* AF_INET */
  291.             addr = port->addrs;
  292.             hc->addr_conf = &addr[0].conf;
  293.             break;
  294.         }
  295.     }

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

  300.     ctx = ngx_palloc(c->pool, sizeof(ngx_http_log_ctx_t));
  301.     if (ctx == NULL) {
  302.         ngx_http_close_connection(c);
  303.         return;
  304.     }

  306.     ctx->connection = c;
  307.     ctx->request = NULL;
  308.     ctx->current_request = NULL;

  310.     c->log->connection = c->number;
  311.     c->log->handler = ngx_http_log_error;
  312.     c->log->data = ctx;
  313.     c->log->action = "waiting for request";

  315.     c->log_error = NGX_ERROR_INFO;

  317.     rev = c->read;
  318.     rev->handler = ngx_http_wait_request_handler;
  319.     c->write->handler = ngx_http_empty_handler;

  321. #if (NGX_HTTP_V3)
  322.     if (hc->addr_conf->quic) {
  323.         ngx_http_v3_init_stream(c);
  324.         return;
  325.     }
  326. #endif

  328. #if (NGX_HTTP_SSL)
  329.     if (hc->addr_conf->ssl) {
  330.         hc->ssl = 1;
  331.         c->log->action = "SSL handshaking";
  332.         rev->handler = ngx_http_ssl_handshake;
  333.     }
  334. #endif

  336.     if (hc->addr_conf->proxy_protocol) {
  337.         hc->proxy_protocol = 1;
  338.         c->log->action = "reading PROXY protocol";
  339.     }

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

  344.         if (ngx_use_accept_mutex) {
  345.             ngx_post_event(rev, &ngx_posted_events);
  346.             return;
  347.         }

  349.         rev->handler(rev);
  350.         return;
  351.     }

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

  355.     ngx_add_timer(rev, cscf->client_header_timeout);
  356.     ngx_reusable_connection(c, 1);

  358.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  359.         ngx_http_close_connection(c);
  360.         return;
  361.     }
  362. }


  365. static void
  366. ‌ngx_http_wait_request_handler(ngx_event_t *rev)
  367. {
  368.     u_char                    *p;
  369.     size_t                     size;
  370.     ssize_t                    n;
  371.     ngx_buf_t                 *b;
  372.     ngx_connection_t          *c;
  373.     ngx_http_connection_t     *hc;
  374. #if (NGX_HTTP_V2)
  375.     ngx_http_v2_srv_conf_t    *h2scf;
  376. #endif
  377.     ngx_http_core_srv_conf_t  *cscf;

  379.     c = rev->data;

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

  383.     if (rev->timedout) {
  384.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  385.         ngx_http_close_connection(c);
  386.         return;
  387.     }

  389.     if (c->close) {
  390.         ngx_http_close_connection(c);
  391.         return;
  392.     }

  394.     hc = c->data;
  395.     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_core_module);

  397.     size = cscf->client_header_buffer_size;

  399.     b = c->buffer;

  401.     if (b == NULL) {
  402.         b = ngx_create_temp_buf(c->pool, size);
  403.         if (b == NULL) {
  404.             ngx_http_close_connection(c);
  405.             return;
  406.         }

  408.         c->buffer = b;

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

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

  418.         b->pos = b->start;
  419.         b->last = b->start;
  420.         b->end = b->last + size;
  421.     }

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

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

  427.     if (n == NGX_AGAIN) {

  429.         if (!rev->timer_set) {
  430.             ngx_add_timer(rev, cscf->client_header_timeout);
  431.             ngx_reusable_connection(c, 1);
  432.         }

  434.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  435.             ngx_http_close_connection(c);
  436.             return;
  437.         }

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

  441.             /*
  442.              * We are trying to not hold c->buffer's memory for an
  443.              * idle connection.
  444.              */

  446.             if (ngx_pfree(c->pool, b->start) == NGX_OK) {
  447.                 b->start = NULL;
  448.             }
  449.         }

  451.         return;
  452.     }

  454.     if (n == NGX_ERROR) {
  455.         ngx_http_close_connection(c);
  456.         return;
  457.     }

  459.     if (n == 0) {
  460.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  461.                       "client closed connection");
  462.         ngx_http_close_connection(c);
  463.         return;
  464.     }

  466.     b->last += n;

  468.     if (hc->proxy_protocol) {
  469.         hc->proxy_protocol = 0;

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

  473.         if (p == NULL) {
  474.             ngx_http_close_connection(c);
  475.             return;
  476.         }

  478.         b->pos = p;

  480.         if (b->pos == b->last) {
  481.             c->log->action = "waiting for request";
  482.             b->pos = b->start;
  483.             b->last = b->start;
  484.             ngx_post_event(rev, &ngx_posted_events);
  485.             return;
  486.         }
  487.     }

  489. #if (NGX_HTTP_V2)

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

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

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

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

  500.             if (size == sizeof(NGX_HTTP_V2_PREFACE) - 1) {
  501.                 ngx_http_v2_init(rev);
  502.                 return;
  503.             }

  505.             ngx_post_event(rev, &ngx_posted_events);
  506.             return;
  507.         }
  508.     }

  510. #endif

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

  514.     ngx_reusable_connection(c, 0);

  516.     c->data = ngx_http_create_request(c);
  517.     if (c->data == NULL) {
  518.         ngx_http_close_connection(c);
  519.         return;
  520.     }

  522.     rev->handler = ngx_http_process_request_line;
  523.     ngx_http_process_request_line(rev);
  524. }


  527. ngx_http_request_t *
  528. ‌ngx_http_create_request(ngx_connection_t *c)
  529. {
  530.     ngx_http_request_t        *r;
  531.     ngx_http_log_ctx_t        *ctx;
  532.     ngx_http_core_loc_conf_t  *clcf;

  534.     r = ngx_http_alloc_request(c);
  535.     if (r == NULL) {
  536.         return NULL;
  537.     }

  539.     c->requests++;

  541.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  545.     ctx = c->log->data;
  546.     ctx->request = r;
  547.     ctx->current_request = r;

  549. #if (NGX_STAT_STUB)
  550.     (void) ngx_atomic_fetch_add(ngx_stat_reading, 1);
  551.     r->stat_reading = 1;
  552.     (void) ngx_atomic_fetch_add(ngx_stat_requests, 1);
  553. #endif

  555.     return r;
  556. }


  559. static ngx_http_request_t *
  560. ‌ngx_http_alloc_request(ngx_connection_t *c)
  561. {
  562.     ngx_pool_t                 *pool;
  563.     ngx_time_t                 *tp;
  564.     ngx_http_request_t         *r;
  565.     ngx_http_connection_t      *hc;
  566.     ngx_http_core_srv_conf_t   *cscf;
  567.     ngx_http_core_main_conf_t  *cmcf;

  569.     hc = c->data;

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

  573.     pool = ngx_create_pool(cscf->request_pool_size, c->log);
  574.     if (pool == NULL) {
  575.         return NULL;
  576.     }

  578.     r = ngx_pcalloc(pool, sizeof(ngx_http_request_t));
  579.     if (r == NULL) {
  580.         ngx_destroy_pool(pool);
  581.         return NULL;
  582.     }

  584.     r->pool = pool;

  586.     r->http_connection = hc;
  587.     r->signature = NGX_HTTP_MODULE;
  588.     r->connection = c;

  590.     r->main_conf = hc->conf_ctx->main_conf;
  591.     r->srv_conf = hc->conf_ctx->srv_conf;
  592.     r->loc_conf = hc->conf_ctx->loc_conf;

  594.     r->read_event_handler = ngx_http_block_reading;

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

  598.     if (ngx_list_init(&r->headers_out.headers, r->pool, 20,
  599.                       sizeof(ngx_table_elt_t))
  600.         != NGX_OK)
  601.     {
  602.         ngx_destroy_pool(r->pool);
  603.         return NULL;
  604.     }

  606.     if (ngx_list_init(&r->headers_out.trailers, r->pool, 4,
  607.                       sizeof(ngx_table_elt_t))
  608.         != NGX_OK)
  609.     {
  610.         ngx_destroy_pool(r->pool);
  611.         return NULL;
  612.     }

  614.     r->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);
  615.     if (r->ctx == NULL) {
  616.         ngx_destroy_pool(r->pool);
  617.         return NULL;
  618.     }

  620.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  622.     r->variables = ngx_pcalloc(r->pool, cmcf->variables.nelts
  623.                                         * sizeof(ngx_http_variable_value_t));
  624.     if (r->variables == NULL) {
  625.         ngx_destroy_pool(r->pool);
  626.         return NULL;
  627.     }

  629. #if (NGX_HTTP_SSL)
  630.     if (c->ssl && !c->ssl->sendfile) {
  631.         r->main_filter_need_in_memory = 1;
  632.     }
  633. #endif

  635.     r->main = r;
  636.     r->count = 1;

  638.     tp = ngx_timeofday();
  639.     r->start_sec = tp->sec;
  640.     r->start_msec = tp->msec;

  642.     r->method = NGX_HTTP_UNKNOWN;
  643.     r->http_version = NGX_HTTP_VERSION_10;

  645.     r->headers_in.content_length_n = -1;
  646.     r->headers_in.keep_alive_n = -1;
  647.     r->headers_out.content_length_n = -1;
  648.     r->headers_out.last_modified_time = -1;

  650.     r->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;
  651.     r->subrequests = NGX_HTTP_MAX_SUBREQUESTS + 1;

  653.     r->http_state = NGX_HTTP_READING_REQUEST_STATE;

  655.     r->log_handler = ngx_http_log_error_handler;

  657.     return r;
  658. }


  661. #if (NGX_HTTP_SSL)

  663. static void
  664. ‌ngx_http_ssl_handshake(ngx_event_t *rev)
  665. {
  666.     u_char                    *p, buf[NGX_PROXY_PROTOCOL_MAX_HEADER + 1];
  667.     size_t                     size;
  668.     ssize_t                    n;
  669.     ngx_err_t                  err;
  670.     ngx_int_t                  rc;
  671.     ngx_connection_t          *c;
  672.     ngx_http_connection_t     *hc;
  673.     ngx_http_ssl_srv_conf_t   *sscf;
  674.     ngx_http_core_loc_conf_t  *clcf;
  675.     ngx_http_core_srv_conf_t  *cscf;

  677.     c = rev->data;
  678.     hc = c->data;

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

  683.     if (rev->timedout) {
  684.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  685.         ngx_http_close_connection(c);
  686.         return;
  687.     }

  689.     if (c->close) {
  690.         ngx_http_close_connection(c);
  691.         return;
  692.     }

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

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

  698.     err = ngx_socket_errno;

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

  702.     if (n == -1) {
  703.         if (err == NGX_EAGAIN) {
  704.             rev->ready = 0;

  706.             if (!rev->timer_set) {
  707.                 cscf = ngx_http_get_module_srv_conf(hc->conf_ctx,
  708.                                                     ngx_http_core_module);
  709.                 ngx_add_timer(rev, cscf->client_header_timeout);
  710.                 ngx_reusable_connection(c, 1);
  711.             }

  713.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  714.                 ngx_http_close_connection(c);
  715.             }

  717.             return;
  718.         }

  720.         ngx_connection_error(c, err, "recv() failed");
  721.         ngx_http_close_connection(c);

  723.         return;
  724.     }

  726.     if (hc->proxy_protocol) {
  727.         hc->proxy_protocol = 0;

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

  731.         if (p == NULL) {
  732.             ngx_http_close_connection(c);
  733.             return;
  734.         }

  736.         size = p - buf;

  738.         if (c->recv(c, buf, size) != (ssize_t) size) {
  739.             ngx_http_close_connection(c);
  740.             return;
  741.         }

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

  745.         if (n == (ssize_t) size) {
  746.             ngx_post_event(rev, &ngx_posted_events);
  747.             return;
  748.         }

  750.         n = 1;
  751.         buf[0] = *p;
  752.     }

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

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

  762.             if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  763.                 ngx_http_close_connection(c);
  764.                 return;
  765.             }

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

  770.             if (ngx_ssl_create_connection(&sscf->ssl, c, NGX_SSL_BUFFER)
  771.                 != NGX_OK)
  772.             {
  773.                 ngx_http_close_connection(c);
  774.                 return;
  775.             }

  777.             ngx_reusable_connection(c, 0);

  779.             rc = ngx_ssl_handshake(c);

  781.             if (rc == NGX_AGAIN) {

  783.                 if (!rev->timer_set) {
  784.                     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx,
  785.                                                         ngx_http_core_module);
  786.                     ngx_add_timer(rev, cscf->client_header_timeout);
  787.                 }

  789.                 c->ssl->handler = ngx_http_ssl_handshake_handler;
  790.                 return;
  791.             }

  793.             ngx_http_ssl_handshake_handler(c);

  795.             return;
  796.         }

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

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

  802.         rev->handler = ngx_http_wait_request_handler;
  803.         ngx_http_wait_request_handler(rev);

  805.         return;
  806.     }

  808.     ngx_log_error(NGX_LOG_INFO, c->log, 0, "client closed connection");
  809.     ngx_http_close_connection(c);
  810. }


  813. static void
  814. ‌ngx_http_ssl_handshake_handler(ngx_connection_t *c)
  815. {
  816.     if (c->ssl->handshaked) {

  818.         /*
  819.          * The majority of browsers do not send the "close notify" alert.
  820.          * Among them are MSIE, old Mozilla, Netscape 4, Konqueror,
  821.          * and Links.  And what is more, MSIE ignores the server's alert.
  822.          *
  823.          * Opera and recent Mozilla send the alert.
  824.          */

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

  828. #if (NGX_HTTP_V2                                                              \
  829.      && defined TLSEXT_TYPE_application_layer_protocol_negotiation)
  830.         {
  831.         unsigned int             len;
  832.         const unsigned char     *data;
  833.         ngx_http_connection_t   *hc;
  834.         ngx_http_v2_srv_conf_t  *h2scf;

  836.         hc = c->data;

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

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

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

  844.             if (len == 2 && data[0] == 'h' && data[1] == '2') {
  845.                 ngx_http_v2_init(c->read);
  846.                 return;
  847.             }
  848.         }
  849.         }
  850. #endif

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

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

  857.         ngx_reusable_connection(c, 1);

  859.         ngx_http_wait_request_handler(c->read);

  861.         return;
  862.     }

  864.     if (c->read->timedout) {
  865.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  866.     }

  868.     ngx_http_close_connection(c);
  869. }


  872. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  874. int
  875. ‌ngx_http_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg)
  876. {
  877.     ngx_int_t                  rc;
  878.     ngx_str_t                  host;
  879.     const char                *servername;
  880.     ngx_connection_t          *c;
  881.     ngx_http_connection_t     *hc;
  882.     ngx_http_ssl_srv_conf_t   *sscf;
  883.     ngx_http_core_loc_conf_t  *clcf;
  884.     ngx_http_core_srv_conf_t  *cscf;

  886.     c = ngx_ssl_get_connection(ssl_conn);

  888.     if (c->ssl->handshaked) {
  889.         *ad = SSL_AD_NO_RENEGOTIATION;
  890.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  891.     }

  893.     hc = c->data;

  895.     servername = SSL_get_servername(ssl_conn, TLSEXT_NAMETYPE_host_name);

  897.     if (servername == NULL) {
  898.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  899.                        "SSL server name: null");
  900.         goto done;
  901.     }

  903.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  904.                    "SSL server name: \"%s\"", servername);

  906.     host.len = ngx_strlen(servername);

  908.     if (host.len == 0) {
  909.         goto done;
  910.     }

  912.     host.data = (u_char *) servername;

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

  916.     if (rc == NGX_ERROR) {
  917.         goto error;
  918.     }

  920.     if (rc == NGX_DECLINED) {
  921.         goto done;
  922.     }

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

  927.     if (rc == NGX_ERROR) {
  928.         goto error;
  929.     }

  931.     if (rc == NGX_DECLINED) {
  932.         goto done;
  933.     }

  935.     hc->ssl_servername = ngx_palloc(c->pool, sizeof(ngx_str_t));
  936.     if (hc->ssl_servername == NULL) {
  937.         goto error;
  938.     }

  940.     *hc->ssl_servername = host;

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

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

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

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

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

  952.     if (sscf->ssl.ctx) {
  953.         if (SSL_set_SSL_CTX(ssl_conn, sscf->ssl.ctx) == NULL) {
  954.             goto error;
  955.         }

  957.         /*
  958.          * SSL_set_SSL_CTX() only changes certs as of 1.0.0d
  959.          * adjust other things we care about
  960.          */

  962.         SSL_set_verify(ssl_conn, SSL_CTX_get_verify_mode(sscf->ssl.ctx),
  963.                        SSL_CTX_get_verify_callback(sscf->ssl.ctx));

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

  967. #if OPENSSL_VERSION_NUMBER >= 0x009080dfL
  968.         /* only in 0.9.8m+ */
  969.         SSL_clear_options(ssl_conn, SSL_get_options(ssl_conn) &
  970.                                     ~SSL_CTX_get_options(sscf->ssl.ctx));
  971. #endif

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

  975. #ifdef SSL_OP_NO_RENEGOTIATION
  976.         SSL_set_options(ssl_conn, SSL_OP_NO_RENEGOTIATION);
  977. #endif

  979. #ifdef SSL_OP_ENABLE_MIDDLEBOX_COMPAT
  980. #if (NGX_HTTP_V3)
  981.         if (c->listening->quic) {
  982.             SSL_clear_options(ssl_conn, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
  983.         }
  984. #endif
  985. #endif
  986.     }

  988. done:

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

  992.     if (sscf->reject_handshake) {
  993.         c->ssl->handshake_rejected = 1;
  994.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  995.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  996.     }

  998.     return SSL_TLSEXT_ERR_OK;

  1000. error:

  1002.     *ad = SSL_AD_INTERNAL_ERROR;
  1003.     return SSL_TLSEXT_ERR_ALERT_FATAL;
  1004. }

  1006. #endif


  1009. #ifdef SSL_R_CERT_CB_ERROR

  1011. int
  1012. ‌ngx_http_ssl_certificate(ngx_ssl_conn_t *ssl_conn, void *arg)
  1013. {
  1014.     ngx_str_t                  cert, key;
  1015.     ngx_uint_t                 i, nelts;
  1016.     ngx_connection_t          *c;
  1017.     ngx_http_request_t        *r;
  1018.     ngx_http_ssl_srv_conf_t   *sscf;
  1019.     ngx_http_complex_value_t  *certs, *keys;

  1021.     c = ngx_ssl_get_connection(ssl_conn);

  1023.     if (c->ssl->handshaked) {
  1024.         return 0;
  1025.     }

  1027.     r = ngx_http_alloc_request(c);
  1028.     if (r == NULL) {
  1029.         return 0;
  1030.     }

  1032.     r->logged = 1;

  1034.     sscf = arg;

  1036.     nelts = sscf->certificate_values->nelts;
  1037.     certs = sscf->certificate_values->elts;
  1038.     keys = sscf->certificate_key_values->elts;

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

  1042.         if (ngx_http_complex_value(r, &certs[i], &cert) != NGX_OK) {
  1043.             goto failed;
  1044.         }

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

  1049.         if (ngx_http_complex_value(r, &keys[i], &key) != NGX_OK) {
  1050.             goto failed;
  1051.         }

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

  1056.         if (ngx_ssl_connection_certificate(c, r->pool, &cert, &key,
  1057.                                            sscf->passwords)
  1058.             != NGX_OK)
  1059.         {
  1060.             goto failed;
  1061.         }
  1062.     }

  1064.     ngx_http_free_request(r, 0);
  1065.     c->log->action = "SSL handshaking";
  1066.     c->destroyed = 0;
  1067.     return 1;

  1069. failed:

  1071.     ngx_http_free_request(r, 0);
  1072.     c->log->action = "SSL handshaking";
  1073.     c->destroyed = 0;
  1074.     return 0;
  1075. }

  1077. #endif

  1079. #endif


  1082. static void
  1083. ‌ngx_http_process_request_line(ngx_event_t *rev)
  1084. {
  1085.     ssize_t              n;
  1086.     ngx_int_t            rc, rv;
  1087.     ngx_str_t            host;
  1088.     ngx_connection_t    *c;
  1089.     ngx_http_request_t  *r;

  1091.     c = rev->data;
  1092.     r = c->data;

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

  1097.     if (rev->timedout) {
  1098.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  1099.         c->timedout = 1;
  1100.         ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  1101.         return;
  1102.     }

  1104.     rc = NGX_AGAIN;

  1106.     for ( ;; ) {

  1108.         if (rc == NGX_AGAIN) {
  1109.             n = ngx_http_read_request_header(r);

  1111.             if (n == NGX_AGAIN || n == NGX_ERROR) {
  1112.                 break;
  1113.             }
  1114.         }

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

  1118.         if (rc == NGX_OK) {

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

  1122.             r->request_line.len = r->request_end - r->request_start;
  1123.             r->request_line.data = r->request_start;
  1124.             r->request_length = r->header_in->pos - r->request_start;

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

  1129.             r->method_name.len = r->method_end - r->request_start + 1;
  1130.             r->method_name.data = r->request_line.data;

  1132.             if (r->http_protocol.data) {
  1133.                 r->http_protocol.len = r->request_end - r->http_protocol.data;
  1134.             }

  1136.             if (ngx_http_process_request_uri(r) != NGX_OK) {
  1137.                 break;
  1138.             }

  1140.             if (r->schema_end) {
  1141.                 r->schema.len = r->schema_end - r->schema_start;
  1142.                 r->schema.data = r->schema_start;
  1143.             }

  1145.             if (r->host_end) {

  1147.                 host.len = r->host_end - r->host_start;
  1148.                 host.data = r->host_start;

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

  1152.                 if (rc == NGX_DECLINED) {
  1153.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1154.                                   "client sent invalid host in request line");
  1155.                     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1156.                     break;
  1157.                 }

  1159.                 if (rc == NGX_ERROR) {
  1160.                     ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1161.                     break;
  1162.                 }

  1164.                 if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
  1165.                     break;
  1166.                 }

  1168.                 r->headers_in.server = host;
  1169.             }

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

  1173.                 if (r->headers_in.server.len == 0
  1174.                     && ngx_http_set_virtual_server(r, &r->headers_in.server)
  1175.                        == NGX_ERROR)
  1176.                 {
  1177.                     break;
  1178.                 }

  1180.                 ngx_http_process_request(r);
  1181.                 break;
  1182.             }


  1185.             if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  1186.                               sizeof(ngx_table_elt_t))
  1187.                 != NGX_OK)
  1188.             {
  1189.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1190.                 break;
  1191.             }

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

  1195.             rev->handler = ngx_http_process_request_headers;
  1196.             ngx_http_process_request_headers(rev);

  1198.             break;
  1199.         }

  1201.         if (rc != NGX_AGAIN) {

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

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

  1208.             if (rc == NGX_HTTP_PARSE_INVALID_VERSION) {
  1209.                 ngx_http_finalize_request(r, NGX_HTTP_VERSION_NOT_SUPPORTED);

  1211.             } else {
  1212.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1213.             }

  1215.             break;
  1216.         }

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

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

  1222.             rv = ngx_http_alloc_large_header_buffer(r, 1);

  1224.             if (rv == NGX_ERROR) {
  1225.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1226.                 break;
  1227.             }

  1229.             if (rv == NGX_DECLINED) {
  1230.                 r->request_line.len = r->header_in->end - r->request_start;
  1231.                 r->request_line.data = r->request_start;

  1233.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1234.                               "client sent too long URI");
  1235.                 ngx_http_finalize_request(r, NGX_HTTP_REQUEST_URI_TOO_LARGE);
  1236.                 break;
  1237.             }
  1238.         }
  1239.     }

  1241.     ngx_http_run_posted_requests(c);
  1242. }


  1245. ngx_int_t
  1246. ‌ngx_http_process_request_uri(ngx_http_request_t *r)
  1247. {
  1248.     ngx_http_core_srv_conf_t  *cscf;

  1250.     if (r->args_start) {
  1251.         r->uri.len = r->args_start - 1 - r->uri_start;
  1252.     } else {
  1253.         r->uri.len = r->uri_end - r->uri_start;
  1254.     }

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

  1258.         if (r->empty_path_in_uri) {
  1259.             r->uri.len++;
  1260.         }

  1262.         r->uri.data = ngx_pnalloc(r->pool, r->uri.len);
  1263.         if (r->uri.data == NULL) {
  1264.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1265.             return NGX_ERROR;
  1266.         }

  1268.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  1273.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1274.                           "client sent invalid request");
  1275.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1276.             return NGX_ERROR;
  1277.         }

  1279.     } else {
  1280.         r->uri.data = r->uri_start;
  1281.     }

  1283.     r->unparsed_uri.len = r->uri_end - r->uri_start;
  1284.     r->unparsed_uri.data = r->uri_start;

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

  1288.     if (r->uri_ext) {
  1289.         if (r->args_start) {
  1290.             r->exten.len = r->args_start - 1 - r->uri_ext;
  1291.         } else {
  1292.             r->exten.len = r->uri_end - r->uri_ext;
  1293.         }

  1295.         r->exten.data = r->uri_ext;
  1296.     }

  1298.     if (r->args_start && r->uri_end > r->args_start) {
  1299.         r->args.len = r->uri_end - r->args_start;
  1300.         r->args.data = r->args_start;
  1301.     }

  1303. #if (NGX_WIN32)
  1304.     {
  1305.     u_char  *p, *last;

  1307.     p = r->uri.data;
  1308.     last = r->uri.data + r->uri.len;

  1310.     while (p < last) {

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

  1314.             /*
  1315.              * this check covers "::$data", "::$index_allocation" and
  1316.              * ":$i30:$index_allocation"
  1317.              */

  1319.             if (p < last && *p == '$') {
  1320.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1321.                               "client sent unsafe win32 URI");
  1322.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1323.                 return NGX_ERROR;
  1324.             }
  1325.         }
  1326.     }

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

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

  1332.         if (*p == ' ') {
  1333.             p--;
  1334.             continue;
  1335.         }

  1337.         if (*p == '.') {
  1338.             p--;
  1339.             continue;
  1340.         }

  1342.         break;
  1343.     }

  1345.     if (p != r->uri.data + r->uri.len - 1) {
  1346.         r->uri.len = p + 1 - r->uri.data;
  1347.         ngx_http_set_exten(r);
  1348.     }

  1350.     }
  1351. #endif

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

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

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

  1362.     return NGX_OK;
  1363. }


  1366. static void
  1367. ‌ngx_http_process_request_headers(ngx_event_t *rev)
  1368. {
  1369.     u_char                     *p;
  1370.     size_t                      len;
  1371.     ssize_t                     n;
  1372.     ngx_int_t                   rc, rv;
  1373.     ngx_table_elt_t            *h;
  1374.     ngx_connection_t           *c;
  1375.     ngx_http_header_t          *hh;
  1376.     ngx_http_request_t         *r;
  1377.     ngx_http_core_srv_conf_t   *cscf;
  1378.     ngx_http_core_main_conf_t  *cmcf;

  1380.     c = rev->data;
  1381.     r = c->data;

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

  1386.     if (rev->timedout) {
  1387.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  1388.         c->timedout = 1;
  1389.         ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  1390.         return;
  1391.     }

  1393.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  1395.     rc = NGX_AGAIN;

  1397.     for ( ;; ) {

  1399.         if (rc == NGX_AGAIN) {

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

  1403.                 rv = ngx_http_alloc_large_header_buffer(r, 0);

  1405.                 if (rv == NGX_ERROR) {
  1406.                     ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1407.                     break;
  1408.                 }

  1410.                 if (rv == NGX_DECLINED) {
  1411.                     p = r->header_name_start;

  1413.                     r->lingering_close = 1;

  1415.                     if (p == NULL) {
  1416.                         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1417.                                       "client sent too large request");
  1418.                         ngx_http_finalize_request(r,
  1419.                                             NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  1420.                         break;
  1421.                     }

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

  1425.                     if (len > NGX_MAX_ERROR_STR - 300) {
  1426.                         len = NGX_MAX_ERROR_STR - 300;
  1427.                     }

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

  1433.                     ngx_http_finalize_request(r,
  1434.                                             NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  1435.                     break;
  1436.                 }
  1437.             }

  1439.             n = ngx_http_read_request_header(r);

  1441.             if (n == NGX_AGAIN || n == NGX_ERROR) {
  1442.                 break;
  1443.             }
  1444.         }

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

  1449.         rc = ngx_http_parse_header_line(r, r->header_in,
  1450.                                         cscf->underscores_in_headers);

  1452.         if (rc == NGX_OK) {

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

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

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

  1460.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1461.                               "client sent invalid header line: \"%*s\"",
  1462.                               r->header_end - r->header_name_start,
  1463.                               r->header_name_start);
  1464.                 continue;
  1465.             }

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

  1469.             h = ngx_list_push(&r->headers_in.headers);
  1470.             if (h == NULL) {
  1471.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1472.                 break;
  1473.             }

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

  1477.             h->key.len = r->header_name_end - r->header_name_start;
  1478.             h->key.data = r->header_name_start;
  1479.             h->key.data[h->key.len] = '\0';

  1481.             h->value.len = r->header_end - r->header_start;
  1482.             h->value.data = r->header_start;
  1483.             h->value.data[h->value.len] = '\0';

  1485.             h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
  1486.             if (h->lowcase_key == NULL) {
  1487.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1488.                 break;
  1489.             }

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

  1494.             } else {
  1495.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1496.             }

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

  1501.             if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1502.                 break;
  1503.             }

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

  1509.             continue;
  1510.         }

  1512.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

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

  1521.             r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  1523.             rc = ngx_http_process_request_header(r);

  1525.             if (rc != NGX_OK) {
  1526.                 break;
  1527.             }

  1529.             ngx_http_process_request(r);

  1531.             break;
  1532.         }

  1534.         if (rc == NGX_AGAIN) {

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

  1538.             continue;
  1539.         }

  1541.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  1543.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1544.                       "client sent invalid header line: \"%*s\\x%02xd...\"",
  1545.                       r->header_end - r->header_name_start,
  1546.                       r->header_name_start, *r->header_end);

  1548.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1549.         break;
  1550.     }

  1552.     ngx_http_run_posted_requests(c);
  1553. }


  1556. static ssize_t
  1557. ‌ngx_http_read_request_header(ngx_http_request_t *r)
  1558. {
  1559.     ssize_t                    n;
  1560.     ngx_event_t               *rev;
  1561.     ngx_connection_t          *c;
  1562.     ngx_http_core_srv_conf_t  *cscf;

  1564.     c = r->connection;
  1565.     rev = c->read;

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

  1569.     if (n > 0) {
  1570.         return n;
  1571.     }

  1573.     if (rev->ready) {
  1574.         n = c->recv(c, r->header_in->last,
  1575.                     r->header_in->end - r->header_in->last);
  1576.     } else {
  1577.         n = NGX_AGAIN;
  1578.     }

  1580.     if (n == NGX_AGAIN) {
  1581.         if (!rev->timer_set) {
  1582.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  1583.             ngx_add_timer(rev, cscf->client_header_timeout);
  1584.         }

  1586.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  1587.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1588.             return NGX_ERROR;
  1589.         }

  1591.         return NGX_AGAIN;
  1592.     }

  1594.     if (n == 0) {
  1595.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1596.                       "client prematurely closed connection");
  1597.     }

  1599.     if (n == 0 || n == NGX_ERROR) {
  1600.         c->error = 1;
  1601.         c->log->action = "reading client request headers";

  1603.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1604.         return NGX_ERROR;
  1605.     }

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

  1609.     return n;
  1610. }


  1613. static ngx_int_t
  1614. ‌ngx_http_alloc_large_header_buffer(ngx_http_request_t *r,
  1615.     ngx_uint_t request_line)
  1616. {
  1617.     u_char                    *old, *new;
  1618.     ngx_buf_t                 *b;
  1619.     ngx_chain_t               *cl;
  1620.     ngx_http_connection_t     *hc;
  1621.     ngx_http_core_srv_conf_t  *cscf;

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

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

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

  1630.         r->header_in->pos = r->header_in->start;
  1631.         r->header_in->last = r->header_in->start;

  1633.         return NGX_OK;
  1634.     }

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

  1638.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1640.     if (r->state != 0
  1641.         && (size_t) (r->header_in->pos - old)
  1642.                                      >= cscf->large_client_header_buffers.size)
  1643.     {
  1644.         return NGX_DECLINED;
  1645.     }

  1647.     hc = r->http_connection;

  1649.     if (hc->free) {
  1650.         cl = hc->free;
  1651.         hc->free = cl->next;

  1653.         b = cl->buf;

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

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

  1661.         b = ngx_create_temp_buf(r->connection->pool,
  1662.                                 cscf->large_client_header_buffers.size);
  1663.         if (b == NULL) {
  1664.             return NGX_ERROR;
  1665.         }

  1667.         cl = ngx_alloc_chain_link(r->connection->pool);
  1668.         if (cl == NULL) {
  1669.             return NGX_ERROR;
  1670.         }

  1672.         cl->buf = b;

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

  1678.     } else {
  1679.         return NGX_DECLINED;
  1680.     }

  1682.     cl->next = hc->busy;
  1683.     hc->busy = cl;
  1684.     hc->nbusy++;

  1686.     if (r->state == 0) {
  1687.         /*
  1688.          * r->state == 0 means that a header line was parsed successfully
  1689.          * and we do not need to copy incomplete header line and
  1690.          * to relocate the parser header pointers
  1691.          */

  1693.         r->header_in = b;

  1695.         return NGX_OK;
  1696.     }

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

  1701.     if (r->header_in->pos - old > b->end - b->start) {
  1702.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1703.                       "too large header to copy");
  1704.         return NGX_ERROR;
  1705.     }

  1707.     new = b->start;

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

  1711.     b->pos = new + (r->header_in->pos - old);
  1712.     b->last = new + (r->header_in->pos - old);

  1714.     if (request_line) {
  1715.         r->request_start = new;

  1717.         if (r->request_end) {
  1718.             r->request_end = new + (r->request_end - old);
  1719.         }

  1721.         if (r->method_end) {
  1722.             r->method_end = new + (r->method_end - old);
  1723.         }

  1725.         if (r->uri_start) {
  1726.             r->uri_start = new + (r->uri_start - old);
  1727.         }

  1729.         if (r->uri_end) {
  1730.             r->uri_end = new + (r->uri_end - old);
  1731.         }

  1733.         if (r->schema_start) {
  1734.             r->schema_start = new + (r->schema_start - old);
  1735.             if (r->schema_end) {
  1736.                 r->schema_end = new + (r->schema_end - old);
  1737.             }
  1738.         }

  1740.         if (r->host_start) {
  1741.             r->host_start = new + (r->host_start - old);
  1742.             if (r->host_end) {
  1743.                 r->host_end = new + (r->host_end - old);
  1744.             }
  1745.         }

  1747.         if (r->uri_ext) {
  1748.             r->uri_ext = new + (r->uri_ext - old);
  1749.         }

  1751.         if (r->args_start) {
  1752.             r->args_start = new + (r->args_start - old);
  1753.         }

  1755.         if (r->http_protocol.data) {
  1756.             r->http_protocol.data = new + (r->http_protocol.data - old);
  1757.         }

  1759.     } else {
  1760.         r->header_name_start = new;

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

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

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

  1775.     r->header_in = b;

  1777.     return NGX_OK;
  1778. }


  1781. static ngx_int_t
  1782. ‌ngx_http_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  1783.     ngx_uint_t offset)
  1784. {
  1785.     ngx_table_elt_t  **ph;

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

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

  1791.     *ph = h;
  1792.     h->next = NULL;

  1794.     return NGX_OK;
  1795. }


  1798. static ngx_int_t
  1799. ‌ngx_http_process_unique_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  1800.     ngx_uint_t offset)
  1801. {
  1802.     ngx_table_elt_t  **ph;

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

  1806.     if (*ph == NULL) {
  1807.         *ph = h;
  1808.         h->next = NULL;
  1809.         return NGX_OK;
  1810.     }

  1812.     ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1813.                   "client sent duplicate header line: \"%V: %V\", "
  1814.                   "previous value: \"%V: %V\"",
  1815.                   &h->key, &h->value, &(*ph)->key, &(*ph)->value);

  1817.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);

  1819.     return NGX_ERROR;
  1820. }


  1823. static ngx_int_t
  1824. ‌ngx_http_process_host(ngx_http_request_t *r, ngx_table_elt_t *h,
  1825.     ngx_uint_t offset)
  1826. {
  1827.     ngx_int_t  rc;
  1828.     ngx_str_t  host;

  1830.     if (r->headers_in.host) {
  1831.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1832.                       "client sent duplicate host header: \"%V: %V\", "
  1833.                       "previous value: \"%V: %V\"",
  1834.                       &h->key, &h->value, &r->headers_in.host->key,
  1835.                       &r->headers_in.host->value);
  1836.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1837.         return NGX_ERROR;
  1838.     }

  1840.     r->headers_in.host = h;
  1841.     h->next = NULL;

  1843.     host = h->value;

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

  1847.     if (rc == NGX_DECLINED) {
  1848.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1849.                       "client sent invalid host header");
  1850.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1851.         return NGX_ERROR;
  1852.     }

  1854.     if (rc == NGX_ERROR) {
  1855.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1856.         return NGX_ERROR;
  1857.     }

  1859.     if (r->headers_in.server.len) {
  1860.         return NGX_OK;
  1861.     }

  1863.     if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
  1864.         return NGX_ERROR;
  1865.     }

  1867.     r->headers_in.server = host;

  1869.     return NGX_OK;
  1870. }


  1873. static ngx_int_t
  1874. ‌ngx_http_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  1875.     ngx_uint_t offset)
  1876. {
  1877.     if (ngx_http_process_header_line(r, h, offset) != NGX_OK) {
  1878.         return NGX_ERROR;
  1879.     }

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

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

  1888.     return NGX_OK;
  1889. }


  1892. static ngx_int_t
  1893. ‌ngx_http_process_user_agent(ngx_http_request_t *r, ngx_table_elt_t *h,
  1894.     ngx_uint_t offset)
  1895. {
  1896.     u_char  *user_agent, *msie;

  1898.     if (ngx_http_process_header_line(r, h, offset) != NGX_OK) {
  1899.         return NGX_ERROR;
  1900.     }

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

  1904.     user_agent = h->value.data;

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

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

  1910.         r->headers_in.msie = 1;

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

  1914.             switch (msie[5]) {
  1915.             case '4':
  1916.             case '5':
  1917.                 r->headers_in.msie6 = 1;
  1918.                 break;
  1919.             case '6':
  1920.                 if (ngx_strstrn(msie + 8, "SV1", 3 - 1) == NULL) {
  1921.                     r->headers_in.msie6 = 1;
  1922.                 }
  1923.                 break;
  1924.             }
  1925.         }

  1927. #if 0
  1928.         /* MSIE ignores the SSL "close notify" alert */
  1929.         if (c->ssl) {
  1930.             c->ssl->no_send_shutdown = 1;
  1931.         }
  1932. #endif
  1933.     }

  1935.     if (ngx_strstrn(user_agent, "Opera", 5 - 1)) {
  1936.         r->headers_in.opera = 1;
  1937.         r->headers_in.msie = 0;
  1938.         r->headers_in.msie6 = 0;
  1939.     }

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

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

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

  1949.         } else if (ngx_strstrn(user_agent, "Safari/", 7 - 1)
  1950.                    && ngx_strstrn(user_agent, "Mac OS X", 8 - 1))
  1951.         {
  1952.             r->headers_in.safari = 1;

  1954.         } else if (ngx_strstrn(user_agent, "Konqueror", 9 - 1)) {
  1955.             r->headers_in.konqueror = 1;
  1956.         }
  1957.     }

  1959.     return NGX_OK;
  1960. }


  1963. ngx_int_t
  1964. ‌ngx_http_process_request_header(ngx_http_request_t *r)
  1965. {
  1966.     if (r->headers_in.server.len == 0
  1967.         && ngx_http_set_virtual_server(r, &r->headers_in.server)
  1968.            == NGX_ERROR)
  1969.     {
  1970.         return NGX_ERROR;
  1971.     }

  1973.     if (r->headers_in.host == NULL && r->http_version > NGX_HTTP_VERSION_10) {
  1974.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1975.                    "client sent HTTP/1.1 request without \"Host\" header");
  1976.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1977.         return NGX_ERROR;
  1978.     }

  1980.     if (r->headers_in.content_length) {
  1981.         r->headers_in.content_length_n =
  1982.                             ngx_atoof(r->headers_in.content_length->value.data,
  1983.                                       r->headers_in.content_length->value.len);

  1985.         if (r->headers_in.content_length_n == NGX_ERROR) {
  1986.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1987.                           "client sent invalid \"Content-Length\" header");
  1988.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1989.             return NGX_ERROR;
  1990.         }
  1991.     }

  1993.     if (r->headers_in.transfer_encoding) {
  1994.         if (r->http_version < NGX_HTTP_VERSION_11) {
  1995.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1996.                           "client sent HTTP/1.0 request with "
  1997.                           "\"Transfer-Encoding\" header");
  1998.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1999.             return NGX_ERROR;
  2000.         }

  2002.         if (r->headers_in.transfer_encoding->value.len == 7
  2003.             && ngx_strncasecmp(r->headers_in.transfer_encoding->value.data,
  2004.                                (u_char *) "chunked", 7) == 0)
  2005.         {
  2006.             if (r->headers_in.content_length) {
  2007.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2008.                               "client sent \"Content-Length\" and "
  2009.                               "\"Transfer-Encoding\" headers "
  2010.                               "at the same time");
  2011.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  2012.                 return NGX_ERROR;
  2013.             }

  2015.             r->headers_in.chunked = 1;

  2017.         } else {
  2018.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2019.                           "client sent unknown \"Transfer-Encoding\": \"%V\"",
  2020.                           &r->headers_in.transfer_encoding->value);
  2021.             ngx_http_finalize_request(r, NGX_HTTP_NOT_IMPLEMENTED);
  2022.             return NGX_ERROR;
  2023.         }
  2024.     }

  2026.     if (r->headers_in.connection_type == NGX_HTTP_CONNECTION_KEEP_ALIVE) {
  2027.         if (r->headers_in.keep_alive) {
  2028.             r->headers_in.keep_alive_n =
  2029.                             ngx_atotm(r->headers_in.keep_alive->value.data,
  2030.                                       r->headers_in.keep_alive->value.len);
  2031.         }
  2032.     }

  2034.     if (r->method == NGX_HTTP_CONNECT) {
  2035.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2036.                       "client sent CONNECT method");
  2037.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  2038.         return NGX_ERROR;
  2039.     }

  2041.     if (r->method == NGX_HTTP_TRACE) {
  2042.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2043.                       "client sent TRACE method");
  2044.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  2045.         return NGX_ERROR;
  2046.     }

  2048.     return NGX_OK;
  2049. }


  2052. void
  2053. ‌ngx_http_process_request(ngx_http_request_t *r)
  2054. {
  2055.     ngx_connection_t  *c;

  2057.     c = r->connection;

  2059. #if (NGX_HTTP_SSL)

  2061.     if (r->http_connection->ssl) {
  2062.         long                      rc;
  2063.         X509                     *cert;
  2064.         const char               *s;
  2065.         ngx_http_ssl_srv_conf_t  *sscf;

  2067.         if (c->ssl == NULL) {
  2068.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2069.                           "client sent plain HTTP request to HTTPS port");
  2070.             ngx_http_finalize_request(r, NGX_HTTP_TO_HTTPS);
  2071.             return;
  2072.         }

  2074.         sscf = ngx_http_get_module_srv_conf(r, ngx_http_ssl_module);

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

  2079.             if (rc != X509_V_OK
  2080.                 && (sscf->verify != 3 || !ngx_ssl_verify_error_optional(rc)))
  2081.             {
  2082.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2083.                               "client SSL certificate verify error: (%l:%s)",
  2084.                               rc, X509_verify_cert_error_string(rc));

  2086.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2087.                                        (SSL_get0_session(c->ssl->connection)));

  2089.                 ngx_http_finalize_request(r, NGX_HTTPS_CERT_ERROR);
  2090.                 return;
  2091.             }

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

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

  2100.                     ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2101.                                        (SSL_get0_session(c->ssl->connection)));

  2103.                     ngx_http_finalize_request(r, NGX_HTTPS_NO_CERT);
  2104.                     return;
  2105.                 }

  2107.                 X509_free(cert);
  2108.             }

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

  2114.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2115.                                        (SSL_get0_session(c->ssl->connection)));

  2117.                 ngx_http_finalize_request(r, NGX_HTTPS_CERT_ERROR);
  2118.                 return;
  2119.             }
  2120.         }
  2121.     }

  2123. #endif

  2125.     if (c->read->timer_set) {
  2126.         ngx_del_timer(c->read);
  2127.     }

  2129. #if (NGX_STAT_STUB)
  2130.     (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  2131.     r->stat_reading = 0;
  2132.     (void) ngx_atomic_fetch_add(ngx_stat_writing, 1);
  2133.     r->stat_writing = 1;
  2134. #endif

  2136.     c->read->handler = ngx_http_request_handler;
  2137.     c->write->handler = ngx_http_request_handler;
  2138.     r->read_event_handler = ngx_http_block_reading;

  2140.     ngx_http_handler(r);
  2141. }


  2144. ngx_int_t
  2145. ‌ngx_http_validate_host(ngx_str_t *host, ngx_pool_t *pool, ngx_uint_t alloc)
  2146. {
  2147.     u_char  *h, ch;
  2148.     size_t   i, dot_pos, host_len;

  2150. ‌    enum {
  2151.         sw_usual = 0,
  2152.         sw_literal,
  2153.         sw_rest
  2154.     } state;

  2156.     dot_pos = host->len;
  2157.     host_len = host->len;

  2159.     h = host->data;

  2161.     state = sw_usual;

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

  2166.         switch (ch) {

  2168.         case '.':
  2169.             if (dot_pos == i - 1) {
  2170.                 return NGX_DECLINED;
  2171.             }
  2172.             dot_pos = i;
  2173.             break;

  2175.         case ':':
  2176.             if (state == sw_usual) {
  2177.                 host_len = i;
  2178.                 state = sw_rest;
  2179.             }
  2180.             break;

  2182.         case '[':
  2183.             if (i == 0) {
  2184.                 state = sw_literal;
  2185.             }
  2186.             break;

  2188.         case ']':
  2189.             if (state == sw_literal) {
  2190.                 host_len = i + 1;
  2191.                 state = sw_rest;
  2192.             }
  2193.             break;

  2195.         default:

  2197.             if (ngx_path_separator(ch)) {
  2198.                 return NGX_DECLINED;
  2199.             }

  2201.             if (ch <= 0x20 || ch == 0x7f) {
  2202.                 return NGX_DECLINED;
  2203.             }

  2205.             if (ch >= 'A' && ch <= 'Z') {
  2206.                 alloc = 1;
  2207.             }

  2209.             break;
  2210.         }
  2211.     }

  2213.     if (dot_pos == host_len - 1) {
  2214.         host_len--;
  2215.     }

  2217.     if (host_len == 0) {
  2218.         return NGX_DECLINED;
  2219.     }

  2221.     if (alloc) {
  2222.         host->data = ngx_pnalloc(pool, host_len);
  2223.         if (host->data == NULL) {
  2224.             return NGX_ERROR;
  2225.         }

  2227.         ngx_strlow(host->data, h, host_len);
  2228.     }

  2230.     host->len = host_len;

  2232.     return NGX_OK;
  2233. }


  2236. ngx_int_t
  2237. ‌ngx_http_set_virtual_server(ngx_http_request_t *r, ngx_str_t *host)
  2238. {
  2239.     ngx_int_t                  rc;
  2240.     ngx_http_connection_t     *hc;
  2241.     ngx_http_core_loc_conf_t  *clcf;
  2242.     ngx_http_core_srv_conf_t  *cscf;

  2244. #if (NGX_SUPPRESS_WARN)
  2245.     cscf = NULL;
  2246. #endif

  2248.     hc = r->http_connection;

  2250. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2252.     if (hc->ssl_servername) {
  2253.         if (hc->ssl_servername->len == host->len
  2254.             && ngx_strncmp(hc->ssl_servername->data,
  2255.                            host->data, host->len) == 0)
  2256.         {
  2257. #if (NGX_PCRE)
  2258.             if (hc->ssl_servername_regex
  2259.                 && ngx_http_regex_exec(r, hc->ssl_servername_regex,
  2260.                                           hc->ssl_servername) != NGX_OK)
  2261.             {
  2262.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2263.                 return NGX_ERROR;
  2264.             }
  2265. #endif
  2266.             return NGX_OK;
  2267.         }
  2268.     }

  2270. #endif

  2272.     rc = ngx_http_find_virtual_server(r->connection,
  2273.                                       hc->addr_conf->virtual_names,
  2274.                                       host, r, &cscf);

  2276.     if (rc == NGX_ERROR) {
  2277.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2278.         return NGX_ERROR;
  2279.     }

  2281. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2283.     if (hc->ssl_servername) {
  2284.         ngx_http_ssl_srv_conf_t  *sscf;

  2286.         if (rc == NGX_DECLINED) {
  2287.             cscf = hc->addr_conf->default_server;
  2288.             rc = NGX_OK;
  2289.         }

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

  2293.         if (sscf->verify) {
  2294.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2295.                           "client attempted to request the server name "
  2296.                           "different from the one that was negotiated");
  2297.             ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  2298.             return NGX_ERROR;
  2299.         }
  2300.     }

  2302. #endif

  2304.     if (rc == NGX_DECLINED) {
  2305.         return NGX_OK;
  2306.     }

  2308.     r->srv_conf = cscf->ctx->srv_conf;
  2309.     r->loc_conf = cscf->ctx->loc_conf;

  2311.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  2315.     return NGX_OK;
  2316. }


  2319. static ngx_int_t
  2320. ‌ngx_http_find_virtual_server(ngx_connection_t *c,
  2321.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  2322.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp)
  2323. {
  2324.     ngx_http_core_srv_conf_t  *cscf;

  2326.     if (virtual_names == NULL) {
  2327.         return NGX_DECLINED;
  2328.     }

  2330.     cscf = ngx_hash_find_combined(&virtual_names->names,
  2331.                                   ngx_hash_key(host->data, host->len),
  2332.                                   host->data, host->len);

  2334.     if (cscf) {
  2335.         *cscfp = cscf;
  2336.         return NGX_OK;
  2337.     }

  2339. #if (NGX_PCRE)

  2341.     if (host->len && virtual_names->nregex) {
  2342.         ngx_int_t                n;
  2343.         ngx_uint_t               i;
  2344.         ngx_http_server_name_t  *sn;

  2346.         sn = virtual_names->regex;

  2348. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2350.         if (r == NULL) {
  2351.             ngx_http_connection_t  *hc;

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

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

  2357.                 if (n == NGX_REGEX_NO_MATCHED) {
  2358.                     continue;
  2359.                 }

  2361.                 if (n >= 0) {
  2362.                     hc = c->data;
  2363.                     hc->ssl_servername_regex = sn[i].regex;

  2365.                     *cscfp = sn[i].server;
  2366.                     return NGX_OK;
  2367.                 }

  2369.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2370.                               ngx_regex_exec_n " failed: %i "
  2371.                               "on \"%V\" using \"%V\"",
  2372.                               n, host, &sn[i].regex->name);

  2374.                 return NGX_ERROR;
  2375.             }

  2377.             return NGX_DECLINED;
  2378.         }

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

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

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

  2386.             if (n == NGX_DECLINED) {
  2387.                 continue;
  2388.             }

  2390.             if (n == NGX_OK) {
  2391.                 *cscfp = sn[i].server;
  2392.                 return NGX_OK;
  2393.             }

  2395.             return NGX_ERROR;
  2396.         }
  2397.     }

  2399. #endif /* NGX_PCRE */

  2401.     return NGX_DECLINED;
  2402. }


  2405. static void
  2406. ‌ngx_http_request_handler(ngx_event_t *ev)
  2407. {
  2408.     ngx_connection_t    *c;
  2409.     ngx_http_request_t  *r;

  2411.     c = ev->data;
  2412.     r = c->data;

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

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

  2419.     if (c->close) {
  2420.         r->main->count++;
  2421.         ngx_http_terminate_request(r, 0);
  2422.         ngx_http_run_posted_requests(c);
  2423.         return;
  2424.     }

  2426.     if (ev->delayed && ev->timedout) {
  2427.         ev->delayed = 0;
  2428.         ev->timedout = 0;
  2429.     }

  2431.     if (ev->write) {
  2432.         r->write_event_handler(r);

  2434.     } else {
  2435.         r->read_event_handler(r);
  2436.     }

  2438.     ngx_http_run_posted_requests(c);
  2439. }


  2442. void
  2443. ‌ngx_http_run_posted_requests(ngx_connection_t *c)
  2444. {
  2445.     ngx_http_request_t         *r;
  2446.     ngx_http_posted_request_t  *pr;

  2448.     for ( ;; ) {

  2450.         if (c->destroyed) {
  2451.             return;
  2452.         }

  2454.         r = c->data;
  2455.         pr = r->main->posted_requests;

  2457.         if (pr == NULL) {
  2458.             return;
  2459.         }

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

  2463.         r = pr->request;

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

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

  2470.         r->write_event_handler(r);
  2471.     }
  2472. }


  2475. ngx_int_t
  2476. ‌ngx_http_post_request(ngx_http_request_t *r, ngx_http_posted_request_t *pr)
  2477. {
  2478.     ngx_http_posted_request_t  **p;

  2480.     if (pr == NULL) {
  2481.         pr = ngx_palloc(r->pool, sizeof(ngx_http_posted_request_t));
  2482.         if (pr == NULL) {
  2483.             return NGX_ERROR;
  2484.         }
  2485.     }

  2487.     pr->request = r;
  2488.     pr->next = NULL;

  2490.     for (p = &r->main->posted_requests; *p; p = &(*p)->next) { /* void */ }

  2492.     *p = pr;

  2494.     return NGX_OK;
  2495. }


  2498. void
  2499. ‌ngx_http_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2500. {
  2501.     ngx_connection_t          *c;
  2502.     ngx_http_request_t        *pr;
  2503.     ngx_http_core_loc_conf_t  *clcf;

  2505.     c = r->connection;

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

  2511.     if (rc == NGX_DONE) {
  2512.         ngx_http_finalize_connection(r);
  2513.         return;
  2514.     }

  2516.     if (rc == NGX_OK && r->filter_finalize) {
  2517.         c->error = 1;
  2518.     }

  2520.     if (rc == NGX_DECLINED) {
  2521.         r->content_handler = NULL;
  2522.         r->write_event_handler = ngx_http_core_run_phases;
  2523.         ngx_http_core_run_phases(r);
  2524.         return;
  2525.     }

  2527.     if (r != r->main && r->post_subrequest) {
  2528.         rc = r->post_subrequest->handler(r, r->post_subrequest->data, rc);
  2529.     }

  2531.     if (rc == NGX_ERROR
  2532.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  2533.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST
  2534.         || c->error)
  2535.     {
  2536.         if (ngx_http_post_action(r) == NGX_OK) {
  2537.             return;
  2538.         }

  2540.         ngx_http_terminate_request(r, rc);
  2541.         return;
  2542.     }

  2544.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE
  2545.         || rc == NGX_HTTP_CREATED
  2546.         || rc == NGX_HTTP_NO_CONTENT)
  2547.     {
  2548.         if (rc == NGX_HTTP_CLOSE) {
  2549.             c->timedout = 1;
  2550.             ngx_http_terminate_request(r, rc);
  2551.             return;
  2552.         }

  2554.         if (r == r->main) {
  2555.             if (c->read->timer_set) {
  2556.                 ngx_del_timer(c->read);
  2557.             }

  2559.             if (c->write->timer_set) {
  2560.                 ngx_del_timer(c->write);
  2561.             }
  2562.         }

  2564.         c->read->handler = ngx_http_request_handler;
  2565.         c->write->handler = ngx_http_request_handler;

  2567.         ngx_http_finalize_request(r, ngx_http_special_response_handler(r, rc));
  2568.         return;
  2569.     }

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

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

  2575.             if (ngx_http_set_write_handler(r) != NGX_OK) {
  2576.                 ngx_http_terminate_request(r, 0);
  2577.             }

  2579.             return;
  2580.         }

  2582.         pr = r->parent;

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

  2586.             if (!r->logged) {

  2588.                 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2590.                 if (clcf->log_subrequest) {
  2591.                     ngx_http_log_request(r);
  2592.                 }

  2594.                 r->logged = 1;

  2596.             } else {
  2597.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2598.                               "subrequest: \"%V?%V\" logged again",
  2599.                               &r->uri, &r->args);
  2600.             }

  2602.             r->done = 1;

  2604.             if (r->background) {
  2605.                 ngx_http_finalize_connection(r);
  2606.                 return;
  2607.             }

  2609.             r->main->count--;

  2611.             if (pr->postponed && pr->postponed->request == r) {
  2612.                 pr->postponed = pr->postponed->next;
  2613.             }

  2615.             c->data = pr;

  2617.         } else {

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

  2623.             r->write_event_handler = ngx_http_request_finalizer;

  2625.             if (r->waited) {
  2626.                 r->done = 1;
  2627.             }
  2628.         }

  2630.         if (ngx_http_post_request(pr, NULL) != NGX_OK) {
  2631.             r->main->count++;
  2632.             ngx_http_terminate_request(r, 0);
  2633.             return;
  2634.         }

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

  2640.         return;
  2641.     }

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

  2645.         if (ngx_http_set_write_handler(r) != NGX_OK) {
  2646.             ngx_http_terminate_request(r, 0);
  2647.         }

  2649.         return;
  2650.     }

  2652.     if (r != c->data) {
  2653.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2654.                       "http finalize non-active request: \"%V?%V\"",
  2655.                       &r->uri, &r->args);
  2656.         return;
  2657.     }

  2659.     r->done = 1;

  2661.     r->read_event_handler = ngx_http_block_reading;
  2662.     r->write_event_handler = ngx_http_request_empty_handler;

  2664.     if (!r->post_action) {
  2665.         r->request_complete = 1;
  2666.     }

  2668.     if (ngx_http_post_action(r) == NGX_OK) {
  2669.         return;
  2670.     }

  2672.     if (c->read->timer_set) {
  2673.         ngx_del_timer(c->read);
  2674.     }

  2676.     if (c->write->timer_set) {
  2677.         c->write->delayed = 0;
  2678.         ngx_del_timer(c->write);
  2679.     }

  2681.     ngx_http_finalize_connection(r);
  2682. }


  2685. static void
  2686. ‌ngx_http_terminate_request(ngx_http_request_t *r, ngx_int_t rc)
  2687. {
  2688.     ngx_http_cleanup_t    *cln;
  2689.     ngx_http_request_t    *mr;
  2690.     ngx_http_ephemeral_t  *e;

  2692.     mr = r->main;

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

  2697.     mr->terminated = 1;

  2699.     if (rc > 0 && (mr->headers_out.status == 0 || mr->connection->sent == 0)) {
  2700.         mr->headers_out.status = rc;
  2701.     }

  2703.     cln = mr->cleanup;
  2704.     mr->cleanup = NULL;

  2706.     while (cln) {
  2707.         if (cln->handler) {
  2708.             cln->handler(cln->data);
  2709.         }

  2711.         cln = cln->next;
  2712.     }

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

  2718.     if (mr->write_event_handler) {

  2720.         if (mr->blocked) {
  2721.             r = r->connection->data;

  2723.             r->connection->error = 1;
  2724.             r->write_event_handler = ngx_http_request_finalizer;

  2726.             return;
  2727.         }

  2729.         e = ngx_http_ephemeral(mr);
  2730.         mr->posted_requests = NULL;
  2731.         mr->write_event_handler = ngx_http_terminate_handler;
  2732.         (void) ngx_http_post_request(mr, &e->terminal_posted_request);
  2733.         return;
  2734.     }

  2736.     ngx_http_close_request(mr, rc);
  2737. }


  2740. static void
  2741. ‌ngx_http_terminate_handler(ngx_http_request_t *r)
  2742. {
  2743.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2744.                    "http terminate handler count:%d", r->count);

  2746.     r->count = 1;

  2748.     ngx_http_close_request(r, 0);
  2749. }


  2752. static void
  2753. ‌ngx_http_finalize_connection(ngx_http_request_t *r)
  2754. {
  2755.     ngx_http_core_loc_conf_t  *clcf;

  2757. #if (NGX_HTTP_V2)
  2758.     if (r->stream) {
  2759.         ngx_http_close_request(r, 0);
  2760.         return;
  2761.     }
  2762. #endif

  2764. #if (NGX_HTTP_V3)
  2765.     if (r->connection->quic) {
  2766.         ngx_http_close_request(r, 0);
  2767.         return;
  2768.     }
  2769. #endif

  2771.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  2775.         if (r->discard_body) {
  2776.             r->read_event_handler = ngx_http_discarded_request_body_handler;
  2777.             ngx_add_timer(r->connection->read, clcf->lingering_timeout);

  2779.             if (r->lingering_time == 0) {
  2780.                 r->lingering_time = ngx_time()
  2781.                                       + (time_t) (clcf->lingering_time / 1000);
  2782.             }
  2783.         }

  2785.         ngx_http_close_request(r, 0);
  2786.         return;
  2787.     }

  2789.     r = r->main;

  2791.     if (r->connection->read->eof) {
  2792.         ngx_http_close_request(r, 0);
  2793.         return;
  2794.     }

  2796.     if (r->reading_body) {
  2797.         r->keepalive = 0;
  2798.         r->lingering_close = 1;
  2799.     }

  2801.     if (!ngx_terminate
  2802.          && !ngx_exiting
  2803.          && r->keepalive
  2804.          && clcf->keepalive_timeout > 0)
  2805.     {
  2806.         ngx_http_set_keepalive(r);
  2807.         return;
  2808.     }

  2810.     if (clcf->lingering_close == NGX_HTTP_LINGERING_ALWAYS
  2811.         || (clcf->lingering_close == NGX_HTTP_LINGERING_ON
  2812.             && (r->lingering_close
  2813.                 || r->header_in->pos < r->header_in->last
  2814.                 || r->connection->read->ready
  2815.                 || r->connection->pipeline)))
  2816.     {
  2817.         ngx_http_set_lingering_close(r->connection);
  2818.         return;
  2819.     }

  2821.     ngx_http_close_request(r, 0);
  2822. }


  2825. static ngx_int_t
  2826. ‌ngx_http_set_write_handler(ngx_http_request_t *r)
  2827. {
  2828.     ngx_event_t               *wev;
  2829.     ngx_http_core_loc_conf_t  *clcf;

  2831.     r->http_state = NGX_HTTP_WRITING_REQUEST_STATE;

  2833.     r->read_event_handler = r->discard_body ?
  2834.                                 ngx_http_discarded_request_body_handler:
  2835.                                 ngx_http_test_reading;
  2836.     r->write_event_handler = ngx_http_writer;

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

  2840.     if (wev->ready && wev->delayed) {
  2841.         return NGX_OK;
  2842.     }

  2844.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  2845.     if (!wev->delayed) {
  2846.         ngx_add_timer(wev, clcf->send_timeout);
  2847.     }

  2849.     if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  2850.         ngx_http_close_request(r, 0);
  2851.         return NGX_ERROR;
  2852.     }

  2854.     return NGX_OK;
  2855. }


  2858. static void
  2859. ‌ngx_http_writer(ngx_http_request_t *r)
  2860. {
  2861.     ngx_int_t                  rc;
  2862.     ngx_event_t               *wev;
  2863.     ngx_connection_t          *c;
  2864.     ngx_http_core_loc_conf_t  *clcf;

  2866.     c = r->connection;
  2867.     wev = c->write;

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

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

  2874.     if (wev->timedout) {
  2875.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  2876.                       "client timed out");
  2877.         c->timedout = 1;

  2879.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  2880.         return;
  2881.     }

  2883.     if (wev->delayed || r->aio) {
  2884.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0,
  2885.                        "http writer delayed");

  2887.         if (!wev->delayed) {
  2888.             ngx_add_timer(wev, clcf->send_timeout);
  2889.         }

  2891.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  2892.             ngx_http_close_request(r, 0);
  2893.         }

  2895.         return;
  2896.     }

  2898.     rc = ngx_http_output_filter(r, NULL);

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

  2904.     if (rc == NGX_ERROR) {
  2905.         ngx_http_finalize_request(r, rc);
  2906.         return;
  2907.     }

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

  2911.         if (!wev->delayed) {
  2912.             ngx_add_timer(wev, clcf->send_timeout);
  2913.         }

  2915.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  2916.             ngx_http_close_request(r, 0);
  2917.         }

  2919.         return;
  2920.     }

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

  2925.     r->write_event_handler = ngx_http_request_empty_handler;

  2927.     ngx_http_finalize_request(r, rc);
  2928. }


  2931. static void
  2932. ‌ngx_http_request_finalizer(ngx_http_request_t *r)
  2933. {
  2934.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2935.                    "http finalizer done: \"%V?%V\"", &r->uri, &r->args);

  2937.     ngx_http_finalize_request(r, 0);
  2938. }


  2941. void
  2942. ‌ngx_http_block_reading(ngx_http_request_t *r)
  2943. {
  2944.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2945.                    "http reading blocked");

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

  2949.     if ((ngx_event_flags & NGX_USE_LEVEL_EVENT)
  2950.         && r->connection->read->active)
  2951.     {
  2952.         if (ngx_del_event(r->connection->read, NGX_READ_EVENT, 0) != NGX_OK) {
  2953.             ngx_http_close_request(r, 0);
  2954.         }
  2955.     }
  2956. }


  2959. void
  2960. ‌ngx_http_test_reading(ngx_http_request_t *r)
  2961. {
  2962.     int                n;
  2963.     char               buf[1];
  2964.     ngx_err_t          err;
  2965.     ngx_event_t       *rev;
  2966.     ngx_connection_t  *c;

  2968.     c = r->connection;
  2969.     rev = c->read;

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

  2973. #if (NGX_HTTP_V2)

  2975.     if (r->stream) {
  2976.         if (c->error) {
  2977.             err = 0;
  2978.             goto closed;
  2979.         }

  2981.         return;
  2982.     }

  2984. #endif

  2986. #if (NGX_HTTP_V3)

  2988.     if (c->quic) {
  2989.         if (rev->error) {
  2990.             c->error = 1;
  2991.             err = 0;
  2992.             goto closed;
  2993.         }

  2995.         return;
  2996.     }

  2998. #endif

  3000. #if (NGX_HAVE_KQUEUE)

  3002.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  3004.         if (!rev->pending_eof) {
  3005.             return;
  3006.         }

  3008.         rev->eof = 1;
  3009.         c->error = 1;
  3010.         err = rev->kq_errno;

  3012.         goto closed;
  3013.     }

  3015. #endif

  3017. #if (NGX_HAVE_EPOLLRDHUP)

  3019.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  3020.         socklen_t  len;

  3022.         if (!rev->pending_eof) {
  3023.             return;
  3024.         }

  3026.         rev->eof = 1;
  3027.         c->error = 1;

  3029.         err = 0;
  3030.         len = sizeof(ngx_err_t);

  3032.         /*
  3033.          * BSDs and Linux return 0 and set a pending error in err
  3034.          * Solaris returns -1 and sets errno
  3035.          */

  3037.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  3038.             == -1)
  3039.         {
  3040.             err = ngx_socket_errno;
  3041.         }

  3043.         goto closed;
  3044.     }

  3046. #endif

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

  3050.     if (n == 0) {
  3051.         rev->eof = 1;
  3052.         c->error = 1;
  3053.         err = 0;

  3055.         goto closed;

  3057.     } else if (n == -1) {
  3058.         err = ngx_socket_errno;

  3060.         if (err != NGX_EAGAIN) {
  3061.             rev->eof = 1;
  3062.             c->error = 1;

  3064.             goto closed;
  3065.         }
  3066.     }

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

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

  3072.         if (ngx_del_event(rev, NGX_READ_EVENT, 0) != NGX_OK) {
  3073.             ngx_http_close_request(r, 0);
  3074.         }
  3075.     }

  3077.     return;

  3079. closed:

  3081.     if (err) {
  3082.         rev->error = 1;
  3083.     }

  3085. #if (NGX_HTTP_SSL)
  3086.     if (c->ssl) {
  3087.         c->ssl->no_send_shutdown = 1;
  3088.     }
  3089. #endif

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

  3094.     ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  3095. }


  3098. static void
  3099. ‌ngx_http_set_keepalive(ngx_http_request_t *r)
  3100. {
  3101.     int                        tcp_nodelay;
  3102.     ngx_buf_t                 *b, *f;
  3103.     ngx_chain_t               *cl, *ln;
  3104.     ngx_event_t               *rev, *wev;
  3105.     ngx_connection_t          *c;
  3106.     ngx_http_connection_t     *hc;
  3107.     ngx_http_core_loc_conf_t  *clcf;

  3109.     c = r->connection;
  3110.     rev = c->read;

  3112.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

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

  3118.     hc = r->http_connection;
  3119.     b = r->header_in;

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

  3123.         /* the pipelined request */

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

  3127.             /*
  3128.              * If the large header buffers were allocated while the previous
  3129.              * request processing then we do not use c->buffer for
  3130.              * the pipelined request (see ngx_http_create_request()).
  3131.              *
  3132.              * Now we would move the large header buffers to the free list.
  3133.              */

  3135.             for (cl = hc->busy; cl; /* void */) {
  3136.                 ln = cl;
  3137.                 cl = cl->next;

  3139.                 if (ln->buf == b) {
  3140.                     ngx_free_chain(c->pool, ln);
  3141.                     continue;
  3142.                 }

  3144.                 f = ln->buf;
  3145.                 f->pos = f->start;
  3146.                 f->last = f->start;

  3148.                 ln->next = hc->free;
  3149.                 hc->free = ln;
  3150.             }

  3152.             cl = ngx_alloc_chain_link(c->pool);
  3153.             if (cl == NULL) {
  3154.                 ngx_http_close_request(r, 0);
  3155.                 return;
  3156.             }

  3158.             cl->buf = b;
  3159.             cl->next = NULL;

  3161.             hc->busy = cl;
  3162.             hc->nbusy = 1;
  3163.         }
  3164.     }

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

  3169.     ngx_http_free_request(r, 0);

  3171.     c->data = hc;

  3173.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3174.         ngx_http_close_connection(c);
  3175.         return;
  3176.     }

  3178.     wev = c->write;
  3179.     wev->handler = ngx_http_empty_handler;

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

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

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

  3187.         r = ngx_http_create_request(c);
  3188.         if (r == NULL) {
  3189.             ngx_http_close_connection(c);
  3190.             return;
  3191.         }

  3193.         r->pipeline = 1;

  3195.         c->data = r;

  3197.         c->sent = 0;
  3198.         c->destroyed = 0;
  3199.         c->pipeline = 1;

  3201.         if (rev->timer_set) {
  3202.             ngx_del_timer(rev);
  3203.         }

  3205.         rev->handler = ngx_http_process_request_line;
  3206.         ngx_post_event(rev, &ngx_posted_events);
  3207.         return;
  3208.     }

  3210.     /*
  3211.      * To keep a memory footprint as small as possible for an idle keepalive
  3212.      * connection we try to free c->buffer's memory if it was allocated outside
  3213.      * the c->pool.  The large header buffers are always allocated outside the
  3214.      * c->pool and are freed too.
  3215.      */

  3217.     b = c->buffer;

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

  3221.         /*
  3222.          * the special note for ngx_http_keepalive_handler() that
  3223.          * c->buffer's memory was freed
  3224.          */

  3226.         b->pos = NULL;

  3228.     } else {
  3229.         b->pos = b->start;
  3230.         b->last = b->start;
  3231.     }

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

  3236.     if (hc->free) {
  3237.         for (cl = hc->free; cl; /* void */) {
  3238.             ln = cl;
  3239.             cl = cl->next;
  3240.             ngx_pfree(c->pool, ln->buf->start);
  3241.             ngx_free_chain(c->pool, ln);
  3242.         }

  3244.         hc->free = NULL;
  3245.     }

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

  3250.     if (hc->busy) {
  3251.         for (cl = hc->busy; cl; /* void */) {
  3252.             ln = cl;
  3253.             cl = cl->next;
  3254.             ngx_pfree(c->pool, ln->buf->start);
  3255.             ngx_free_chain(c->pool, ln);
  3256.         }

  3258.         hc->busy = NULL;
  3259.         hc->nbusy = 0;
  3260.     }

  3262. #if (NGX_HTTP_SSL)
  3263.     if (c->ssl) {
  3264.         ngx_ssl_free_buffer(c);
  3265.     }
  3266. #endif

  3268.     rev->handler = ngx_http_keepalive_handler;

  3270.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3271.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3272.             ngx_http_close_connection(c);
  3273.             return;
  3274.         }
  3275.     }

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

  3279.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  3280.         if (ngx_tcp_push(c->fd) == -1) {
  3281.             ngx_connection_error(c, ngx_socket_errno, ngx_tcp_push_n " failed");
  3282.             ngx_http_close_connection(c);
  3283.             return;
  3284.         }

  3286.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  3287.         tcp_nodelay = ngx_tcp_nodelay_and_tcp_nopush ? 1 : 0;

  3289.     } else {
  3290.         tcp_nodelay = 1;
  3291.     }

  3293.     if (tcp_nodelay && clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  3294.         ngx_http_close_connection(c);
  3295.         return;
  3296.     }

  3298. #if 0
  3299.     /* if ngx_http_request_t was freed then we need some other place */
  3300.     r->http_state = NGX_HTTP_KEEPALIVE_STATE;
  3301. #endif

  3303.     c->idle = 1;
  3304.     ngx_reusable_connection(c, 1);

  3306.     ngx_add_timer(rev, clcf->keepalive_timeout);

  3308.     if (rev->ready) {
  3309.         ngx_post_event(rev, &ngx_posted_events);
  3310.     }
  3311. }


  3314. static void
  3315. ‌ngx_http_keepalive_handler(ngx_event_t *rev)
  3316. {
  3317.     size_t             size;
  3318.     ssize_t            n;
  3319.     ngx_buf_t         *b;
  3320.     ngx_connection_t  *c;

  3322.     c = rev->data;

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

  3326.     if (rev->timedout || c->close) {
  3327.         ngx_http_close_connection(c);
  3328.         return;
  3329.     }

  3331. #if (NGX_HAVE_KQUEUE)

  3333.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  3334.         if (rev->pending_eof) {
  3335.             c->log->handler = NULL;
  3336.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  3337.                           "kevent() reported that client %V closed "
  3338.                           "keepalive connection", &c->addr_text);
  3339. #if (NGX_HTTP_SSL)
  3340.             if (c->ssl) {
  3341.                 c->ssl->no_send_shutdown = 1;
  3342.             }
  3343. #endif
  3344.             ngx_http_close_connection(c);
  3345.             return;
  3346.         }
  3347.     }

  3349. #endif

  3351.     b = c->buffer;
  3352.     size = b->end - b->start;

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

  3356.         /*
  3357.          * The c->buffer's memory was freed by ngx_http_set_keepalive().
  3358.          * However, the c->buffer->start and c->buffer->end were not changed
  3359.          * to keep the buffer size.
  3360.          */

  3362.         b->pos = ngx_palloc(c->pool, size);
  3363.         if (b->pos == NULL) {
  3364.             ngx_http_close_connection(c);
  3365.             return;
  3366.         }

  3368.         b->start = b->pos;
  3369.         b->last = b->pos;
  3370.         b->end = b->pos + size;
  3371.     }

  3373.     /*
  3374.      * MSIE closes a keepalive connection with RST flag
  3375.      * so we ignore ECONNRESET here.
  3376.      */

  3378.     c->log_error = NGX_ERROR_IGNORE_ECONNRESET;
  3379.     ngx_set_socket_errno(0);

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

  3384.     if (n == NGX_AGAIN) {
  3385.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3386.             ngx_http_close_connection(c);
  3387.             return;
  3388.         }

  3390.         /*
  3391.          * Like ngx_http_set_keepalive() we are trying to not hold
  3392.          * c->buffer's memory for a keepalive connection.
  3393.          */

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

  3397.             /*
  3398.              * the special note that c->buffer's memory was freed
  3399.              */

  3401.             b->pos = NULL;
  3402.         }

  3404.         return;
  3405.     }

  3407.     if (n == NGX_ERROR) {
  3408.         ngx_http_close_connection(c);
  3409.         return;
  3410.     }

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

  3414.     if (n == 0) {
  3415.         ngx_log_error(NGX_LOG_INFO, c->log, ngx_socket_errno,
  3416.                       "client %V closed keepalive connection", &c->addr_text);
  3417.         ngx_http_close_connection(c);
  3418.         return;
  3419.     }

  3421.     b->last += n;

  3423.     c->log->handler = ngx_http_log_error;
  3424.     c->log->action = "reading client request line";

  3426.     c->idle = 0;
  3427.     ngx_reusable_connection(c, 0);

  3429.     c->data = ngx_http_create_request(c);
  3430.     if (c->data == NULL) {
  3431.         ngx_http_close_connection(c);
  3432.         return;
  3433.     }

  3435.     c->sent = 0;
  3436.     c->destroyed = 0;

  3438.     ngx_del_timer(rev);

  3440.     rev->handler = ngx_http_process_request_line;
  3441.     ngx_http_process_request_line(rev);
  3442. }


  3445. static void
  3446. ‌ngx_http_set_lingering_close(ngx_connection_t *c)
  3447. {
  3448.     ngx_event_t               *rev, *wev;
  3449.     ngx_http_request_t        *r;
  3450.     ngx_http_core_loc_conf_t  *clcf;

  3452.     r = c->data;

  3454.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3456.     if (r->lingering_time == 0) {
  3457.         r->lingering_time = ngx_time() + (time_t) (clcf->lingering_time / 1000);
  3458.     }

  3460. #if (NGX_HTTP_SSL)
  3461.     if (c->ssl) {
  3462.         ngx_int_t  rc;

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

  3466.         rc = ngx_ssl_shutdown(c);

  3468.         if (rc == NGX_ERROR) {
  3469.             ngx_http_close_request(r, 0);
  3470.             return;
  3471.         }

  3473.         if (rc == NGX_AGAIN) {
  3474.             c->ssl->handler = ngx_http_set_lingering_close;
  3475.             return;
  3476.         }
  3477.     }
  3478. #endif

  3480.     rev = c->read;
  3481.     rev->handler = ngx_http_lingering_close_handler;

  3483.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3484.         ngx_http_close_request(r, 0);
  3485.         return;
  3486.     }

  3488.     wev = c->write;
  3489.     wev->handler = ngx_http_empty_handler;

  3491.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3492.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3493.             ngx_http_close_request(r, 0);
  3494.             return;
  3495.         }
  3496.     }

  3498.     if (ngx_shutdown_socket(c->fd, NGX_WRITE_SHUTDOWN) == -1) {
  3499.         ngx_connection_error(c, ngx_socket_errno,
  3500.                              ngx_shutdown_socket_n " failed");
  3501.         ngx_http_close_request(r, 0);
  3502.         return;
  3503.     }

  3505.     c->close = 0;
  3506.     ngx_reusable_connection(c, 1);

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

  3510.     if (rev->ready) {
  3511.         ngx_http_lingering_close_handler(rev);
  3512.     }
  3513. }


  3516. static void
  3517. ‌ngx_http_lingering_close_handler(ngx_event_t *rev)
  3518. {
  3519.     ssize_t                    n;
  3520.     ngx_msec_t                 timer;
  3521.     ngx_connection_t          *c;
  3522.     ngx_http_request_t        *r;
  3523.     ngx_http_core_loc_conf_t  *clcf;
  3524.     u_char                     buffer[NGX_HTTP_LINGERING_BUFFER_SIZE];

  3526.     c = rev->data;
  3527.     r = c->data;

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

  3532.     if (rev->timedout || c->close) {
  3533.         ngx_http_close_request(r, 0);
  3534.         return;
  3535.     }

  3537.     timer = (ngx_msec_t) r->lingering_time - (ngx_msec_t) ngx_time();
  3538.     if ((ngx_msec_int_t) timer <= 0) {
  3539.         ngx_http_close_request(r, 0);
  3540.         return;
  3541.     }

  3543.     do {
  3544.         n = c->recv(c, buffer, NGX_HTTP_LINGERING_BUFFER_SIZE);

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

  3548.         if (n == NGX_AGAIN) {
  3549.             break;
  3550.         }

  3552.         if (n == NGX_ERROR || n == 0) {
  3553.             ngx_http_close_request(r, 0);
  3554.             return;
  3555.         }

  3557.     } while (rev->ready);

  3559.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3560.         ngx_http_close_request(r, 0);
  3561.         return;
  3562.     }

  3564.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3566.     timer *= 1000;

  3568.     if (timer > clcf->lingering_timeout) {
  3569.         timer = clcf->lingering_timeout;
  3570.     }

  3572.     ngx_add_timer(rev, timer);
  3573. }


  3576. void
  3577. ‌ngx_http_empty_handler(ngx_event_t *wev)
  3578. {
  3579.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0, "http empty handler");

  3581.     return;
  3582. }


  3585. void
  3586. ‌ngx_http_request_empty_handler(ngx_http_request_t *r)
  3587. {
  3588.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3589.                    "http request empty handler");

  3591.     return;
  3592. }


  3595. ngx_int_t
  3596. ‌ngx_http_send_special(ngx_http_request_t *r, ngx_uint_t flags)
  3597. {
  3598.     ngx_buf_t    *b;
  3599.     ngx_chain_t   out;

  3601.     b = ngx_calloc_buf(r->pool);
  3602.     if (b == NULL) {
  3603.         return NGX_ERROR;
  3604.     }

  3606.     if (flags & NGX_HTTP_LAST) {

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

  3611.         } else {
  3612.             b->sync = 1;
  3613.             b->last_in_chain = 1;
  3614.         }
  3615.     }

  3617.     if (flags & NGX_HTTP_FLUSH) {
  3618.         b->flush = 1;
  3619.     }

  3621.     out.buf = b;
  3622.     out.next = NULL;

  3624.     return ngx_http_output_filter(r, &out);
  3625. }


  3628. static ngx_int_t
  3629. ‌ngx_http_post_action(ngx_http_request_t *r)
  3630. {
  3631.     ngx_http_core_loc_conf_t  *clcf;

  3633.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3635.     if (clcf->post_action.data == NULL) {
  3636.         return NGX_DECLINED;
  3637.     }

  3639.     if (r->post_action && r->uri_changes == 0) {
  3640.         return NGX_DECLINED;
  3641.     }

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

  3646.     r->main->count--;

  3648.     r->http_version = NGX_HTTP_VERSION_9;
  3649.     r->header_only = 1;
  3650.     r->post_action = 1;

  3652.     r->read_event_handler = ngx_http_block_reading;

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

  3657.     } else {
  3658.         ngx_http_named_location(r, &clcf->post_action);
  3659.     }

  3661.     return NGX_OK;
  3662. }


  3665. void
  3666. ‌ngx_http_close_request(ngx_http_request_t *r, ngx_int_t rc)
  3667. {
  3668.     ngx_connection_t  *c;

  3670.     r = r->main;
  3671.     c = r->connection;

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

  3676.     if (r->count == 0) {
  3677.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "http request count is zero");
  3678.     }

  3680.     r->count--;

  3682.     if (r->count || r->blocked) {
  3683.         return;
  3684.     }

  3686. #if (NGX_HTTP_V2)
  3687.     if (r->stream) {
  3688.         ngx_http_v2_close_stream(r->stream, rc);
  3689.         return;
  3690.     }
  3691. #endif

  3693.     ngx_http_free_request(r, rc);
  3694.     ngx_http_close_connection(c);
  3695. }


  3698. void
  3699. ‌ngx_http_free_request(ngx_http_request_t *r, ngx_int_t rc)
  3700. {
  3701.     ngx_log_t                 *log;
  3702.     ngx_pool_t                *pool;
  3703.     struct linger              linger;
  3704.     ngx_http_cleanup_t        *cln;
  3705.     ngx_http_log_ctx_t        *ctx;
  3706.     ngx_http_core_loc_conf_t  *clcf;

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

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

  3712.     if (r->pool == NULL) {
  3713.         ngx_log_error(NGX_LOG_ALERT, log, 0, "http request already closed");
  3714.         return;
  3715.     }

  3717.     cln = r->cleanup;
  3718.     r->cleanup = NULL;

  3720.     while (cln) {
  3721.         if (cln->handler) {
  3722.             cln->handler(cln->data);
  3723.         }

  3725.         cln = cln->next;
  3726.     }

  3728. #if (NGX_STAT_STUB)

  3730.     if (r->stat_reading) {
  3731.         (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  3732.     }

  3734.     if (r->stat_writing) {
  3735.         (void) ngx_atomic_fetch_add(ngx_stat_writing, -1);
  3736.     }

  3738. #endif

  3740.     if (rc > 0 && (r->headers_out.status == 0 || r->connection->sent == 0)) {
  3741.         r->headers_out.status = rc;
  3742.     }

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

  3747.         ngx_http_log_request(r);
  3748.     }

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

  3752.     if (r->connection->timedout
  3753. #if (NGX_HTTP_V3)
  3754.         && r->connection->quic == NULL
  3755. #endif
  3756.        )
  3757.     {
  3758.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3760.         if (clcf->reset_timedout_connection) {
  3761.             linger.l_onoff = 1;
  3762.             linger.l_linger = 0;

  3764.             if (setsockopt(r->connection->fd, SOL_SOCKET, SO_LINGER,
  3765.                            (const void *) &linger, sizeof(struct linger)) == -1)
  3766.             {
  3767.                 ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
  3768.                               "setsockopt(SO_LINGER) failed");
  3769.             }
  3770.         }
  3771.     }

  3773.     /* the various request strings were allocated from r->pool */
  3774.     ctx = log->data;
  3775.     ctx->request = NULL;

  3777.     r->request_line.len = 0;

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

  3781.     /*
  3782.      * Setting r->pool to NULL will increase probability to catch double close
  3783.      * of request since the request object is allocated from its own pool.
  3784.      */

  3786.     pool = r->pool;
  3787.     r->pool = NULL;

  3789.     ngx_destroy_pool(pool);
  3790. }


  3793. static void
  3794. ‌ngx_http_log_request(ngx_http_request_t *r)
  3795. {
  3796.     ngx_uint_t                  i, n;
  3797.     ngx_http_handler_pt        *log_handler;
  3798.     ngx_http_core_main_conf_t  *cmcf;

  3800.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  3802.     log_handler = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.elts;
  3803.     n = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.nelts;

  3805.     for (i = 0; i < n; i++) {
  3806.         log_handler[i](r);
  3807.     }
  3808. }


  3811. void
  3812. ‌ngx_http_close_connection(ngx_connection_t *c)
  3813. {
  3814.     ngx_pool_t  *pool;

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

  3819. #if (NGX_HTTP_SSL)

  3821.     if (c->ssl) {
  3822.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  3823.             c->ssl->handler = ngx_http_close_connection;
  3824.             return;
  3825.         }
  3826.     }

  3828. #endif

  3830. #if (NGX_HTTP_V3)
  3831.     if (c->quic) {
  3832.         ngx_http_v3_reset_stream(c);
  3833.     }
  3834. #endif

  3836. #if (NGX_STAT_STUB)
  3837.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  3838. #endif

  3840.     c->destroyed = 1;

  3842.     pool = c->pool;

  3844.     ngx_close_connection(c);

  3846.     ngx_destroy_pool(pool);
  3847. }


  3850. static u_char *
  3851. ‌ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len)
  3852. {
  3853.     u_char              *p;
  3854.     ngx_http_request_t  *r;
  3855.     ngx_http_log_ctx_t  *ctx;

  3857.     if (log->action) {
  3858.         p = ngx_snprintf(buf, len, " while %s", log->action);
  3859.         len -= p - buf;
  3860.         buf = p;
  3861.     }

  3863.     ctx = log->data;

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

  3868.     r = ctx->request;

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

  3873.     } else {
  3874.         p = ngx_snprintf(p, len, ", server: %V",
  3875.                          &ctx->connection->listening->addr_text);
  3876.     }

  3878.     return p;
  3879. }


  3882. static u_char *
  3883. ‌ngx_http_log_error_handler(ngx_http_request_t *r, ngx_http_request_t *sr,
  3884.     u_char *buf, size_t len)
  3885. {
  3886.     char                      *uri_separator;
  3887.     u_char                    *p;
  3888.     ngx_http_upstream_t       *u;
  3889.     ngx_http_core_srv_conf_t  *cscf;

  3891.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  3893.     p = ngx_snprintf(buf, len, ", server: %V", &cscf->server_name);
  3894.     len -= p - buf;
  3895.     buf = p;

  3897.     if (r->request_line.data == NULL && r->request_start) {
  3898.         for (p = r->request_start; p < r->header_in->last; p++) {
  3899.             if (*p == CR || *p == LF) {
  3900.                 break;
  3901.             }
  3902.         }

  3904.         r->request_line.len = p - r->request_start;
  3905.         r->request_line.data = r->request_start;
  3906.     }

  3908.     if (r->request_line.len) {
  3909.         p = ngx_snprintf(buf, len, ", request: \"%V\"", &r->request_line);
  3910.         len -= p - buf;
  3911.         buf = p;
  3912.     }

  3914.     if (r != sr) {
  3915.         p = ngx_snprintf(buf, len, ", subrequest: \"%V\"", &sr->uri);
  3916.         len -= p - buf;
  3917.         buf = p;
  3918.     }

  3920.     u = sr->upstream;

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

  3924.         uri_separator = "";

  3926. #if (NGX_HAVE_UNIX_DOMAIN)
  3927.         if (u->peer.sockaddr && u->peer.sockaddr->sa_family == AF_UNIX) {
  3928.             uri_separator = ":";
  3929.         }
  3930. #endif

  3932.         p = ngx_snprintf(buf, len, ", upstream: \"%V%V%s%V\"",
  3933.                          &u->schema, u->peer.name,
  3934.                          uri_separator, &u->uri);
  3935.         len -= p - buf;
  3936.         buf = p;
  3937.     }

  3939.     if (r->headers_in.host) {
  3940.         p = ngx_snprintf(buf, len, ", host: \"%V\"",
  3941.                          &r->headers_in.host->value);
  3942.         len -= p - buf;
  3943.         buf = p;
  3944.     }

  3946.     if (r->headers_in.referer) {
  3947.         p = ngx_snprintf(buf, len, ", referrer: \"%V\"",
  3948.                          &r->headers_in.referer->value);
  3949.         buf = p;
  3950.     }

  3952.     return buf;
  3953. }

One Level Up Top Level