One Level Up Top Level

src/http/ngx_http_request.c - nginx

Global variables defined

Data types defined

Functions defined

Source code


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


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


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

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

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

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

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

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

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


  64. ‌static char *ngx_http_client_errors[] = {

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

  231.     c->data = hc;

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

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

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

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

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

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

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

  256.             addr6 = port->addrs;

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

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

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

  268.             break;
  269. #endif

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

  274.             addr = port->addrs;

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

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

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

  286.             break;
  287.         }

  289.     } else {

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

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

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

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

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

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

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

  325.     c->log_error = NGX_ERROR_INFO;

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

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

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

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

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

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

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

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

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

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


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

  389.     c = rev->data;

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

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

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

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

  407.     size = cscf->client_header_buffer_size;

  409.     b = c->buffer;

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

  418.         c->buffer = b;

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

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

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

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

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

  437.     if (n == NGX_AGAIN) {

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

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

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

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

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

  461.         return;
  462.     }

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

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

  476.     b->last += n;

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

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

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

  488.         b->pos = p;

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

  499. #if (NGX_HTTP_V2)

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

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

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

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

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

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

  520. #endif

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

  524.     ngx_reusable_connection(c, 0);

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

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


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

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

  549.     c->requests++;

  551.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

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

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

  565.     return r;
  566. }


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

  579.     hc = c->data;

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

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

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

  594.     r->pool = pool;

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

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

  604.     r->read_event_handler = ngx_http_block_reading;

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

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

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

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

  630.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

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

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

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

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

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

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

  663.     r->http_state = NGX_HTTP_READING_REQUEST_STATE;

  665.     r->log_handler = ngx_http_log_error_handler;

  667.     return r;
  668. }


  671. #if (NGX_HTTP_SSL)

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

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

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

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

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

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

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

  708.     err = ngx_socket_errno;

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

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

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

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

  727.             return;
  728.         }

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

  733.         return;
  734.     }

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

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

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

  746.         size = p - buf;

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

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

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

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

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

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

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

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

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

  787.             ngx_reusable_connection(c, 0);

  789.             rc = ngx_ssl_handshake(c);

  791.             if (rc == NGX_AGAIN) {

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

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

  803.             ngx_http_ssl_handshake_handler(c);

  805.             return;
  806.         }

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

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

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

  815.         return;
  816.     }

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


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

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

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

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

  846.         hc = c->data;

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

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

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

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

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

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

  867.         ngx_reusable_connection(c, 1);

  869.         ngx_http_wait_request_handler(c->read);

  871.         return;
  872.     }

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

  878.     ngx_http_close_connection(c);
  879. }


  882. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  896.     c = ngx_ssl_get_connection(ssl_conn);

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

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

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

  912.     hc = c->data;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  969.     *hc->ssl_servername = host;

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

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

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

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

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

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

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

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

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

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

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

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

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

  1017. done:

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

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

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

  1030. error:

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

  1036. #endif


  1039. #ifdef SSL_R_CERT_CB_ERROR

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

  1051.     c = ngx_ssl_get_connection(ssl_conn);

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

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

  1062.     r->logged = 1;

  1064.     sscf = arg;

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

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

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

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

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

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

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

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

  1100. failed:

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

  1108. #endif

  1110. #endif


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

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

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

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

  1136.     rc = NGX_AGAIN;

  1138.     for ( ;; ) {

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

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

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

  1150.         if (rc == NGX_OK) {

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

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

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

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

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

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

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

  1177.             if (r->host_end) {

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

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

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

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

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

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

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

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

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


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

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

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

  1231.             break;
  1232.         }

  1234.         if (rc != NGX_AGAIN) {

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

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

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

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

  1248.             break;
  1249.         }

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

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

  1255.             rv = ngx_http_alloc_large_header_buffer(r, 1);

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

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

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

  1274.     ngx_http_run_posted_requests(c);
  1275. }


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

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

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

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

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

  1301.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

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

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

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

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

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

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

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

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

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

  1343.     while (p < last) {

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

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

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

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

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

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

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

  1375.         break;
  1376.     }

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

  1383.     }
  1384. #endif

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

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

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

  1395.     return NGX_OK;
  1396. }


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

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

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

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

  1426.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  1428.     rc = NGX_AGAIN;

  1430.     for ( ;; ) {

  1432.         if (rc == NGX_AGAIN) {

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

  1436.                 rv = ngx_http_alloc_large_header_buffer(r, 0);

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

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

  1446.                     r->lingering_close = 1;

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

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

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

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

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

  1472.             n = ngx_http_read_request_header(r);

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

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

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

  1485.         if (rc == NGX_OK) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1551.             continue;
  1552.         }

  1554.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

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

  1563.             r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  1565.             rc = ngx_http_process_request_header(r);

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

  1571.             ngx_http_process_request(r);

  1573.             break;
  1574.         }

  1576.         if (rc == NGX_AGAIN) {

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

  1580.             continue;
  1581.         }

  1583.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

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

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

  1594.     ngx_http_run_posted_requests(c);
  1595. }


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

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

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

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

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

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

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

  1633.         return NGX_AGAIN;
  1634.     }

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

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

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

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

  1651.     return n;
  1652. }


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

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

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

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

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

  1675.         return NGX_OK;
  1676.     }

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

  1680.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  1689.     hc = r->http_connection;

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

  1695.         b = cl->buf;

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

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

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

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

  1714.         cl->buf = b;

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

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

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

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

  1735.         r->header_in = b;

  1737.         return NGX_OK;
  1738.     }

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

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

  1749.     new = b->start;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1817.     r->header_in = b;

  1819.     return NGX_OK;
  1820. }


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

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

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

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

  1836.     return NGX_OK;
  1837. }


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

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

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

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

  1859.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);

  1861.     return NGX_ERROR;
  1862. }


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

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

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

  1886.     host = h->value;

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

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

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

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

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

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

  1913.     return NGX_OK;
  1914. }


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

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

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

  1932.     return NGX_OK;
  1933. }


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

  1947.     return NGX_OK;
  1948. }


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

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

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

  1963.     user_agent = h->value.data;

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

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

  1969.         r->headers_in.msie = 1;

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

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

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

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

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

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

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

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

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

  2018.     return NGX_OK;
  2019. }


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

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

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

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

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

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

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

  2076.             r->headers_in.chunked = 1;

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

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

  2095.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  2106.     if (r->method == NGX_HTTP_TRACE) {
  2107.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2108.                       "client sent TRACE method");
  2109.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  2110.         return NGX_ERROR;
  2111.     }

  2113.     return NGX_OK;
  2114. }


  2117. void
  2118. ‌ngx_http_process_request(ngx_http_request_t *r)
  2119. {
  2120.     ngx_connection_t  *c;

  2122.     c = r->connection;

  2124. #if (NGX_HTTP_SSL)

  2126.     if (r->http_connection->ssl) {
  2127.         long                      rc;
  2128.         X509                     *cert;
  2129.         const char               *s;
  2130.         ngx_http_ssl_srv_conf_t  *sscf;

  2132.         if (c->ssl == NULL) {
  2133.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2134.                           "client sent plain HTTP request to HTTPS port");
  2135.             ngx_http_finalize_request(r, NGX_HTTP_TO_HTTPS);
  2136.             return;
  2137.         }

  2139.         sscf = ngx_http_get_module_srv_conf(r, ngx_http_ssl_module);

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

  2144.             if (rc != X509_V_OK
  2145.                 && (sscf->verify != 3 || !ngx_ssl_verify_error_optional(rc)))
  2146.             {
  2147.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2148.                               "client SSL certificate verify error: (%l:%s)",
  2149.                               rc, X509_verify_cert_error_string(rc));

  2151.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2152.                                        (SSL_get0_session(c->ssl->connection)));

  2154.                 ngx_http_finalize_request(r, NGX_HTTPS_CERT_ERROR);
  2155.                 return;
  2156.             }

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

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

  2165.                     ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2166.                                        (SSL_get0_session(c->ssl->connection)));

  2168.                     ngx_http_finalize_request(r, NGX_HTTPS_NO_CERT);
  2169.                     return;
  2170.                 }

  2172.                 X509_free(cert);
  2173.             }

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

  2179.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  2180.                                        (SSL_get0_session(c->ssl->connection)));

  2182.                 ngx_http_finalize_request(r, NGX_HTTPS_CERT_ERROR);
  2183.                 return;
  2184.             }
  2185.         }
  2186.     }

  2188. #endif

  2190.     if (c->read->timer_set) {
  2191.         ngx_del_timer(c->read);
  2192.     }

  2194. #if (NGX_STAT_STUB)
  2195.     (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  2196.     r->stat_reading = 0;
  2197.     (void) ngx_atomic_fetch_add(ngx_stat_writing, 1);
  2198.     r->stat_writing = 1;
  2199. #endif

  2201.     c->read->handler = ngx_http_request_handler;
  2202.     c->write->handler = ngx_http_request_handler;
  2203.     r->read_event_handler = ngx_http_block_reading;

  2205.     ngx_http_handler(r);
  2206. }


  2209. ngx_int_t
  2210. ‌ngx_http_validate_host(ngx_str_t *host, in_port_t *portp, ngx_pool_t *pool,
  2211.     ngx_uint_t alloc)
  2212. {
  2213.     u_char     *h, ch;
  2214.     size_t      i, dot_pos, host_len;
  2215.     ngx_int_t   port;

  2217. ‌    enum {
  2218.         sw_host_start = 0,
  2219.         sw_host,
  2220.         sw_host_ip_literal,
  2221.         sw_host_end,
  2222.         sw_port,
  2223.     } state;

  2225.     dot_pos = host->len;
  2226.     host_len = host->len;
  2227.     port = 0;

  2229.     h = host->data;

  2231.     state = sw_host_start;

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

  2236.         switch (state) {

  2238.         case sw_host_start:

  2240.             if (ch == '[') {
  2241.                 state = sw_host_ip_literal;
  2242.                 break;
  2243.             }

  2245.             state = sw_host;

  2247.             /* fall through */

  2249.         case sw_host:

  2251.             if (ch >= 'A' && ch <= 'Z') {
  2252.                 alloc = 1;
  2253.                 break;
  2254.             }

  2256.             if (ch >= 'a' && ch <= 'z') {
  2257.                 break;
  2258.             }

  2260.             if (ch >= '0' && ch <= '9') {
  2261.                 break;
  2262.             }

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

  2302.         case sw_host_ip_literal:

  2304.             if (ch >= 'A' && ch <= 'Z') {
  2305.                 alloc = 1;
  2306.                 break;
  2307.             }

  2309.             if (ch >= 'a' && ch <= 'z') {
  2310.                 break;
  2311.             }

  2313.             if (ch >= '0' && ch <= '9') {
  2314.                 break;
  2315.             }

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

  2354.         case sw_host_end:

  2356.             if (ch == ':') {
  2357.                 state = sw_port;
  2358.                 break;
  2359.             }
  2360.             return NGX_DECLINED;

  2362.         case sw_port:

  2364.             if (ch >= '0' && ch <= '9') {
  2365.                 if (port >= 6553 && (port > 6553 || (ch - '0') > 5)) {
  2366.                     return NGX_DECLINED;
  2367.                 }

  2369.                 port = port * 10 + (ch - '0');
  2370.                 break;
  2371.             }
  2372.             return NGX_DECLINED;
  2373.         }
  2374.     }

  2376.     if (state == sw_host_ip_literal) {
  2377.         return NGX_DECLINED;
  2378.     }

  2380.     if (dot_pos == host_len - 1) {
  2381.         host_len--;
  2382.     }

  2384.     if (host_len == 0) {
  2385.         return NGX_DECLINED;
  2386.     }

  2388.     if (alloc) {
  2389.         host->data = ngx_pnalloc(pool, host_len);
  2390.         if (host->data == NULL) {
  2391.             return NGX_ERROR;
  2392.         }

  2394.         ngx_strlow(host->data, h, host_len);
  2395.     }

  2397.     host->len = host_len;

  2399.     if (portp) {
  2400.         *portp = port;
  2401.     }

  2403.     return NGX_OK;
  2404. }


  2407. ngx_int_t
  2408. ‌ngx_http_set_virtual_server(ngx_http_request_t *r, ngx_str_t *host)
  2409. {
  2410.     ngx_int_t                  rc;
  2411.     ngx_http_connection_t     *hc;
  2412.     ngx_http_core_loc_conf_t  *clcf;
  2413.     ngx_http_core_srv_conf_t  *cscf;

  2415. #if (NGX_SUPPRESS_WARN)
  2416.     cscf = NULL;
  2417. #endif

  2419.     hc = r->http_connection;

  2421. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2423.     if (hc->ssl_servername) {
  2424.         if (hc->ssl_servername->len == host->len
  2425.             && ngx_strncmp(hc->ssl_servername->data,
  2426.                            host->data, host->len) == 0)
  2427.         {
  2428. #if (NGX_PCRE)
  2429.             if (hc->ssl_servername_regex
  2430.                 && ngx_http_regex_exec(r, hc->ssl_servername_regex,
  2431.                                           hc->ssl_servername) != NGX_OK)
  2432.             {
  2433.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2434.                 return NGX_ERROR;
  2435.             }
  2436. #endif
  2437.             return NGX_OK;
  2438.         }
  2439.     }

  2441. #endif

  2443.     rc = ngx_http_find_virtual_server(r->connection,
  2444.                                       hc->addr_conf->virtual_names,
  2445.                                       host, r, &cscf);

  2447.     if (rc == NGX_ERROR) {
  2448.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2449.         return NGX_ERROR;
  2450.     }

  2452. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2454.     if (hc->ssl_servername) {
  2455.         ngx_http_ssl_srv_conf_t  *sscf;

  2457.         if (rc == NGX_DECLINED) {
  2458.             cscf = hc->addr_conf->default_server;
  2459.             rc = NGX_OK;
  2460.         }

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

  2464.         if (sscf->verify) {
  2465.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2466.                           "client attempted to request the server name "
  2467.                           "different from the one that was negotiated");
  2468.             ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  2469.             return NGX_ERROR;
  2470.         }
  2471.     }

  2473. #endif

  2475.     if (rc == NGX_DECLINED) {
  2476.         return NGX_OK;
  2477.     }

  2479.     r->srv_conf = cscf->ctx->srv_conf;
  2480.     r->loc_conf = cscf->ctx->loc_conf;

  2482.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  2486.     return NGX_OK;
  2487. }


  2490. static ngx_int_t
  2491. ‌ngx_http_find_virtual_server(ngx_connection_t *c,
  2492.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  2493.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp)
  2494. {
  2495.     ngx_http_core_srv_conf_t  *cscf;

  2497.     if (virtual_names == NULL) {
  2498.         return NGX_DECLINED;
  2499.     }

  2501.     cscf = ngx_hash_find_combined(&virtual_names->names,
  2502.                                   ngx_hash_key(host->data, host->len),
  2503.                                   host->data, host->len);

  2505.     if (cscf) {
  2506.         *cscfp = cscf;
  2507.         return NGX_OK;
  2508.     }

  2510. #if (NGX_PCRE)

  2512.     if (host->len && virtual_names->nregex) {
  2513.         ngx_int_t                n;
  2514.         ngx_uint_t               i;
  2515.         ngx_http_server_name_t  *sn;

  2517.         sn = virtual_names->regex;

  2519. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2521.         if (r == NULL) {
  2522.             ngx_http_connection_t  *hc;

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

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

  2528.                 if (n == NGX_REGEX_NO_MATCHED) {
  2529.                     continue;
  2530.                 }

  2532.                 if (n >= 0) {
  2533.                     hc = c->data;
  2534.                     hc->ssl_servername_regex = sn[i].regex;

  2536.                     *cscfp = sn[i].server;
  2537.                     return NGX_OK;
  2538.                 }

  2540.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2541.                               ngx_regex_exec_n " failed: %i "
  2542.                               "on \"%V\" using \"%V\"",
  2543.                               n, host, &sn[i].regex->name);

  2545.                 return NGX_ERROR;
  2546.             }

  2548.             return NGX_DECLINED;
  2549.         }

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

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

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

  2557.             if (n == NGX_DECLINED) {
  2558.                 continue;
  2559.             }

  2561.             if (n == NGX_OK) {
  2562.                 *cscfp = sn[i].server;
  2563.                 return NGX_OK;
  2564.             }

  2566.             return NGX_ERROR;
  2567.         }
  2568.     }

  2570. #endif /* NGX_PCRE */

  2572.     return NGX_DECLINED;
  2573. }


  2576. static void
  2577. ‌ngx_http_request_handler(ngx_event_t *ev)
  2578. {
  2579.     ngx_connection_t    *c;
  2580.     ngx_http_request_t  *r;

  2582.     c = ev->data;
  2583.     r = c->data;

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

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

  2590.     if (c->close) {
  2591.         r->main->count++;
  2592.         ngx_http_terminate_request(r, 0);
  2593.         ngx_http_run_posted_requests(c);
  2594.         return;
  2595.     }

  2597.     if (ev->delayed && ev->timedout) {
  2598.         ev->delayed = 0;
  2599.         ev->timedout = 0;
  2600.     }

  2602.     if (ev->write) {
  2603.         r->write_event_handler(r);

  2605.     } else {
  2606.         r->read_event_handler(r);
  2607.     }

  2609.     ngx_http_run_posted_requests(c);
  2610. }


  2613. void
  2614. ‌ngx_http_run_posted_requests(ngx_connection_t *c)
  2615. {
  2616.     ngx_http_request_t         *r;
  2617.     ngx_http_posted_request_t  *pr;

  2619.     for ( ;; ) {

  2621.         if (c->destroyed) {
  2622.             return;
  2623.         }

  2625.         r = c->data;
  2626.         pr = r->main->posted_requests;

  2628.         if (pr == NULL) {
  2629.             return;
  2630.         }

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

  2634.         r = pr->request;

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

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

  2641.         r->write_event_handler(r);
  2642.     }
  2643. }


  2646. ngx_int_t
  2647. ‌ngx_http_post_request(ngx_http_request_t *r, ngx_http_posted_request_t *pr)
  2648. {
  2649.     ngx_http_posted_request_t  **p;

  2651.     if (pr == NULL) {
  2652.         pr = ngx_palloc(r->pool, sizeof(ngx_http_posted_request_t));
  2653.         if (pr == NULL) {
  2654.             return NGX_ERROR;
  2655.         }
  2656.     }

  2658.     pr->request = r;
  2659.     pr->next = NULL;

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

  2663.     *p = pr;

  2665.     return NGX_OK;
  2666. }


  2669. void
  2670. ‌ngx_http_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2671. {
  2672.     ngx_connection_t          *c;
  2673.     ngx_http_request_t        *pr;
  2674.     ngx_http_core_loc_conf_t  *clcf;

  2676.     c = r->connection;

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

  2682.     if (rc == NGX_DONE) {
  2683.         ngx_http_finalize_connection(r);
  2684.         return;
  2685.     }

  2687.     if (rc == NGX_OK && r->filter_finalize) {
  2688.         c->error = 1;
  2689.     }

  2691.     if (rc == NGX_DECLINED) {
  2692.         r->content_handler = NULL;
  2693.         r->write_event_handler = ngx_http_core_run_phases;
  2694.         ngx_http_core_run_phases(r);
  2695.         return;
  2696.     }

  2698.     if (r != r->main && r->post_subrequest) {
  2699.         rc = r->post_subrequest->handler(r, r->post_subrequest->data, rc);
  2700.     }

  2702.     if (rc == NGX_ERROR
  2703.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  2704.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST
  2705.         || c->error)
  2706.     {
  2707.         if (ngx_http_post_action(r) == NGX_OK) {
  2708.             return;
  2709.         }

  2711.         ngx_http_terminate_request(r, rc);
  2712.         return;
  2713.     }

  2715.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE
  2716.         || rc == NGX_HTTP_CREATED
  2717.         || rc == NGX_HTTP_NO_CONTENT)
  2718.     {
  2719.         if (rc == NGX_HTTP_CLOSE) {
  2720.             c->timedout = 1;
  2721.             ngx_http_terminate_request(r, rc);
  2722.             return;
  2723.         }

  2725.         if (r == r->main) {
  2726.             if (c->read->timer_set) {
  2727.                 ngx_del_timer(c->read);
  2728.             }

  2730.             if (c->write->timer_set) {
  2731.                 ngx_del_timer(c->write);
  2732.             }
  2733.         }

  2735.         c->read->handler = ngx_http_request_handler;
  2736.         c->write->handler = ngx_http_request_handler;

  2738.         ngx_http_finalize_request(r, ngx_http_special_response_handler(r, rc));
  2739.         return;
  2740.     }

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

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

  2746.             if (ngx_http_set_write_handler(r) != NGX_OK) {
  2747.                 ngx_http_terminate_request(r, 0);
  2748.             }

  2750.             return;
  2751.         }

  2753.         pr = r->parent;

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

  2757.             if (!r->logged) {

  2759.                 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2761.                 if (clcf->log_subrequest) {
  2762.                     ngx_http_log_request(r);
  2763.                 }

  2765.                 r->logged = 1;

  2767.             } else {
  2768.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2769.                               "subrequest: \"%V?%V\" logged again",
  2770.                               &r->uri, &r->args);
  2771.             }

  2773.             r->done = 1;

  2775.             if (r->background) {
  2776.                 ngx_http_finalize_connection(r);
  2777.                 return;
  2778.             }

  2780.             r->main->count--;

  2782.             if (pr->postponed && pr->postponed->request == r) {
  2783.                 pr->postponed = pr->postponed->next;
  2784.             }

  2786.             c->data = pr;

  2788.         } else {

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

  2794.             r->write_event_handler = ngx_http_request_finalizer;

  2796.             if (r->waited) {
  2797.                 r->done = 1;
  2798.             }
  2799.         }

  2801.         if (ngx_http_post_request(pr, NULL) != NGX_OK) {
  2802.             r->main->count++;
  2803.             ngx_http_terminate_request(r, 0);
  2804.             return;
  2805.         }

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

  2811.         return;
  2812.     }

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

  2816.         if (ngx_http_set_write_handler(r) != NGX_OK) {
  2817.             ngx_http_terminate_request(r, 0);
  2818.         }

  2820.         return;
  2821.     }

  2823.     if (r != c->data) {
  2824.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2825.                       "http finalize non-active request: \"%V?%V\"",
  2826.                       &r->uri, &r->args);
  2827.         return;
  2828.     }

  2830.     r->done = 1;

  2832.     r->read_event_handler = ngx_http_block_reading;
  2833.     r->write_event_handler = ngx_http_request_empty_handler;

  2835.     if (!r->post_action) {
  2836.         r->request_complete = 1;
  2837.     }

  2839.     if (ngx_http_post_action(r) == NGX_OK) {
  2840.         return;
  2841.     }

  2843.     if (c->read->timer_set) {
  2844.         ngx_del_timer(c->read);
  2845.     }

  2847.     if (c->write->timer_set) {
  2848.         c->write->delayed = 0;
  2849.         ngx_del_timer(c->write);
  2850.     }

  2852.     ngx_http_finalize_connection(r);
  2853. }


  2856. static void
  2857. ‌ngx_http_terminate_request(ngx_http_request_t *r, ngx_int_t rc)
  2858. {
  2859.     ngx_http_cleanup_t    *cln;
  2860.     ngx_http_request_t    *mr;
  2861.     ngx_http_ephemeral_t  *e;

  2863.     mr = r->main;

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

  2868.     mr->terminated = 1;

  2870.     if (rc > 0 && (mr->headers_out.status == 0 || mr->connection->sent == 0)) {
  2871.         mr->headers_out.status = rc;
  2872.     }

  2874.     cln = mr->cleanup;
  2875.     mr->cleanup = NULL;

  2877.     while (cln) {
  2878.         if (cln->handler) {
  2879.             cln->handler(cln->data);
  2880.         }

  2882.         cln = cln->next;
  2883.     }

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

  2889.     if (mr->write_event_handler) {

  2891.         if (mr->blocked) {
  2892.             r = r->connection->data;

  2894.             r->connection->error = 1;
  2895.             r->write_event_handler = ngx_http_request_finalizer;

  2897.             return;
  2898.         }

  2900.         e = ngx_http_ephemeral(mr);
  2901.         mr->posted_requests = NULL;
  2902.         mr->write_event_handler = ngx_http_terminate_handler;
  2903.         (void) ngx_http_post_request(mr, &e->terminal_posted_request);
  2904.         return;
  2905.     }

  2907.     ngx_http_close_request(mr, rc);
  2908. }


  2911. static void
  2912. ‌ngx_http_terminate_handler(ngx_http_request_t *r)
  2913. {
  2914.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2915.                    "http terminate handler count:%d", r->count);

  2917.     r->count = 1;

  2919.     ngx_http_close_request(r, 0);
  2920. }


  2923. static void
  2924. ‌ngx_http_finalize_connection(ngx_http_request_t *r)
  2925. {
  2926.     ngx_http_core_loc_conf_t  *clcf;

  2928. #if (NGX_HTTP_V2)
  2929.     if (r->stream) {
  2930.         ngx_http_close_request(r, 0);
  2931.         return;
  2932.     }
  2933. #endif

  2935. #if (NGX_HTTP_V3)
  2936.     if (r->connection->quic) {
  2937.         ngx_http_close_request(r, 0);
  2938.         return;
  2939.     }
  2940. #endif

  2942.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  2946.         if (r->discard_body) {
  2947.             r->read_event_handler = ngx_http_discarded_request_body_handler;
  2948.             ngx_add_timer(r->connection->read, clcf->lingering_timeout);

  2950.             if (r->lingering_time == 0) {
  2951.                 r->lingering_time = ngx_time()
  2952.                                       + (time_t) (clcf->lingering_time / 1000);
  2953.             }
  2954.         }

  2956.         ngx_http_close_request(r, 0);
  2957.         return;
  2958.     }

  2960.     r = r->main;

  2962.     if (r->connection->read->eof) {
  2963.         ngx_http_close_request(r, 0);
  2964.         return;
  2965.     }

  2967.     if (r->reading_body) {
  2968.         r->keepalive = 0;
  2969.         r->lingering_close = 1;
  2970.     }

  2972.     if (r->keepalive
  2973.         && clcf->keepalive_min_timeout > 0)
  2974.     {
  2975.         ngx_http_set_keepalive(r);
  2976.         return;
  2977.     }

  2979.     if (!ngx_terminate
  2980.          && !ngx_exiting
  2981.          && r->keepalive
  2982.          && clcf->keepalive_timeout > 0)
  2983.     {
  2984.         ngx_http_set_keepalive(r);
  2985.         return;
  2986.     }

  2988.     if (clcf->lingering_close == NGX_HTTP_LINGERING_ALWAYS
  2989.         || (clcf->lingering_close == NGX_HTTP_LINGERING_ON
  2990.             && (r->lingering_close
  2991.                 || r->header_in->pos < r->header_in->last
  2992.                 || r->connection->read->ready
  2993.                 || r->connection->pipeline)))
  2994.     {
  2995.         ngx_http_set_lingering_close(r->connection);
  2996.         return;
  2997.     }

  2999.     ngx_http_close_request(r, 0);
  3000. }


  3003. static ngx_int_t
  3004. ‌ngx_http_set_write_handler(ngx_http_request_t *r)
  3005. {
  3006.     ngx_event_t               *wev;
  3007.     ngx_http_core_loc_conf_t  *clcf;

  3009.     r->http_state = NGX_HTTP_WRITING_REQUEST_STATE;

  3011.     r->read_event_handler = r->discard_body ?
  3012.                                 ngx_http_discarded_request_body_handler:
  3013.                                 ngx_http_test_reading;
  3014.     r->write_event_handler = ngx_http_writer;

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

  3018.     if (wev->ready && wev->delayed) {
  3019.         return NGX_OK;
  3020.     }

  3022.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  3023.     if (!wev->delayed) {
  3024.         ngx_add_timer(wev, clcf->send_timeout);
  3025.     }

  3027.     if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3028.         ngx_http_close_request(r, 0);
  3029.         return NGX_ERROR;
  3030.     }

  3032.     return NGX_OK;
  3033. }


  3036. static void
  3037. ‌ngx_http_writer(ngx_http_request_t *r)
  3038. {
  3039.     ngx_int_t                  rc;
  3040.     ngx_event_t               *wev;
  3041.     ngx_connection_t          *c;
  3042.     ngx_http_core_loc_conf_t  *clcf;

  3044.     c = r->connection;
  3045.     wev = c->write;

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

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

  3052.     if (wev->timedout) {
  3053.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  3054.                       "client timed out");
  3055.         c->timedout = 1;

  3057.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  3058.         return;
  3059.     }

  3061.     if (wev->delayed || r->aio) {
  3062.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0,
  3063.                        "http writer delayed");

  3065.         if (!wev->delayed) {
  3066.             ngx_add_timer(wev, clcf->send_timeout);
  3067.         }

  3069.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3070.             ngx_http_close_request(r, 0);
  3071.         }

  3073.         return;
  3074.     }

  3076.     rc = ngx_http_output_filter(r, NULL);

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

  3082.     if (rc == NGX_ERROR) {
  3083.         ngx_http_finalize_request(r, rc);
  3084.         return;
  3085.     }

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

  3089.         if (!wev->delayed) {
  3090.             ngx_add_timer(wev, clcf->send_timeout);
  3091.         }

  3093.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  3094.             ngx_http_close_request(r, 0);
  3095.         }

  3097.         return;
  3098.     }

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

  3103.     r->write_event_handler = ngx_http_request_empty_handler;

  3105.     ngx_http_finalize_request(r, rc);
  3106. }


  3109. static void
  3110. ‌ngx_http_request_finalizer(ngx_http_request_t *r)
  3111. {
  3112.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3113.                    "http finalizer done: \"%V?%V\"", &r->uri, &r->args);

  3115.     ngx_http_finalize_request(r, 0);
  3116. }


  3119. void
  3120. ‌ngx_http_block_reading(ngx_http_request_t *r)
  3121. {
  3122.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3123.                    "http reading blocked");

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

  3127.     if ((ngx_event_flags & NGX_USE_LEVEL_EVENT)
  3128.         && r->connection->read->active)
  3129.     {
  3130.         if (ngx_del_event(r->connection->read, NGX_READ_EVENT, 0) != NGX_OK) {
  3131.             ngx_http_close_request(r, 0);
  3132.         }
  3133.     }
  3134. }


  3137. void
  3138. ‌ngx_http_test_reading(ngx_http_request_t *r)
  3139. {
  3140.     int                n;
  3141.     char               buf[1];
  3142.     ngx_err_t          err;
  3143.     ngx_event_t       *rev;
  3144.     ngx_connection_t  *c;

  3146.     c = r->connection;
  3147.     rev = c->read;

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

  3151. #if (NGX_HTTP_V2)

  3153.     if (r->stream) {
  3154.         if (c->error) {
  3155.             err = 0;
  3156.             goto closed;
  3157.         }

  3159.         return;
  3160.     }

  3162. #endif

  3164. #if (NGX_HTTP_V3)

  3166.     if (c->quic) {
  3167.         if (rev->error) {
  3168.             c->error = 1;
  3169.             err = 0;
  3170.             goto closed;
  3171.         }

  3173.         return;
  3174.     }

  3176. #endif

  3178. #if (NGX_HAVE_KQUEUE)

  3180.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  3182.         if (!rev->pending_eof) {
  3183.             return;
  3184.         }

  3186.         rev->eof = 1;
  3187.         c->error = 1;
  3188.         err = rev->kq_errno;

  3190.         goto closed;
  3191.     }

  3193. #endif

  3195. #if (NGX_HAVE_EPOLLRDHUP)

  3197.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  3198.         socklen_t  len;

  3200.         if (!rev->pending_eof) {
  3201.             return;
  3202.         }

  3204.         rev->eof = 1;
  3205.         c->error = 1;

  3207.         err = 0;
  3208.         len = sizeof(ngx_err_t);

  3210.         /*
  3211.          * BSDs and Linux return 0 and set a pending error in err
  3212.          * Solaris returns -1 and sets errno
  3213.          */

  3215.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  3216.             == -1)
  3217.         {
  3218.             err = ngx_socket_errno;
  3219.         }

  3221.         goto closed;
  3222.     }

  3224. #endif

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

  3228.     if (n == 0) {
  3229.         rev->eof = 1;
  3230.         c->error = 1;
  3231.         err = 0;

  3233.         goto closed;

  3235.     } else if (n == -1) {
  3236.         err = ngx_socket_errno;

  3238.         if (err != NGX_EAGAIN) {
  3239.             rev->eof = 1;
  3240.             c->error = 1;

  3242.             goto closed;
  3243.         }
  3244.     }

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

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

  3250.         if (ngx_del_event(rev, NGX_READ_EVENT, 0) != NGX_OK) {
  3251.             ngx_http_close_request(r, 0);
  3252.         }
  3253.     }

  3255.     return;

  3257. closed:

  3259.     if (err) {
  3260.         rev->error = 1;
  3261.     }

  3263. #if (NGX_HTTP_SSL)
  3264.     if (c->ssl) {
  3265.         c->ssl->no_send_shutdown = 1;
  3266.     }
  3267. #endif

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

  3272.     ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  3273. }


  3276. static void
  3277. ‌ngx_http_set_keepalive(ngx_http_request_t *r)
  3278. {
  3279.     int                        tcp_nodelay;
  3280.     ngx_buf_t                 *b, *f;
  3281.     ngx_chain_t               *cl, *ln;
  3282.     ngx_event_t               *rev, *wev;
  3283.     ngx_connection_t          *c;
  3284.     ngx_http_connection_t     *hc;
  3285.     ngx_http_core_loc_conf_t  *clcf;

  3287.     c = r->connection;
  3288.     rev = c->read;

  3290.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

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

  3296.     hc = r->http_connection;
  3297.     b = r->header_in;

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

  3301.         /* the pipelined request */

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

  3305.             /*
  3306.              * If the large header buffers were allocated while the previous
  3307.              * request processing then we do not use c->buffer for
  3308.              * the pipelined request (see ngx_http_create_request()).
  3309.              *
  3310.              * Now we would move the large header buffers to the free list.
  3311.              */

  3313.             for (cl = hc->busy; cl; /* void */) {
  3314.                 ln = cl;
  3315.                 cl = cl->next;

  3317.                 if (ln->buf == b) {
  3318.                     ngx_free_chain(c->pool, ln);
  3319.                     continue;
  3320.                 }

  3322.                 f = ln->buf;
  3323.                 f->pos = f->start;
  3324.                 f->last = f->start;

  3326.                 ln->next = hc->free;
  3327.                 hc->free = ln;
  3328.             }

  3330.             cl = ngx_alloc_chain_link(c->pool);
  3331.             if (cl == NULL) {
  3332.                 ngx_http_close_request(r, 0);
  3333.                 return;
  3334.             }

  3336.             cl->buf = b;
  3337.             cl->next = NULL;

  3339.             hc->busy = cl;
  3340.             hc->nbusy = 1;
  3341.         }
  3342.     }

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

  3347.     ngx_http_free_request(r, 0);

  3349.     c->data = hc;

  3351.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3352.         ngx_http_close_connection(c);
  3353.         return;
  3354.     }

  3356.     wev = c->write;
  3357.     wev->handler = ngx_http_empty_handler;

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

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

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

  3365.         r = ngx_http_create_request(c);
  3366.         if (r == NULL) {
  3367.             ngx_http_close_connection(c);
  3368.             return;
  3369.         }

  3371.         r->pipeline = 1;

  3373.         c->data = r;

  3375.         c->sent = 0;
  3376.         c->destroyed = 0;
  3377.         c->pipeline = 1;

  3379.         if (rev->timer_set) {
  3380.             ngx_del_timer(rev);
  3381.         }

  3383.         rev->handler = ngx_http_process_request_line;
  3384.         ngx_post_event(rev, &ngx_posted_events);
  3385.         return;
  3386.     }

  3388.     /*
  3389.      * To keep a memory footprint as small as possible for an idle keepalive
  3390.      * connection we try to free c->buffer's memory if it was allocated outside
  3391.      * the c->pool.  The large header buffers are always allocated outside the
  3392.      * c->pool and are freed too.
  3393.      */

  3395.     b = c->buffer;

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

  3399.         /*
  3400.          * the special note for ngx_http_keepalive_handler() that
  3401.          * c->buffer's memory was freed
  3402.          */

  3404.         b->pos = NULL;

  3406.     } else {
  3407.         b->pos = b->start;
  3408.         b->last = b->start;
  3409.     }

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

  3414.     if (hc->free) {
  3415.         for (cl = hc->free; cl; /* void */) {
  3416.             ln = cl;
  3417.             cl = cl->next;
  3418.             ngx_pfree(c->pool, ln->buf->start);
  3419.             ngx_free_chain(c->pool, ln);
  3420.         }

  3422.         hc->free = NULL;
  3423.     }

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

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

  3436.         hc->busy = NULL;
  3437.         hc->nbusy = 0;
  3438.     }

  3440. #if (NGX_HTTP_SSL)
  3441.     if (c->ssl) {
  3442.         ngx_ssl_free_buffer(c);
  3443.     }
  3444. #endif

  3446.     rev->handler = ngx_http_keepalive_handler;

  3448.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3449.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3450.             ngx_http_close_connection(c);
  3451.             return;
  3452.         }
  3453.     }

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

  3457.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  3458.         if (ngx_tcp_push(c->fd) == -1) {
  3459.             ngx_connection_error(c, ngx_socket_errno, ngx_tcp_push_n " failed");
  3460.             ngx_http_close_connection(c);
  3461.             return;
  3462.         }

  3464.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  3465.         tcp_nodelay = ngx_tcp_nodelay_and_tcp_nopush ? 1 : 0;

  3467.     } else {
  3468.         tcp_nodelay = 1;
  3469.     }

  3471.     if (tcp_nodelay && clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  3472.         ngx_http_close_connection(c);
  3473.         return;
  3474.     }

  3476. #if 0
  3477.     /* if ngx_http_request_t was freed then we need some other place */
  3478.     r->http_state = NGX_HTTP_KEEPALIVE_STATE;
  3479. #endif

  3481.     if (clcf->keepalive_min_timeout == 0) {
  3482.         c->idle = 1;
  3483.         ngx_reusable_connection(c, 1);
  3484.     }

  3486.     if (clcf->keepalive_min_timeout > 0
  3487.         && clcf->keepalive_timeout > clcf->keepalive_min_timeout)
  3488.     {
  3489.         hc->keepalive_timeout = clcf->keepalive_timeout
  3490.                                 - clcf->keepalive_min_timeout;

  3492.     } else {
  3493.         hc->keepalive_timeout = 0;
  3494.     }

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

  3498.     if (rev->ready) {
  3499.         ngx_post_event(rev, &ngx_posted_events);
  3500.     }
  3501. }


  3504. static void
  3505. ‌ngx_http_keepalive_handler(ngx_event_t *rev)
  3506. {
  3507.     size_t                  size;
  3508.     ssize_t                 n;
  3509.     ngx_buf_t              *b;
  3510.     ngx_connection_t       *c;
  3511.     ngx_http_connection_t  *hc;

  3513.     c = rev->data;
  3514.     hc = c->data;

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

  3518.     if (!ngx_terminate
  3519.          && !ngx_exiting
  3520.          && rev->timedout
  3521.          && hc->keepalive_timeout > 0)
  3522.     {
  3523.         c->idle = 1;
  3524.         ngx_reusable_connection(c, 1);

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

  3528.         hc->keepalive_timeout = 0;
  3529.         rev->timedout = 0;
  3530.         return;
  3531.     }

  3533.     if (rev->timedout || c->close) {
  3534.         ngx_http_close_connection(c);
  3535.         return;
  3536.     }

  3538. #if (NGX_HAVE_KQUEUE)

  3540.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  3541.         if (rev->pending_eof) {
  3542.             c->log->handler = NULL;
  3543.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  3544.                           "kevent() reported that client %V closed "
  3545.                           "keepalive connection", &c->addr_text);
  3546. #if (NGX_HTTP_SSL)
  3547.             if (c->ssl) {
  3548.                 c->ssl->no_send_shutdown = 1;
  3549.             }
  3550. #endif
  3551.             ngx_http_close_connection(c);
  3552.             return;
  3553.         }
  3554.     }

  3556. #endif

  3558.     b = c->buffer;
  3559.     size = b->end - b->start;

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

  3563.         /*
  3564.          * The c->buffer's memory was freed by ngx_http_set_keepalive().
  3565.          * However, the c->buffer->start and c->buffer->end were not changed
  3566.          * to keep the buffer size.
  3567.          */

  3569.         b->pos = ngx_palloc(c->pool, size);
  3570.         if (b->pos == NULL) {
  3571.             ngx_http_close_connection(c);
  3572.             return;
  3573.         }

  3575.         b->start = b->pos;
  3576.         b->last = b->pos;
  3577.         b->end = b->pos + size;
  3578.     }

  3580.     /*
  3581.      * MSIE closes a keepalive connection with RST flag
  3582.      * so we ignore ECONNRESET here.
  3583.      */

  3585.     c->log_error = NGX_ERROR_IGNORE_ECONNRESET;
  3586.     ngx_set_socket_errno(0);

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

  3591.     if (n == NGX_AGAIN) {
  3592.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3593.             ngx_http_close_connection(c);
  3594.             return;
  3595.         }

  3597.         /*
  3598.          * Like ngx_http_set_keepalive() we are trying to not hold
  3599.          * c->buffer's memory for a keepalive connection.
  3600.          */

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

  3604.             /*
  3605.              * the special note that c->buffer's memory was freed
  3606.              */

  3608.             b->pos = NULL;
  3609.         }

  3611.         return;
  3612.     }

  3614.     if (n == NGX_ERROR) {
  3615.         ngx_http_close_connection(c);
  3616.         return;
  3617.     }

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

  3621.     if (n == 0) {
  3622.         ngx_log_error(NGX_LOG_INFO, c->log, ngx_socket_errno,
  3623.                       "client %V closed keepalive connection", &c->addr_text);
  3624.         ngx_http_close_connection(c);
  3625.         return;
  3626.     }

  3628.     b->last += n;

  3630.     c->log->handler = ngx_http_log_error;
  3631.     c->log->action = "reading client request line";

  3633.     c->idle = 0;
  3634.     ngx_reusable_connection(c, 0);

  3636.     c->data = ngx_http_create_request(c);
  3637.     if (c->data == NULL) {
  3638.         ngx_http_close_connection(c);
  3639.         return;
  3640.     }

  3642.     c->sent = 0;
  3643.     c->destroyed = 0;

  3645.     ngx_del_timer(rev);

  3647.     rev->handler = ngx_http_process_request_line;
  3648.     ngx_http_process_request_line(rev);
  3649. }


  3652. static void
  3653. ‌ngx_http_set_lingering_close(ngx_connection_t *c)
  3654. {
  3655.     ngx_event_t               *rev, *wev;
  3656.     ngx_http_request_t        *r;
  3657.     ngx_http_core_loc_conf_t  *clcf;

  3659.     r = c->data;

  3661.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3663.     if (r->lingering_time == 0) {
  3664.         r->lingering_time = ngx_time() + (time_t) (clcf->lingering_time / 1000);
  3665.     }

  3667. #if (NGX_HTTP_SSL)
  3668.     if (c->ssl) {
  3669.         ngx_int_t  rc;

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

  3673.         rc = ngx_ssl_shutdown(c);

  3675.         if (rc == NGX_ERROR) {
  3676.             ngx_http_close_request(r, 0);
  3677.             return;
  3678.         }

  3680.         if (rc == NGX_AGAIN) {
  3681.             c->ssl->handler = ngx_http_set_lingering_close;
  3682.             return;
  3683.         }
  3684.     }
  3685. #endif

  3687.     rev = c->read;
  3688.     rev->handler = ngx_http_lingering_close_handler;

  3690.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3691.         ngx_http_close_request(r, 0);
  3692.         return;
  3693.     }

  3695.     wev = c->write;
  3696.     wev->handler = ngx_http_empty_handler;

  3698.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3699.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3700.             ngx_http_close_request(r, 0);
  3701.             return;
  3702.         }
  3703.     }

  3705.     if (ngx_shutdown_socket(c->fd, NGX_WRITE_SHUTDOWN) == -1) {
  3706.         ngx_connection_error(c, ngx_socket_errno,
  3707.                              ngx_shutdown_socket_n " failed");
  3708.         ngx_http_close_request(r, 0);
  3709.         return;
  3710.     }

  3712.     c->close = 0;
  3713.     ngx_reusable_connection(c, 1);

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

  3717.     if (rev->ready) {
  3718.         ngx_http_lingering_close_handler(rev);
  3719.     }
  3720. }


  3723. static void
  3724. ‌ngx_http_lingering_close_handler(ngx_event_t *rev)
  3725. {
  3726.     ssize_t                    n;
  3727.     ngx_msec_t                 timer;
  3728.     ngx_connection_t          *c;
  3729.     ngx_http_request_t        *r;
  3730.     ngx_http_core_loc_conf_t  *clcf;
  3731.     u_char                     buffer[NGX_HTTP_LINGERING_BUFFER_SIZE];

  3733.     c = rev->data;
  3734.     r = c->data;

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

  3739.     if (rev->timedout || c->close) {
  3740.         ngx_http_close_request(r, 0);
  3741.         return;
  3742.     }

  3744.     timer = (ngx_msec_t) r->lingering_time - (ngx_msec_t) ngx_time();
  3745.     if ((ngx_msec_int_t) timer <= 0) {
  3746.         ngx_http_close_request(r, 0);
  3747.         return;
  3748.     }

  3750.     do {
  3751.         n = c->recv(c, buffer, NGX_HTTP_LINGERING_BUFFER_SIZE);

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

  3755.         if (n == NGX_AGAIN) {
  3756.             break;
  3757.         }

  3759.         if (n == NGX_ERROR || n == 0) {
  3760.             ngx_http_close_request(r, 0);
  3761.             return;
  3762.         }

  3764.     } while (rev->ready);

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

  3771.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3773.     timer *= 1000;

  3775.     if (timer > clcf->lingering_timeout) {
  3776.         timer = clcf->lingering_timeout;
  3777.     }

  3779.     ngx_add_timer(rev, timer);
  3780. }


  3783. void
  3784. ‌ngx_http_empty_handler(ngx_event_t *wev)
  3785. {
  3786.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0, "http empty handler");

  3788.     return;
  3789. }


  3792. void
  3793. ‌ngx_http_request_empty_handler(ngx_http_request_t *r)
  3794. {
  3795.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3796.                    "http request empty handler");

  3798.     return;
  3799. }


  3802. ngx_int_t
  3803. ‌ngx_http_send_special(ngx_http_request_t *r, ngx_uint_t flags)
  3804. {
  3805.     ngx_buf_t    *b;
  3806.     ngx_chain_t   out;

  3808.     b = ngx_calloc_buf(r->pool);
  3809.     if (b == NULL) {
  3810.         return NGX_ERROR;
  3811.     }

  3813.     if (flags & NGX_HTTP_LAST) {

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

  3818.         } else {
  3819.             b->sync = 1;
  3820.             b->last_in_chain = 1;
  3821.         }
  3822.     }

  3824.     if (flags & NGX_HTTP_FLUSH) {
  3825.         b->flush = 1;
  3826.     }

  3828.     out.buf = b;
  3829.     out.next = NULL;

  3831.     return ngx_http_output_filter(r, &out);
  3832. }


  3835. static ngx_int_t
  3836. ‌ngx_http_post_action(ngx_http_request_t *r)
  3837. {
  3838.     ngx_http_core_loc_conf_t  *clcf;

  3840.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3842.     if (clcf->post_action.data == NULL) {
  3843.         return NGX_DECLINED;
  3844.     }

  3846.     if (r->post_action && r->uri_changes == 0) {
  3847.         return NGX_DECLINED;
  3848.     }

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

  3853.     r->main->count--;

  3855.     r->http_version = NGX_HTTP_VERSION_9;
  3856.     r->header_only = 1;
  3857.     r->post_action = 1;

  3859.     r->read_event_handler = ngx_http_block_reading;

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

  3864.     } else {
  3865.         ngx_http_named_location(r, &clcf->post_action);
  3866.     }

  3868.     return NGX_OK;
  3869. }


  3872. void
  3873. ‌ngx_http_close_request(ngx_http_request_t *r, ngx_int_t rc)
  3874. {
  3875.     ngx_connection_t  *c;

  3877.     r = r->main;
  3878.     c = r->connection;

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

  3883.     if (r->count == 0) {
  3884.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "http request count is zero");
  3885.     }

  3887.     r->count--;

  3889.     if (r->count || r->blocked) {
  3890.         return;
  3891.     }

  3893. #if (NGX_HTTP_V2)
  3894.     if (r->stream) {
  3895.         ngx_http_v2_close_stream(r->stream, rc);
  3896.         return;
  3897.     }
  3898. #endif

  3900.     ngx_http_free_request(r, rc);
  3901.     ngx_http_close_connection(c);
  3902. }


  3905. void
  3906. ‌ngx_http_free_request(ngx_http_request_t *r, ngx_int_t rc)
  3907. {
  3908.     ngx_log_t                 *log;
  3909.     ngx_pool_t                *pool;
  3910.     struct linger              linger;
  3911.     ngx_http_cleanup_t        *cln;
  3912.     ngx_http_log_ctx_t        *ctx;
  3913.     ngx_http_core_loc_conf_t  *clcf;

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

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

  3919.     if (r->pool == NULL) {
  3920.         ngx_log_error(NGX_LOG_ALERT, log, 0, "http request already closed");
  3921.         return;
  3922.     }

  3924.     cln = r->cleanup;
  3925.     r->cleanup = NULL;

  3927.     while (cln) {
  3928.         if (cln->handler) {
  3929.             cln->handler(cln->data);
  3930.         }

  3932.         cln = cln->next;
  3933.     }

  3935. #if (NGX_STAT_STUB)

  3937.     if (r->stat_reading) {
  3938.         (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  3939.     }

  3941.     if (r->stat_writing) {
  3942.         (void) ngx_atomic_fetch_add(ngx_stat_writing, -1);
  3943.     }

  3945. #endif

  3947.     if (rc > 0 && (r->headers_out.status == 0 || r->connection->sent == 0)) {
  3948.         r->headers_out.status = rc;
  3949.     }

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

  3954.         ngx_http_log_request(r);
  3955.     }

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

  3959.     if (r->connection->timedout
  3960. #if (NGX_HTTP_V3)
  3961.         && r->connection->quic == NULL
  3962. #endif
  3963.        )
  3964.     {
  3965.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3967.         if (clcf->reset_timedout_connection) {
  3968.             linger.l_onoff = 1;
  3969.             linger.l_linger = 0;

  3971.             if (setsockopt(r->connection->fd, SOL_SOCKET, SO_LINGER,
  3972.                            (const void *) &linger, sizeof(struct linger)) == -1)
  3973.             {
  3974.                 ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
  3975.                               "setsockopt(SO_LINGER) failed");
  3976.             }
  3977.         }
  3978.     }

  3980.     /* the various request strings were allocated from r->pool */
  3981.     ctx = log->data;
  3982.     ctx->request = NULL;

  3984.     r->request_line.len = 0;

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

  3988.     /*
  3989.      * Setting r->pool to NULL will increase probability to catch double close
  3990.      * of request since the request object is allocated from its own pool.
  3991.      */

  3993.     pool = r->pool;
  3994.     r->pool = NULL;

  3996.     ngx_destroy_pool(pool);
  3997. }


  4000. static void
  4001. ‌ngx_http_log_request(ngx_http_request_t *r)
  4002. {
  4003.     ngx_uint_t                  i, n;
  4004.     ngx_http_handler_pt        *log_handler;
  4005.     ngx_http_core_main_conf_t  *cmcf;

  4007.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  4009.     log_handler = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.elts;
  4010.     n = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.nelts;

  4012.     for (i = 0; i < n; i++) {
  4013.         log_handler[i](r);
  4014.     }
  4015. }


  4018. void
  4019. ‌ngx_http_close_connection(ngx_connection_t *c)
  4020. {
  4021.     ngx_pool_t  *pool;

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

  4026. #if (NGX_HTTP_SSL)

  4028.     if (c->ssl) {
  4029.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  4030.             c->ssl->handler = ngx_http_close_connection;
  4031.             return;
  4032.         }
  4033.     }

  4035. #endif

  4037. #if (NGX_HTTP_V3)
  4038.     if (c->quic) {
  4039.         ngx_http_v3_reset_stream(c);
  4040.     }
  4041. #endif

  4043. #if (NGX_STAT_STUB)
  4044.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  4045. #endif

  4047.     c->destroyed = 1;

  4049.     pool = c->pool;

  4051.     ngx_close_connection(c);

  4053.     ngx_destroy_pool(pool);
  4054. }


  4057. static u_char *
  4058. ‌ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len)
  4059. {
  4060.     u_char              *p;
  4061.     ngx_http_request_t  *r;
  4062.     ngx_http_log_ctx_t  *ctx;

  4064.     if (log->action) {
  4065.         p = ngx_snprintf(buf, len, " while %s", log->action);
  4066.         len -= p - buf;
  4067.         buf = p;
  4068.     }

  4070.     ctx = log->data;

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

  4075.     r = ctx->request;

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

  4080.     } else {
  4081.         p = ngx_snprintf(p, len, ", server: %V",
  4082.                          &ctx->connection->listening->addr_text);
  4083.     }

  4085.     return p;
  4086. }


  4089. static u_char *
  4090. ‌ngx_http_log_error_handler(ngx_http_request_t *r, ngx_http_request_t *sr,
  4091.     u_char *buf, size_t len)
  4092. {
  4093.     char                      *uri_separator;
  4094.     u_char                    *p;
  4095.     ngx_http_upstream_t       *u;
  4096.     ngx_http_core_srv_conf_t  *cscf;

  4098.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  4100.     p = ngx_snprintf(buf, len, ", server: %V", &cscf->server_name);
  4101.     len -= p - buf;
  4102.     buf = p;

  4104.     if (r->request_line.data == NULL && r->request_start) {
  4105.         for (p = r->request_start; p < r->header_in->last; p++) {
  4106.             if (*p == CR || *p == LF) {
  4107.                 break;
  4108.             }
  4109.         }

  4111.         r->request_line.len = p - r->request_start;
  4112.         r->request_line.data = r->request_start;
  4113.     }

  4115.     if (r->request_line.len) {
  4116.         p = ngx_snprintf(buf, len, ", request: \"%V\"", &r->request_line);
  4117.         len -= p - buf;
  4118.         buf = p;
  4119.     }

  4121.     if (r != sr) {
  4122.         p = ngx_snprintf(buf, len, ", subrequest: \"%V\"", &sr->uri);
  4123.         len -= p - buf;
  4124.         buf = p;
  4125.     }

  4127.     u = sr->upstream;

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

  4131.         uri_separator = "";

  4133. #if (NGX_HAVE_UNIX_DOMAIN)
  4134.         if (u->peer.sockaddr && u->peer.sockaddr->sa_family == AF_UNIX) {
  4135.             uri_separator = ":";
  4136.         }
  4137. #endif

  4139.         p = ngx_snprintf(buf, len, ", upstream: \"%V%V%s%V\"",
  4140.                          &u->schema, u->peer.name,
  4141.                          uri_separator, &u->uri);
  4142.         len -= p - buf;
  4143.         buf = p;
  4144.     }

  4146.     if (r->headers_in.host) {
  4147.         p = ngx_snprintf(buf, len, ", host: \"%V\"",
  4148.                          &r->headers_in.host->value);
  4149.         len -= p - buf;
  4150.         buf = p;
  4151.     }

  4153.     if (r->headers_in.referer) {
  4154.         p = ngx_snprintf(buf, len, ", referrer: \"%V\"",
  4155.                          &r->headers_in.referer->value);
  4156.         buf = p;
  4157.     }

  4159.     return buf;
  4160. }

One Level Up Top Level