One Level Up Top Level

src/http/ngx_http_request.c - nginx-1.7.10

Global variables 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 void ngx_http_process_request_line(ngx_event_t *rev);
  15. static void ngx_http_process_request_headers(ngx_event_t *rev);
  16. static ssize_t ngx_http_read_request_header(ngx_http_request_t *r);
  17. static ngx_int_t ngx_http_alloc_large_header_buffer(ngx_http_request_t *r,
  18.     ngx_uint_t request_line);

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

  33. static ngx_int_t ngx_http_validate_host(ngx_str_t *host, ngx_pool_t *pool,
  34.     ngx_uint_t alloc);
  35. static ngx_int_t ngx_http_set_virtual_server(ngx_http_request_t *r,
  36.     ngx_str_t *host);
  37. static ngx_int_t ngx_http_find_virtual_server(ngx_connection_t *c,
  38.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  39.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp);

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

  49. static void ngx_http_set_keepalive(ngx_http_request_t *r);
  50. static void ngx_http_keepalive_handler(ngx_event_t *ev);
  51. static void ngx_http_set_lingering_close(ngx_http_request_t *r);
  52. static void ngx_http_lingering_close_handler(ngx_event_t *ev);
  53. static ngx_int_t ngx_http_post_action(ngx_http_request_t *r);
  54. static void ngx_http_close_request(ngx_http_request_t *r, ngx_int_t error);
  55. static void ngx_http_log_request(ngx_http_request_t *r);

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

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


  67. ‌static char *ngx_http_client_errors[] = {

  69.     /* NGX_HTTP_PARSE_INVALID_METHOD */
  70.     "client sent invalid method",

  72.     /* NGX_HTTP_PARSE_INVALID_REQUEST */
  73.     "client sent invalid request",

  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("If-Modified-Since"),
  88.                  offsetof(ngx_http_headers_in_t, if_modified_since),
  89.                  ngx_http_process_unique_header_line },

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

  95.     { ngx_string("If-Match"),
  96.                  offsetof(ngx_http_headers_in_t, if_match),
  97.                  ngx_http_process_unique_header_line },

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

  103.     { ngx_string("User-Agent"), offsetof(ngx_http_headers_in_t, user_agent),
  104.                  ngx_http_process_user_agent },

  106.     { ngx_string("Referer"), offsetof(ngx_http_headers_in_t, referer),
  107.                  ngx_http_process_header_line },

  109.     { ngx_string("Content-Length"),
  110.                  offsetof(ngx_http_headers_in_t, content_length),
  111.                  ngx_http_process_unique_header_line },

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

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

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

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

  128.     { ngx_string("Expect"),
  129.                  offsetof(ngx_http_headers_in_t, expect),
  130.                  ngx_http_process_unique_header_line },

  132.     { ngx_string("Upgrade"),
  133.                  offsetof(ngx_http_headers_in_t, upgrade),
  134.                  ngx_http_process_header_line },

  136. #if (NGX_HTTP_GZIP)
  137.     { ngx_string("Accept-Encoding"),
  138.                  offsetof(ngx_http_headers_in_t, accept_encoding),
  139.                  ngx_http_process_header_line },

  141.     { ngx_string("Via"), offsetof(ngx_http_headers_in_t, via),
  142.                  ngx_http_process_header_line },
  143. #endif

  145.     { ngx_string("Authorization"),
  146.                  offsetof(ngx_http_headers_in_t, authorization),
  147.                  ngx_http_process_unique_header_line },

  149.     { ngx_string("Keep-Alive"), offsetof(ngx_http_headers_in_t, keep_alive),
  150.                  ngx_http_process_header_line },

  152. #if (NGX_HTTP_X_FORWARDED_FOR)
  153.     { ngx_string("X-Forwarded-For"),
  154.                  offsetof(ngx_http_headers_in_t, x_forwarded_for),
  155.                  ngx_http_process_multi_header_lines },
  156. #endif

  158. #if (NGX_HTTP_REALIP)
  159.     { ngx_string("X-Real-IP"),
  160.                  offsetof(ngx_http_headers_in_t, x_real_ip),
  161.                  ngx_http_process_header_line },
  162. #endif

  164. #if (NGX_HTTP_HEADERS)
  165.     { ngx_string("Accept"), offsetof(ngx_http_headers_in_t, accept),
  166.                  ngx_http_process_header_line },

  168.     { ngx_string("Accept-Language"),
  169.                  offsetof(ngx_http_headers_in_t, accept_language),
  170.                  ngx_http_process_header_line },
  171. #endif

  173. #if (NGX_HTTP_DAV)
  174.     { ngx_string("Depth"), offsetof(ngx_http_headers_in_t, depth),
  175.                  ngx_http_process_header_line },

  177.     { ngx_string("Destination"), offsetof(ngx_http_headers_in_t, destination),
  178.                  ngx_http_process_header_line },

  180.     { ngx_string("Overwrite"), offsetof(ngx_http_headers_in_t, overwrite),
  181.                  ngx_http_process_header_line },

  183.     { ngx_string("Date"), offsetof(ngx_http_headers_in_t, date),
  184.                  ngx_http_process_header_line },
  185. #endif

  187.     { ngx_string("Cookie"), offsetof(ngx_http_headers_in_t, cookies),
  188.                  ngx_http_process_multi_header_lines },

  190.     { ngx_null_string, 0, NULL }
  191. };


  194. void
  195. ‌ngx_http_init_connection(ngx_connection_t *c)
  196. {
  197.     ngx_uint_t              i;
  198.     ngx_event_t            *rev;
  199.     struct sockaddr_in     *sin;
  200.     ngx_http_port_t        *port;
  201.     ngx_http_in_addr_t     *addr;
  202.     ngx_http_log_ctx_t     *ctx;
  203.     ngx_http_connection_t  *hc;
  204. #if (NGX_HAVE_INET6)
  205.     struct sockaddr_in6    *sin6;
  206.     ngx_http_in6_addr_t    *addr6;
  207. #endif

  209.     hc = ngx_pcalloc(c->pool, sizeof(ngx_http_connection_t));
  210.     if (hc == NULL) {
  211.         ngx_http_close_connection(c);
  212.         return;
  213.     }

  215.     c->data = hc;

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

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

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

  223.         /*
  224.          * there are several addresses on this port and one of them
  225.          * is an "*:port" wildcard so getsockname() in ngx_http_server_addr()
  226.          * is required to determine a server address
  227.          */

  229.         if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
  230.             ngx_http_close_connection(c);
  231.             return;
  232.         }

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

  236. #if (NGX_HAVE_INET6)
  237.         case AF_INET6:
  238.             sin6 = (struct sockaddr_in6 *) c->local_sockaddr;

  240.             addr6 = port->addrs;

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

  244.             for (i = 0; i < port->naddrs - 1; i++) {
  245.                 if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16) == 0) {
  246.                     break;
  247.                 }
  248.             }

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

  252.             break;
  253. #endif

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

  258.             addr = port->addrs;

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

  262.             for (i = 0; i < port->naddrs - 1; i++) {
  263.                 if (addr[i].addr == sin->sin_addr.s_addr) {
  264.                     break;
  265.                 }
  266.             }

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

  270.             break;
  271.         }

  273.     } else {

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

  277. #if (NGX_HAVE_INET6)
  278.         case AF_INET6:
  279.             addr6 = port->addrs;
  280.             hc->addr_conf = &addr6[0].conf;
  281.             break;
  282. #endif

  284.         default: /* AF_INET */
  285.             addr = port->addrs;
  286.             hc->addr_conf = &addr[0].conf;
  287.             break;
  288.         }
  289.     }

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

  294.     ctx = ngx_palloc(c->pool, sizeof(ngx_http_log_ctx_t));
  295.     if (ctx == NULL) {
  296.         ngx_http_close_connection(c);
  297.         return;
  298.     }

  300.     ctx->connection = c;
  301.     ctx->request = NULL;
  302.     ctx->current_request = NULL;

  304.     c->log->connection = c->number;
  305.     c->log->handler = ngx_http_log_error;
  306.     c->log->data = ctx;
  307.     c->log->action = "waiting for request";

  309.     c->log_error = NGX_ERROR_INFO;

  311.     rev = c->read;
  312.     rev->handler = ngx_http_wait_request_handler;
  313.     c->write->handler = ngx_http_empty_handler;

  315. #if (NGX_HTTP_SPDY)
  316.     if (hc->addr_conf->spdy) {
  317.         rev->handler = ngx_http_spdy_init;
  318.     }
  319. #endif

  321. #if (NGX_HTTP_SSL)
  322.     {
  323.     ngx_http_ssl_srv_conf_t  *sscf;

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

  327.     if (sscf->enable || hc->addr_conf->ssl) {

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

  331.         if (hc->addr_conf->ssl && sscf->ssl.ctx == NULL) {
  332.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  333.                           "no \"ssl_certificate\" is defined "
  334.                           "in server listening on SSL port");
  335.             ngx_http_close_connection(c);
  336.             return;
  337.         }

  339.         hc->ssl = 1;

  341.         rev->handler = ngx_http_ssl_handshake;
  342.     }
  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(), rtsig, aio, 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.     ngx_add_timer(rev, c->listening->post_accept_timeout);
  364.     ngx_reusable_connection(c, 1);

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


  373. static void
  374. ‌ngx_http_wait_request_handler(ngx_event_t *rev)
  375. {
  376.     u_char                    *p;
  377.     size_t                     size;
  378.     ssize_t                    n;
  379.     ngx_buf_t                 *b;
  380.     ngx_connection_t          *c;
  381.     ngx_http_connection_t     *hc;
  382.     ngx_http_core_srv_conf_t  *cscf;

  384.     c = rev->data;

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

  388.     if (rev->timedout) {
  389.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  390.         ngx_http_close_connection(c);
  391.         return;
  392.     }

  394.     if (c->close) {
  395.         ngx_http_close_connection(c);
  396.         return;
  397.     }

  399.     hc = c->data;
  400.     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_core_module);

  402.     size = cscf->client_header_buffer_size;

  404.     b = c->buffer;

  406.     if (b == NULL) {
  407.         b = ngx_create_temp_buf(c->pool, size);
  408.         if (b == NULL) {
  409.             ngx_http_close_connection(c);
  410.             return;
  411.         }

  413.         c->buffer = b;

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

  417.         b->start = ngx_palloc(c->pool, size);
  418.         if (b->start == NULL) {
  419.             ngx_http_close_connection(c);
  420.             return;
  421.         }

  423.         b->pos = b->start;
  424.         b->last = b->start;
  425.         b->end = b->last + size;
  426.     }

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

  430.     if (n == NGX_AGAIN) {

  432.         if (!rev->timer_set) {
  433.             ngx_add_timer(rev, c->listening->post_accept_timeout);
  434.             ngx_reusable_connection(c, 1);
  435.         }

  437.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  438.             ngx_http_close_connection(c);
  439.             return;
  440.         }

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

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

  450.         return;
  451.     }

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

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

  465.     b->last += n;

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

  470.         p = ngx_proxy_protocol_parse(c, b->pos, b->last);

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

  477.         b->pos = p;

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

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

  490.     ngx_reusable_connection(c, 0);

  492.     c->data = ngx_http_create_request(c);
  493.     if (c->data == NULL) {
  494.         ngx_http_close_connection(c);
  495.         return;
  496.     }

  498.     rev->handler = ngx_http_process_request_line;
  499.     ngx_http_process_request_line(rev);
  500. }


  503. ngx_http_request_t *
  504. ‌ngx_http_create_request(ngx_connection_t *c)
  505. {
  506.     ngx_pool_t                 *pool;
  507.     ngx_time_t                 *tp;
  508.     ngx_http_request_t         *r;
  509.     ngx_http_log_ctx_t         *ctx;
  510.     ngx_http_connection_t      *hc;
  511.     ngx_http_core_srv_conf_t   *cscf;
  512.     ngx_http_core_loc_conf_t   *clcf;
  513.     ngx_http_core_main_conf_t  *cmcf;

  515.     c->requests++;

  517.     hc = c->data;

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

  521.     pool = ngx_create_pool(cscf->request_pool_size, c->log);
  522.     if (pool == NULL) {
  523.         return NULL;
  524.     }

  526.     r = ngx_pcalloc(pool, sizeof(ngx_http_request_t));
  527.     if (r == NULL) {
  528.         ngx_destroy_pool(pool);
  529.         return NULL;
  530.     }

  532.     r->pool = pool;

  534.     r->http_connection = hc;
  535.     r->signature = NGX_HTTP_MODULE;
  536.     r->connection = c;

  538.     r->main_conf = hc->conf_ctx->main_conf;
  539.     r->srv_conf = hc->conf_ctx->srv_conf;
  540.     r->loc_conf = hc->conf_ctx->loc_conf;

  542.     r->read_event_handler = ngx_http_block_reading;

  544.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  546.     ngx_http_set_connection_log(r->connection, clcf->error_log);

  548.     r->header_in = hc->nbusy ? hc->busy[0] : c->buffer;

  550.     if (ngx_list_init(&r->headers_out.headers, r->pool, 20,
  551.                       sizeof(ngx_table_elt_t))
  552.         != NGX_OK)
  553.     {
  554.         ngx_destroy_pool(r->pool);
  555.         return NULL;
  556.     }

  558.     r->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);
  559.     if (r->ctx == NULL) {
  560.         ngx_destroy_pool(r->pool);
  561.         return NULL;
  562.     }

  564.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  566.     r->variables = ngx_pcalloc(r->pool, cmcf->variables.nelts
  567.                                         * sizeof(ngx_http_variable_value_t));
  568.     if (r->variables == NULL) {
  569.         ngx_destroy_pool(r->pool);
  570.         return NULL;
  571.     }

  573. #if (NGX_HTTP_SSL)
  574.     if (c->ssl) {
  575.         r->main_filter_need_in_memory = 1;
  576.     }
  577. #endif

  579.     r->main = r;
  580.     r->count = 1;

  582.     tp = ngx_timeofday();
  583.     r->start_sec = tp->sec;
  584.     r->start_msec = tp->msec;

  586.     r->method = NGX_HTTP_UNKNOWN;
  587.     r->http_version = NGX_HTTP_VERSION_10;

  589.     r->headers_in.content_length_n = -1;
  590.     r->headers_in.keep_alive_n = -1;
  591.     r->headers_out.content_length_n = -1;
  592.     r->headers_out.last_modified_time = -1;

  594.     r->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;
  595.     r->subrequests = NGX_HTTP_MAX_SUBREQUESTS + 1;

  597.     r->http_state = NGX_HTTP_READING_REQUEST_STATE;

  599.     ctx = c->log->data;
  600.     ctx->request = r;
  601.     ctx->current_request = r;
  602.     r->log_handler = ngx_http_log_error_handler;

  604. #if (NGX_STAT_STUB)
  605.     (void) ngx_atomic_fetch_add(ngx_stat_reading, 1);
  606.     r->stat_reading = 1;
  607.     (void) ngx_atomic_fetch_add(ngx_stat_requests, 1);
  608. #endif

  610.     return r;
  611. }


  614. #if (NGX_HTTP_SSL)

  616. static void
  617. ‌ngx_http_ssl_handshake(ngx_event_t *rev)
  618. {
  619.     u_char                   *p, buf[NGX_PROXY_PROTOCOL_MAX_HEADER + 1];
  620.     size_t                    size;
  621.     ssize_t                   n;
  622.     ngx_err_t                 err;
  623.     ngx_int_t                 rc;
  624.     ngx_connection_t         *c;
  625.     ngx_http_connection_t    *hc;
  626.     ngx_http_ssl_srv_conf_t  *sscf;

  628.     c = rev->data;
  629.     hc = c->data;

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

  634.     if (rev->timedout) {
  635.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  636.         ngx_http_close_connection(c);
  637.         return;
  638.     }

  640.     if (c->close) {
  641.         ngx_http_close_connection(c);
  642.         return;
  643.     }

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

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

  649.     err = ngx_socket_errno;

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

  653.     if (n == -1) {
  654.         if (err == NGX_EAGAIN) {

  656.             if (!rev->timer_set) {
  657.                 ngx_add_timer(rev, c->listening->post_accept_timeout);
  658.                 ngx_reusable_connection(c, 1);
  659.             }

  661.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  662.                 ngx_http_close_connection(c);
  663.             }

  665.             return;
  666.         }

  668.         ngx_connection_error(c, err, "recv() failed");
  669.         ngx_http_close_connection(c);

  671.         return;
  672.     }

  674.     if (hc->proxy_protocol) {
  675.         hc->proxy_protocol = 0;

  677.         p = ngx_proxy_protocol_parse(c, buf, buf + n);

  679.         if (p == NULL) {
  680.             ngx_http_close_connection(c);
  681.             return;
  682.         }

  684.         size = p - buf;

  686.         if (c->recv(c, buf, size) != (ssize_t) size) {
  687.             ngx_http_close_connection(c);
  688.             return;
  689.         }

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

  693.         if (n == (ssize_t) size) {
  694.             ngx_post_event(rev, &ngx_posted_events);
  695.             return;
  696.         }

  698.         n = 1;
  699.         buf[0] = *p;
  700.     }

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

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

  710.             if (ngx_ssl_create_connection(&sscf->ssl, c, NGX_SSL_BUFFER)
  711.                 != NGX_OK)
  712.             {
  713.                 ngx_http_close_connection(c);
  714.                 return;
  715.             }

  717.             rc = ngx_ssl_handshake(c);

  719.             if (rc == NGX_AGAIN) {

  721.                 if (!rev->timer_set) {
  722.                     ngx_add_timer(rev, c->listening->post_accept_timeout);
  723.                 }

  725.                 ngx_reusable_connection(c, 0);

  727.                 c->ssl->handler = ngx_http_ssl_handshake_handler;
  728.                 return;
  729.             }

  731.             ngx_http_ssl_handshake_handler(c);

  733.             return;
  734.         }

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

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

  740.         rev->handler = ngx_http_wait_request_handler;
  741.         ngx_http_wait_request_handler(rev);

  743.         return;
  744.     }

  746.     ngx_log_error(NGX_LOG_INFO, c->log, 0, "client closed connection");
  747.     ngx_http_close_connection(c);
  748. }


  751. static void
  752. ‌ngx_http_ssl_handshake_handler(ngx_connection_t *c)
  753. {
  754.     if (c->ssl->handshaked) {

  756.         /*
  757.          * The majority of browsers do not send the "close notify" alert.
  758.          * Among them are MSIE, old Mozilla, Netscape 4, Konqueror,
  759.          * and Links.  And what is more, MSIE ignores the server's alert.
  760.          *
  761.          * Opera and recent Mozilla send the alert.
  762.          */

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

  766. #if (NGX_HTTP_SPDY                                                            \
  767.      && (defined TLSEXT_TYPE_application_layer_protocol_negotiation           \
  768.          || defined TLSEXT_TYPE_next_proto_neg))
  769.         {
  770.         unsigned int             len;
  771.         const unsigned char     *data;
  772.         static const ngx_str_t   spdy = ngx_string(NGX_SPDY_NPN_NEGOTIATED);

  774. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
  775.         SSL_get0_alpn_selected(c->ssl->connection, &data, &len);

  777. #ifdef TLSEXT_TYPE_next_proto_neg
  778.         if (len == 0) {
  779.             SSL_get0_next_proto_negotiated(c->ssl->connection, &data, &len);
  780.         }
  781. #endif

  783. #else /* TLSEXT_TYPE_next_proto_neg */
  784.         SSL_get0_next_proto_negotiated(c->ssl->connection, &data, &len);
  785. #endif

  787.         if (len == spdy.len && ngx_strncmp(data, spdy.data, spdy.len) == 0) {
  788.             ngx_http_spdy_init(c->read);
  789.             return;
  790.         }
  791.         }
  792. #endif

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

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

  799.         ngx_reusable_connection(c, 1);

  801.         ngx_http_wait_request_handler(c->read);

  803.         return;
  804.     }

  806.     if (c->read->timedout) {
  807.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  808.     }

  810.     ngx_http_close_connection(c);
  811. }

  813. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  815. int
  816. ‌ngx_http_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg)
  817. {
  818.     ngx_str_t                  host;
  819.     const char                *servername;
  820.     ngx_connection_t          *c;
  821.     ngx_http_connection_t     *hc;
  822.     ngx_http_ssl_srv_conf_t   *sscf;
  823.     ngx_http_core_loc_conf_t  *clcf;
  824.     ngx_http_core_srv_conf_t  *cscf;

  826.     servername = SSL_get_servername(ssl_conn, TLSEXT_NAMETYPE_host_name);

  828.     if (servername == NULL) {
  829.         return SSL_TLSEXT_ERR_NOACK;
  830.     }

  832.     c = ngx_ssl_get_connection(ssl_conn);

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

  837.     host.len = ngx_strlen(servername);

  839.     if (host.len == 0) {
  840.         return SSL_TLSEXT_ERR_NOACK;
  841.     }

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

  845.     if (ngx_http_validate_host(&host, c->pool, 1) != NGX_OK) {
  846.         return SSL_TLSEXT_ERR_NOACK;
  847.     }

  849.     hc = c->data;

  851.     if (ngx_http_find_virtual_server(c, hc->addr_conf->virtual_names, &host,
  852.                                      NULL, &cscf)
  853.         != NGX_OK)
  854.     {
  855.         return SSL_TLSEXT_ERR_NOACK;
  856.     }

  858.     hc->ssl_servername = ngx_palloc(c->pool, sizeof(ngx_str_t));
  859.     if (hc->ssl_servername == NULL) {
  860.         return SSL_TLSEXT_ERR_NOACK;
  861.     }

  863.     *hc->ssl_servername = host;

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

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

  869.     ngx_http_set_connection_log(c, clcf->error_log);

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

  873.     if (sscf->ssl.ctx) {
  874.         SSL_set_SSL_CTX(ssl_conn, sscf->ssl.ctx);

  876.         /*
  877.          * SSL_set_SSL_CTX() only changes certs as of 1.0.0d
  878.          * adjust other things we care about
  879.          */

  881.         SSL_set_verify(ssl_conn, SSL_CTX_get_verify_mode(sscf->ssl.ctx),
  882.                        SSL_CTX_get_verify_callback(sscf->ssl.ctx));

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

  886. #ifdef SSL_CTRL_CLEAR_OPTIONS
  887.         /* only in 0.9.8m+ */
  888.         SSL_clear_options(ssl_conn, SSL_get_options(ssl_conn) &
  889.                                     ~SSL_CTX_get_options(sscf->ssl.ctx));
  890. #endif

  892.         SSL_set_options(ssl_conn, SSL_CTX_get_options(sscf->ssl.ctx));
  893.     }

  895.     return SSL_TLSEXT_ERR_OK;
  896. }

  898. #endif

  900. #endif


  903. static void
  904. ‌ngx_http_process_request_line(ngx_event_t *rev)
  905. {
  906.     ssize_t              n;
  907.     ngx_int_t            rc, rv;
  908.     ngx_str_t            host;
  909.     ngx_connection_t    *c;
  910.     ngx_http_request_t  *r;

  912.     c = rev->data;
  913.     r = c->data;

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

  918.     if (rev->timedout) {
  919.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  920.         c->timedout = 1;
  921.         ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  922.         return;
  923.     }

  925.     rc = NGX_AGAIN;

  927.     for ( ;; ) {

  929.         if (rc == NGX_AGAIN) {
  930.             n = ngx_http_read_request_header(r);

  932.             if (n == NGX_AGAIN || n == NGX_ERROR) {
  933.                 return;
  934.             }
  935.         }

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

  939.         if (rc == NGX_OK) {

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

  943.             r->request_line.len = r->request_end - r->request_start;
  944.             r->request_line.data = r->request_start;
  945.             r->request_length = r->header_in->pos - r->request_start;

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

  950.             r->method_name.len = r->method_end - r->request_start + 1;
  951.             r->method_name.data = r->request_line.data;

  953.             if (r->http_protocol.data) {
  954.                 r->http_protocol.len = r->request_end - r->http_protocol.data;
  955.             }

  957.             if (ngx_http_process_request_uri(r) != NGX_OK) {
  958.                 return;
  959.             }

  961.             if (r->host_start && r->host_end) {

  963.                 host.len = r->host_end - r->host_start;
  964.                 host.data = r->host_start;

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

  968.                 if (rc == NGX_DECLINED) {
  969.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  970.                                   "client sent invalid host in request line");
  971.                     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  972.                     return;
  973.                 }

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

  980.                 if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
  981.                     return;
  982.                 }

  984.                 r->headers_in.server = host;
  985.             }

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

  989.                 if (r->headers_in.server.len == 0
  990.                     && ngx_http_set_virtual_server(r, &r->headers_in.server)
  991.                        == NGX_ERROR)
  992.                 {
  993.                     return;
  994.                 }

  996.                 ngx_http_process_request(r);
  997.                 return;
  998.             }


  1001.             if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  1002.                               sizeof(ngx_table_elt_t))
  1003.                 != NGX_OK)
  1004.             {
  1005.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1006.                 return;
  1007.             }

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

  1011.             rev->handler = ngx_http_process_request_headers;
  1012.             ngx_http_process_request_headers(rev);

  1014.             return;
  1015.         }

  1017.         if (rc != NGX_AGAIN) {

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

  1021.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1022.                           ngx_http_client_errors[rc - NGX_HTTP_CLIENT_ERROR]);
  1023.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1024.             return;
  1025.         }

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

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

  1031.             rv = ngx_http_alloc_large_header_buffer(r, 1);

  1033.             if (rv == NGX_ERROR) {
  1034.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1035.                 return;
  1036.             }

  1038.             if (rv == NGX_DECLINED) {
  1039.                 r->request_line.len = r->header_in->end - r->request_start;
  1040.                 r->request_line.data = r->request_start;

  1042.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1043.                               "client sent too long URI");
  1044.                 ngx_http_finalize_request(r, NGX_HTTP_REQUEST_URI_TOO_LARGE);
  1045.                 return;
  1046.             }
  1047.         }
  1048.     }
  1049. }


  1052. ngx_int_t
  1053. ‌ngx_http_process_request_uri(ngx_http_request_t *r)
  1054. {
  1055.     ngx_http_core_srv_conf_t  *cscf;

  1057.     if (r->args_start) {
  1058.         r->uri.len = r->args_start - 1 - r->uri_start;
  1059.     } else {
  1060.         r->uri.len = r->uri_end - r->uri_start;
  1061.     }

  1063.     if (r->complex_uri || r->quoted_uri) {

  1065.         r->uri.data = ngx_pnalloc(r->pool, r->uri.len + 1);
  1066.         if (r->uri.data == NULL) {
  1067.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1068.             return NGX_ERROR;
  1069.         }

  1071.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  1076.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1077.                           "client sent invalid request");
  1078.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1079.             return NGX_ERROR;
  1080.         }

  1082.     } else {
  1083.         r->uri.data = r->uri_start;
  1084.     }

  1086.     r->unparsed_uri.len = r->uri_end - r->uri_start;
  1087.     r->unparsed_uri.data = r->uri_start;

  1089.     r->valid_unparsed_uri = r->space_in_uri ? 0 : 1;

  1091.     if (r->uri_ext) {
  1092.         if (r->args_start) {
  1093.             r->exten.len = r->args_start - 1 - r->uri_ext;
  1094.         } else {
  1095.             r->exten.len = r->uri_end - r->uri_ext;
  1096.         }

  1098.         r->exten.data = r->uri_ext;
  1099.     }

  1101.     if (r->args_start && r->uri_end > r->args_start) {
  1102.         r->args.len = r->uri_end - r->args_start;
  1103.         r->args.data = r->args_start;
  1104.     }

  1106. #if (NGX_WIN32)
  1107.     {
  1108.     u_char  *p, *last;

  1110.     p = r->uri.data;
  1111.     last = r->uri.data + r->uri.len;

  1113.     while (p < last) {

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

  1117.             /*
  1118.              * this check covers "::$data", "::$index_allocation" and
  1119.              * ":$i30:$index_allocation"
  1120.              */

  1122.             if (p < last && *p == '$') {
  1123.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1124.                               "client sent unsafe win32 URI");
  1125.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1126.                 return NGX_ERROR;
  1127.             }
  1128.         }
  1129.     }

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

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

  1135.         if (*p == ' ') {
  1136.             p--;
  1137.             continue;
  1138.         }

  1140.         if (*p == '.') {
  1141.             p--;
  1142.             continue;
  1143.         }

  1145.         break;
  1146.     }

  1148.     if (p != r->uri.data + r->uri.len - 1) {
  1149.         r->uri.len = p + 1 - r->uri.data;
  1150.         ngx_http_set_exten(r);
  1151.     }

  1153.     }
  1154. #endif

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

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

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

  1165.     return NGX_OK;
  1166. }


  1169. static void
  1170. ‌ngx_http_process_request_headers(ngx_event_t *rev)
  1171. {
  1172.     u_char                     *p;
  1173.     size_t                      len;
  1174.     ssize_t                     n;
  1175.     ngx_int_t                   rc, rv;
  1176.     ngx_table_elt_t            *h;
  1177.     ngx_connection_t           *c;
  1178.     ngx_http_header_t          *hh;
  1179.     ngx_http_request_t         *r;
  1180.     ngx_http_core_srv_conf_t   *cscf;
  1181.     ngx_http_core_main_conf_t  *cmcf;

  1183.     c = rev->data;
  1184.     r = c->data;

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

  1189.     if (rev->timedout) {
  1190.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  1191.         c->timedout = 1;
  1192.         ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  1193.         return;
  1194.     }

  1196.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  1198.     rc = NGX_AGAIN;

  1200.     for ( ;; ) {

  1202.         if (rc == NGX_AGAIN) {

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

  1206.                 rv = ngx_http_alloc_large_header_buffer(r, 0);

  1208.                 if (rv == NGX_ERROR) {
  1209.                     ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1210.                     return;
  1211.                 }

  1213.                 if (rv == NGX_DECLINED) {
  1214.                     p = r->header_name_start;

  1216.                     r->lingering_close = 1;

  1218.                     if (p == NULL) {
  1219.                         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1220.                                       "client sent too large request");
  1221.                         ngx_http_finalize_request(r,
  1222.                                             NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  1223.                         return;
  1224.                     }

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

  1228.                     if (len > NGX_MAX_ERROR_STR - 300) {
  1229.                         len = NGX_MAX_ERROR_STR - 300;
  1230.                     }

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

  1236.                     ngx_http_finalize_request(r,
  1237.                                             NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  1238.                     return;
  1239.                 }
  1240.             }

  1242.             n = ngx_http_read_request_header(r);

  1244.             if (n == NGX_AGAIN || n == NGX_ERROR) {
  1245.                 return;
  1246.             }
  1247.         }

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

  1252.         rc = ngx_http_parse_header_line(r, r->header_in,
  1253.                                         cscf->underscores_in_headers);

  1255.         if (rc == NGX_OK) {

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

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

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

  1263.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1264.                               "client sent invalid header line: \"%*s\"",
  1265.                               r->header_end - r->header_name_start,
  1266.                               r->header_name_start);
  1267.                 continue;
  1268.             }

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

  1272.             h = ngx_list_push(&r->headers_in.headers);
  1273.             if (h == NULL) {
  1274.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1275.                 return;
  1276.             }

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

  1280.             h->key.len = r->header_name_end - r->header_name_start;
  1281.             h->key.data = r->header_name_start;
  1282.             h->key.data[h->key.len] = '\0';

  1284.             h->value.len = r->header_end - r->header_start;
  1285.             h->value.data = r->header_start;
  1286.             h->value.data[h->value.len] = '\0';

  1288.             h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
  1289.             if (h->lowcase_key == NULL) {
  1290.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1291.                 return;
  1292.             }

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

  1297.             } else {
  1298.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1299.             }

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

  1304.             if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1305.                 return;
  1306.             }

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

  1312.             continue;
  1313.         }

  1315.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

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

  1324.             r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  1326.             rc = ngx_http_process_request_header(r);

  1328.             if (rc != NGX_OK) {
  1329.                 return;
  1330.             }

  1332.             ngx_http_process_request(r);

  1334.             return;
  1335.         }

  1337.         if (rc == NGX_AGAIN) {

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

  1341.             continue;
  1342.         }

  1344.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER: "\r" is not followed by "\n" */

  1346.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1347.                       "client sent invalid header line: \"%*s\\r...\"",
  1348.                       r->header_end - r->header_name_start,
  1349.                       r->header_name_start);
  1350.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1351.         return;
  1352.     }
  1353. }


  1356. static ssize_t
  1357. ‌ngx_http_read_request_header(ngx_http_request_t *r)
  1358. {
  1359.     ssize_t                    n;
  1360.     ngx_event_t               *rev;
  1361.     ngx_connection_t          *c;
  1362.     ngx_http_core_srv_conf_t  *cscf;

  1364.     c = r->connection;
  1365.     rev = c->read;

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

  1369.     if (n > 0) {
  1370.         return n;
  1371.     }

  1373.     if (rev->ready) {
  1374.         n = c->recv(c, r->header_in->last,
  1375.                     r->header_in->end - r->header_in->last);
  1376.     } else {
  1377.         n = NGX_AGAIN;
  1378.     }

  1380.     if (n == NGX_AGAIN) {
  1381.         if (!rev->timer_set) {
  1382.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  1383.             ngx_add_timer(rev, cscf->client_header_timeout);
  1384.         }

  1386.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  1387.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1388.             return NGX_ERROR;
  1389.         }

  1391.         return NGX_AGAIN;
  1392.     }

  1394.     if (n == 0) {
  1395.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1396.                       "client prematurely closed connection");
  1397.     }

  1399.     if (n == 0 || n == NGX_ERROR) {
  1400.         c->error = 1;
  1401.         c->log->action = "reading client request headers";

  1403.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1404.         return NGX_ERROR;
  1405.     }

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

  1409.     return n;
  1410. }


  1413. static ngx_int_t
  1414. ‌ngx_http_alloc_large_header_buffer(ngx_http_request_t *r,
  1415.     ngx_uint_t request_line)
  1416. {
  1417.     u_char                    *old, *new;
  1418.     ngx_buf_t                 *b;
  1419.     ngx_http_connection_t     *hc;
  1420.     ngx_http_core_srv_conf_t  *cscf;

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

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

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

  1429.         r->header_in->pos = r->header_in->start;
  1430.         r->header_in->last = r->header_in->start;

  1432.         return NGX_OK;
  1433.     }

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

  1437.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1439.     if (r->state != 0
  1440.         && (size_t) (r->header_in->pos - old)
  1441.                                      >= cscf->large_client_header_buffers.size)
  1442.     {
  1443.         return NGX_DECLINED;
  1444.     }

  1446.     hc = r->http_connection;

  1448.     if (hc->nfree) {
  1449.         b = hc->free[--hc->nfree];

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

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

  1457.         if (hc->busy == NULL) {
  1458.             hc->busy = ngx_palloc(r->connection->pool,
  1459.                   cscf->large_client_header_buffers.num * sizeof(ngx_buf_t *));
  1460.             if (hc->busy == NULL) {
  1461.                 return NGX_ERROR;
  1462.             }
  1463.         }

  1465.         b = ngx_create_temp_buf(r->connection->pool,
  1466.                                 cscf->large_client_header_buffers.size);
  1467.         if (b == NULL) {
  1468.             return NGX_ERROR;
  1469.         }

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

  1475.     } else {
  1476.         return NGX_DECLINED;
  1477.     }

  1479.     hc->busy[hc->nbusy++] = b;

  1481.     if (r->state == 0) {
  1482.         /*
  1483.          * r->state == 0 means that a header line was parsed successfully
  1484.          * and we do not need to copy incomplete header line and
  1485.          * to relocate the parser header pointers
  1486.          */

  1488.         r->header_in = b;

  1490.         return NGX_OK;
  1491.     }

  1493.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1494.                    "http large header copy: %d", r->header_in->pos - old);

  1496.     new = b->start;

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

  1500.     b->pos = new + (r->header_in->pos - old);
  1501.     b->last = new + (r->header_in->pos - old);

  1503.     if (request_line) {
  1504.         r->request_start = new;

  1506.         if (r->request_end) {
  1507.             r->request_end = new + (r->request_end - old);
  1508.         }

  1510.         r->method_end = new + (r->method_end - old);

  1512.         r->uri_start = new + (r->uri_start - old);
  1513.         r->uri_end = new + (r->uri_end - old);

  1515.         if (r->schema_start) {
  1516.             r->schema_start = new + (r->schema_start - old);
  1517.             r->schema_end = new + (r->schema_end - old);
  1518.         }

  1520.         if (r->host_start) {
  1521.             r->host_start = new + (r->host_start - old);
  1522.             if (r->host_end) {
  1523.                 r->host_end = new + (r->host_end - old);
  1524.             }
  1525.         }

  1527.         if (r->port_start) {
  1528.             r->port_start = new + (r->port_start - old);
  1529.             r->port_end = new + (r->port_end - old);
  1530.         }

  1532.         if (r->uri_ext) {
  1533.             r->uri_ext = new + (r->uri_ext - old);
  1534.         }

  1536.         if (r->args_start) {
  1537.             r->args_start = new + (r->args_start - old);
  1538.         }

  1540.         if (r->http_protocol.data) {
  1541.             r->http_protocol.data = new + (r->http_protocol.data - old);
  1542.         }

  1544.     } else {
  1545.         r->header_name_start = new;
  1546.         r->header_name_end = new + (r->header_name_end - old);
  1547.         r->header_start = new + (r->header_start - old);
  1548.         r->header_end = new + (r->header_end - old);
  1549.     }

  1551.     r->header_in = b;

  1553.     return NGX_OK;
  1554. }


  1557. static ngx_int_t
  1558. ‌ngx_http_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  1559.     ngx_uint_t offset)
  1560. {
  1561.     ngx_table_elt_t  **ph;

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

  1565.     if (*ph == NULL) {
  1566.         *ph = h;
  1567.     }

  1569.     return NGX_OK;
  1570. }


  1573. static ngx_int_t
  1574. ‌ngx_http_process_unique_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  1575.     ngx_uint_t offset)
  1576. {
  1577.     ngx_table_elt_t  **ph;

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

  1581.     if (*ph == NULL) {
  1582.         *ph = h;
  1583.         return NGX_OK;
  1584.     }

  1586.     ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1587.                   "client sent duplicate header line: \"%V: %V\", "
  1588.                   "previous value: \"%V: %V\"",
  1589.                   &h->key, &h->value, &(*ph)->key, &(*ph)->value);

  1591.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);

  1593.     return NGX_ERROR;
  1594. }


  1597. static ngx_int_t
  1598. ‌ngx_http_process_host(ngx_http_request_t *r, ngx_table_elt_t *h,
  1599.     ngx_uint_t offset)
  1600. {
  1601.     ngx_int_t  rc;
  1602.     ngx_str_t  host;

  1604.     if (r->headers_in.host == NULL) {
  1605.         r->headers_in.host = h;
  1606.     }

  1608.     host = h->value;

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

  1612.     if (rc == NGX_DECLINED) {
  1613.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1614.                       "client sent invalid host header");
  1615.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1616.         return NGX_ERROR;
  1617.     }

  1619.     if (rc == NGX_ERROR) {
  1620.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1621.         return NGX_ERROR;
  1622.     }

  1624.     if (r->headers_in.server.len) {
  1625.         return NGX_OK;
  1626.     }

  1628.     if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
  1629.         return NGX_ERROR;
  1630.     }

  1632.     r->headers_in.server = host;

  1634.     return NGX_OK;
  1635. }


  1638. static ngx_int_t
  1639. ‌ngx_http_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  1640.     ngx_uint_t offset)
  1641. {
  1642.     if (ngx_strcasestrn(h->value.data, "close", 5 - 1)) {
  1643.         r->headers_in.connection_type = NGX_HTTP_CONNECTION_CLOSE;

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

  1649.     return NGX_OK;
  1650. }


  1653. static ngx_int_t
  1654. ‌ngx_http_process_user_agent(ngx_http_request_t *r, ngx_table_elt_t *h,
  1655.     ngx_uint_t offset)
  1656. {
  1657.     u_char  *user_agent, *msie;

  1659.     if (r->headers_in.user_agent) {
  1660.         return NGX_OK;
  1661.     }

  1663.     r->headers_in.user_agent = h;

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

  1667.     user_agent = h->value.data;

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

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

  1673.         r->headers_in.msie = 1;

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

  1677.             switch (msie[5]) {
  1678.             case '4':
  1679.             case '5':
  1680.                 r->headers_in.msie6 = 1;
  1681.                 break;
  1682.             case '6':
  1683.                 if (ngx_strstrn(msie + 8, "SV1", 3 - 1) == NULL) {
  1684.                     r->headers_in.msie6 = 1;
  1685.                 }
  1686.                 break;
  1687.             }
  1688.         }

  1690. #if 0
  1691.         /* MSIE ignores the SSL "close notify" alert */
  1692.         if (c->ssl) {
  1693.             c->ssl->no_send_shutdown = 1;
  1694.         }
  1695. #endif
  1696.     }

  1698.     if (ngx_strstrn(user_agent, "Opera", 5 - 1)) {
  1699.         r->headers_in.opera = 1;
  1700.         r->headers_in.msie = 0;
  1701.         r->headers_in.msie6 = 0;
  1702.     }

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

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

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

  1712.         } else if (ngx_strstrn(user_agent, "Safari/", 7 - 1)
  1713.                    && ngx_strstrn(user_agent, "Mac OS X", 8 - 1))
  1714.         {
  1715.             r->headers_in.safari = 1;

  1717.         } else if (ngx_strstrn(user_agent, "Konqueror", 9 - 1)) {
  1718.             r->headers_in.konqueror = 1;
  1719.         }
  1720.     }

  1722.     return NGX_OK;
  1723. }


  1726. static ngx_int_t
  1727. ‌ngx_http_process_multi_header_lines(ngx_http_request_t *r, ngx_table_elt_t *h,
  1728.     ngx_uint_t offset)
  1729. {
  1730.     ngx_array_t       *headers;
  1731.     ngx_table_elt_t  **ph;

  1733.     headers = (ngx_array_t *) ((char *) &r->headers_in + offset);

  1735.     if (headers->elts == NULL) {
  1736.         if (ngx_array_init(headers, r->pool, 1, sizeof(ngx_table_elt_t *))
  1737.             != NGX_OK)
  1738.         {
  1739.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1740.             return NGX_ERROR;
  1741.         }
  1742.     }

  1744.     ph = ngx_array_push(headers);
  1745.     if (ph == NULL) {
  1746.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1747.         return NGX_ERROR;
  1748.     }

  1750.     *ph = h;
  1751.     return NGX_OK;
  1752. }


  1755. ngx_int_t
  1756. ‌ngx_http_process_request_header(ngx_http_request_t *r)
  1757. {
  1758.     if (r->headers_in.server.len == 0
  1759.         && ngx_http_set_virtual_server(r, &r->headers_in.server)
  1760.            == NGX_ERROR)
  1761.     {
  1762.         return NGX_ERROR;
  1763.     }

  1765.     if (r->headers_in.host == NULL && r->http_version > NGX_HTTP_VERSION_10) {
  1766.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1767.                    "client sent HTTP/1.1 request without \"Host\" header");
  1768.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1769.         return NGX_ERROR;
  1770.     }

  1772.     if (r->headers_in.content_length) {
  1773.         r->headers_in.content_length_n =
  1774.                             ngx_atoof(r->headers_in.content_length->value.data,
  1775.                                       r->headers_in.content_length->value.len);

  1777.         if (r->headers_in.content_length_n == NGX_ERROR) {
  1778.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1779.                           "client sent invalid \"Content-Length\" header");
  1780.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1781.             return NGX_ERROR;
  1782.         }
  1783.     }

  1785.     if (r->method & NGX_HTTP_TRACE) {
  1786.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1787.                       "client sent TRACE method");
  1788.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  1789.         return NGX_ERROR;
  1790.     }

  1792.     if (r->headers_in.transfer_encoding) {
  1793.         if (r->headers_in.transfer_encoding->value.len == 7
  1794.             && ngx_strncasecmp(r->headers_in.transfer_encoding->value.data,
  1795.                                (u_char *) "chunked", 7) == 0)
  1796.         {
  1797.             r->headers_in.content_length = NULL;
  1798.             r->headers_in.content_length_n = -1;
  1799.             r->headers_in.chunked = 1;

  1801.         } else if (r->headers_in.transfer_encoding->value.len != 8
  1802.             || ngx_strncasecmp(r->headers_in.transfer_encoding->value.data,
  1803.                                (u_char *) "identity", 8) != 0)
  1804.         {
  1805.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1806.                           "client sent unknown \"Transfer-Encoding\": \"%V\"",
  1807.                           &r->headers_in.transfer_encoding->value);
  1808.             ngx_http_finalize_request(r, NGX_HTTP_NOT_IMPLEMENTED);
  1809.             return NGX_ERROR;
  1810.         }
  1811.     }

  1813.     if (r->headers_in.connection_type == NGX_HTTP_CONNECTION_KEEP_ALIVE) {
  1814.         if (r->headers_in.keep_alive) {
  1815.             r->headers_in.keep_alive_n =
  1816.                             ngx_atotm(r->headers_in.keep_alive->value.data,
  1817.                                       r->headers_in.keep_alive->value.len);
  1818.         }
  1819.     }

  1821.     return NGX_OK;
  1822. }


  1825. void
  1826. ‌ngx_http_process_request(ngx_http_request_t *r)
  1827. {
  1828.     ngx_connection_t  *c;

  1830.     c = r->connection;

  1832. #if (NGX_HTTP_SSL)

  1834.     if (r->http_connection->ssl) {
  1835.         long                      rc;
  1836.         X509                     *cert;
  1837.         ngx_http_ssl_srv_conf_t  *sscf;

  1839.         if (c->ssl == NULL) {
  1840.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1841.                           "client sent plain HTTP request to HTTPS port");
  1842.             ngx_http_finalize_request(r, NGX_HTTP_TO_HTTPS);
  1843.             return;
  1844.         }

  1846.         sscf = ngx_http_get_module_srv_conf(r, ngx_http_ssl_module);

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

  1851.             if (rc != X509_V_OK
  1852.                 && (sscf->verify != 3 || !ngx_ssl_verify_error_optional(rc)))
  1853.             {
  1854.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1855.                               "client SSL certificate verify error: (%l:%s)",
  1856.                               rc, X509_verify_cert_error_string(rc));

  1858.                 ngx_ssl_remove_cached_session(sscf->ssl.ctx,
  1859.                                        (SSL_get0_session(c->ssl->connection)));

  1861.                 ngx_http_finalize_request(r, NGX_HTTPS_CERT_ERROR);
  1862.                 return;
  1863.             }

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

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

  1872.                     ngx_ssl_remove_cached_session(sscf->ssl.ctx,
  1873.                                        (SSL_get0_session(c->ssl->connection)));

  1875.                     ngx_http_finalize_request(r, NGX_HTTPS_NO_CERT);
  1876.                     return;
  1877.                 }

  1879.                 X509_free(cert);
  1880.             }
  1881.         }
  1882.     }

  1884. #endif

  1886.     if (c->read->timer_set) {
  1887.         ngx_del_timer(c->read);
  1888.     }

  1890. #if (NGX_STAT_STUB)
  1891.     (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  1892.     r->stat_reading = 0;
  1893.     (void) ngx_atomic_fetch_add(ngx_stat_writing, 1);
  1894.     r->stat_writing = 1;
  1895. #endif

  1897.     c->read->handler = ngx_http_request_handler;
  1898.     c->write->handler = ngx_http_request_handler;
  1899.     r->read_event_handler = ngx_http_block_reading;

  1901.     ngx_http_handler(r);

  1903.     ngx_http_run_posted_requests(c);
  1904. }


  1907. static ngx_int_t
  1908. ‌ngx_http_validate_host(ngx_str_t *host, ngx_pool_t *pool, ngx_uint_t alloc)
  1909. {
  1910.     u_char  *h, ch;
  1911.     size_t   i, dot_pos, host_len;

  1913.     enum {
  1914.         sw_usual = 0,
  1915.         sw_literal,
  1916.         sw_rest
  1917.     } state;

  1919.     dot_pos = host->len;
  1920.     host_len = host->len;

  1922.     h = host->data;

  1924.     state = sw_usual;

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

  1929.         switch (ch) {

  1931.         case '.':
  1932.             if (dot_pos == i - 1) {
  1933.                 return NGX_DECLINED;
  1934.             }
  1935.             dot_pos = i;
  1936.             break;

  1938.         case ':':
  1939.             if (state == sw_usual) {
  1940.                 host_len = i;
  1941.                 state = sw_rest;
  1942.             }
  1943.             break;

  1945.         case '[':
  1946.             if (i == 0) {
  1947.                 state = sw_literal;
  1948.             }
  1949.             break;

  1951.         case ']':
  1952.             if (state == sw_literal) {
  1953.                 host_len = i + 1;
  1954.                 state = sw_rest;
  1955.             }
  1956.             break;

  1958.         case '\0':
  1959.             return NGX_DECLINED;

  1961.         default:

  1963.             if (ngx_path_separator(ch)) {
  1964.                 return NGX_DECLINED;
  1965.             }

  1967.             if (ch >= 'A' && ch <= 'Z') {
  1968.                 alloc = 1;
  1969.             }

  1971.             break;
  1972.         }
  1973.     }

  1975.     if (dot_pos == host_len - 1) {
  1976.         host_len--;
  1977.     }

  1979.     if (host_len == 0) {
  1980.         return NGX_DECLINED;
  1981.     }

  1983.     if (alloc) {
  1984.         host->data = ngx_pnalloc(pool, host_len);
  1985.         if (host->data == NULL) {
  1986.             return NGX_ERROR;
  1987.         }

  1989.         ngx_strlow(host->data, h, host_len);
  1990.     }

  1992.     host->len = host_len;

  1994.     return NGX_OK;
  1995. }


  1998. static ngx_int_t
  1999. ‌ngx_http_set_virtual_server(ngx_http_request_t *r, ngx_str_t *host)
  2000. {
  2001.     ngx_int_t                  rc;
  2002.     ngx_http_connection_t     *hc;
  2003.     ngx_http_core_loc_conf_t  *clcf;
  2004.     ngx_http_core_srv_conf_t  *cscf;

  2006. #if (NGX_SUPPRESS_WARN)
  2007.     cscf = NULL;
  2008. #endif

  2010.     hc = r->http_connection;

  2012. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2014.     if (hc->ssl_servername) {
  2015.         if (hc->ssl_servername->len == host->len
  2016.             && ngx_strncmp(hc->ssl_servername->data,
  2017.                            host->data, host->len) == 0)
  2018.         {
  2019. #if (NGX_PCRE)
  2020.             if (hc->ssl_servername_regex
  2021.                 && ngx_http_regex_exec(r, hc->ssl_servername_regex,
  2022.                                           hc->ssl_servername) != NGX_OK)
  2023.             {
  2024.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2025.                 return NGX_ERROR;
  2026.             }
  2027. #endif
  2028.             return NGX_OK;
  2029.         }
  2030.     }

  2032. #endif

  2034.     rc = ngx_http_find_virtual_server(r->connection,
  2035.                                       hc->addr_conf->virtual_names,
  2036.                                       host, r, &cscf);

  2038.     if (rc == NGX_ERROR) {
  2039.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  2040.         return NGX_ERROR;
  2041.     }

  2043. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2045.     if (hc->ssl_servername) {
  2046.         ngx_http_ssl_srv_conf_t  *sscf;

  2048.         if (rc == NGX_DECLINED) {
  2049.             cscf = hc->addr_conf->default_server;
  2050.             rc = NGX_OK;
  2051.         }

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

  2055.         if (sscf->verify) {
  2056.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  2057.                           "client attempted to request the server name "
  2058.                           "different from that one was negotiated");
  2059.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  2060.             return NGX_ERROR;
  2061.         }
  2062.     }

  2064. #endif

  2066.     if (rc == NGX_DECLINED) {
  2067.         return NGX_OK;
  2068.     }

  2070.     r->srv_conf = cscf->ctx->srv_conf;
  2071.     r->loc_conf = cscf->ctx->loc_conf;

  2073.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2075.     ngx_http_set_connection_log(r->connection, clcf->error_log);

  2077.     return NGX_OK;
  2078. }


  2081. static ngx_int_t
  2082. ‌ngx_http_find_virtual_server(ngx_connection_t *c,
  2083.     ngx_http_virtual_names_t *virtual_names, ngx_str_t *host,
  2084.     ngx_http_request_t *r, ngx_http_core_srv_conf_t **cscfp)
  2085. {
  2086.     ngx_http_core_srv_conf_t  *cscf;

  2088.     if (virtual_names == NULL) {
  2089.         return NGX_DECLINED;
  2090.     }

  2092.     cscf = ngx_hash_find_combined(&virtual_names->names,
  2093.                                   ngx_hash_key(host->data, host->len),
  2094.                                   host->data, host->len);

  2096.     if (cscf) {
  2097.         *cscfp = cscf;
  2098.         return NGX_OK;
  2099.     }

  2101. #if (NGX_PCRE)

  2103.     if (host->len && virtual_names->nregex) {
  2104.         ngx_int_t                n;
  2105.         ngx_uint_t               i;
  2106.         ngx_http_server_name_t  *sn;

  2108.         sn = virtual_names->regex;

  2110. #if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)

  2112.         if (r == NULL) {
  2113.             ngx_http_connection_t  *hc;

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

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

  2119.                 if (n == NGX_REGEX_NO_MATCHED) {
  2120.                     continue;
  2121.                 }

  2123.                 if (n >= 0) {
  2124.                     hc = c->data;
  2125.                     hc->ssl_servername_regex = sn[i].regex;

  2127.                     *cscfp = sn[i].server;
  2128.                     return NGX_OK;
  2129.                 }

  2131.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2132.                               ngx_regex_exec_n " failed: %i "
  2133.                               "on \"%V\" using \"%V\"",
  2134.                               n, host, &sn[i].regex->name);

  2136.                 return NGX_ERROR;
  2137.             }

  2139.             return NGX_DECLINED;
  2140.         }

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

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

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

  2148.             if (n == NGX_DECLINED) {
  2149.                 continue;
  2150.             }

  2152.             if (n == NGX_OK) {
  2153.                 *cscfp = sn[i].server;
  2154.                 return NGX_OK;
  2155.             }

  2157.             return NGX_ERROR;
  2158.         }
  2159.     }

  2161. #endif /* NGX_PCRE */

  2163.     return NGX_DECLINED;
  2164. }


  2167. static void
  2168. ‌ngx_http_request_handler(ngx_event_t *ev)
  2169. {
  2170.     ngx_connection_t    *c;
  2171.     ngx_http_request_t  *r;

  2173.     c = ev->data;
  2174.     r = c->data;

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

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

  2181.     if (ev->write) {
  2182.         r->write_event_handler(r);

  2184.     } else {
  2185.         r->read_event_handler(r);
  2186.     }

  2188.     ngx_http_run_posted_requests(c);
  2189. }


  2192. void
  2193. ‌ngx_http_run_posted_requests(ngx_connection_t *c)
  2194. {
  2195.     ngx_http_request_t         *r;
  2196.     ngx_http_posted_request_t  *pr;

  2198.     for ( ;; ) {

  2200.         if (c->destroyed) {
  2201.             return;
  2202.         }

  2204.         r = c->data;
  2205.         pr = r->main->posted_requests;

  2207.         if (pr == NULL) {
  2208.             return;
  2209.         }

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

  2213.         r = pr->request;

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

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

  2220.         r->write_event_handler(r);
  2221.     }
  2222. }


  2225. ngx_int_t
  2226. ‌ngx_http_post_request(ngx_http_request_t *r, ngx_http_posted_request_t *pr)
  2227. {
  2228.     ngx_http_posted_request_t  **p;

  2230.     if (pr == NULL) {
  2231.         pr = ngx_palloc(r->pool, sizeof(ngx_http_posted_request_t));
  2232.         if (pr == NULL) {
  2233.             return NGX_ERROR;
  2234.         }
  2235.     }

  2237.     pr->request = r;
  2238.     pr->next = NULL;

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

  2242.     *p = pr;

  2244.     return NGX_OK;
  2245. }


  2248. void
  2249. ‌ngx_http_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2250. {
  2251.     ngx_connection_t          *c;
  2252.     ngx_http_request_t        *pr;
  2253.     ngx_http_core_loc_conf_t  *clcf;

  2255.     c = r->connection;

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

  2261.     if (rc == NGX_DONE) {
  2262.         ngx_http_finalize_connection(r);
  2263.         return;
  2264.     }

  2266.     if (rc == NGX_OK && r->filter_finalize) {
  2267.         c->error = 1;
  2268.     }

  2270.     if (rc == NGX_DECLINED) {
  2271.         r->content_handler = NULL;
  2272.         r->write_event_handler = ngx_http_core_run_phases;
  2273.         ngx_http_core_run_phases(r);
  2274.         return;
  2275.     }

  2277.     if (r != r->main && r->post_subrequest) {
  2278.         rc = r->post_subrequest->handler(r, r->post_subrequest->data, rc);
  2279.     }

  2281.     if (rc == NGX_ERROR
  2282.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  2283.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST
  2284.         || c->error)
  2285.     {
  2286.         if (ngx_http_post_action(r) == NGX_OK) {
  2287.             return;
  2288.         }

  2290.         if (r->main->blocked) {
  2291.             r->write_event_handler = ngx_http_request_finalizer;
  2292.         }

  2294.         ngx_http_terminate_request(r, rc);
  2295.         return;
  2296.     }

  2298.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE
  2299.         || rc == NGX_HTTP_CREATED
  2300.         || rc == NGX_HTTP_NO_CONTENT)
  2301.     {
  2302.         if (rc == NGX_HTTP_CLOSE) {
  2303.             ngx_http_terminate_request(r, rc);
  2304.             return;
  2305.         }

  2307.         if (r == r->main) {
  2308.             if (c->read->timer_set) {
  2309.                 ngx_del_timer(c->read);
  2310.             }

  2312.             if (c->write->timer_set) {
  2313.                 ngx_del_timer(c->write);
  2314.             }
  2315.         }

  2317.         c->read->handler = ngx_http_request_handler;
  2318.         c->write->handler = ngx_http_request_handler;

  2320.         ngx_http_finalize_request(r, ngx_http_special_response_handler(r, rc));
  2321.         return;
  2322.     }

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

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

  2328.             if (ngx_http_set_write_handler(r) != NGX_OK) {
  2329.                 ngx_http_terminate_request(r, 0);
  2330.             }

  2332.             return;
  2333.         }

  2335.         pr = r->parent;

  2337.         if (r == c->data) {

  2339.             r->main->count--;
  2340.             r->main->subrequests++;

  2342.             if (!r->logged) {

  2344.                 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2346.                 if (clcf->log_subrequest) {
  2347.                     ngx_http_log_request(r);
  2348.                 }

  2350.                 r->logged = 1;

  2352.             } else {
  2353.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2354.                               "subrequest: \"%V?%V\" logged again",
  2355.                               &r->uri, &r->args);
  2356.             }

  2358.             r->done = 1;

  2360.             if (pr->postponed && pr->postponed->request == r) {
  2361.                 pr->postponed = pr->postponed->next;
  2362.             }

  2364.             c->data = pr;

  2366.         } else {

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

  2372.             r->write_event_handler = ngx_http_request_finalizer;

  2374.             if (r->waited) {
  2375.                 r->done = 1;
  2376.             }
  2377.         }

  2379.         if (ngx_http_post_request(pr, NULL) != NGX_OK) {
  2380.             r->main->count++;
  2381.             ngx_http_terminate_request(r, 0);
  2382.             return;
  2383.         }

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

  2389.         return;
  2390.     }

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

  2394.         if (ngx_http_set_write_handler(r) != NGX_OK) {
  2395.             ngx_http_terminate_request(r, 0);
  2396.         }

  2398.         return;
  2399.     }

  2401.     if (r != c->data) {
  2402.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2403.                       "http finalize non-active request: \"%V?%V\"",
  2404.                       &r->uri, &r->args);
  2405.         return;
  2406.     }

  2408.     r->done = 1;
  2409.     r->write_event_handler = ngx_http_request_empty_handler;

  2411.     if (!r->post_action) {
  2412.         r->request_complete = 1;
  2413.     }

  2415.     if (ngx_http_post_action(r) == NGX_OK) {
  2416.         return;
  2417.     }

  2419.     if (c->read->timer_set) {
  2420.         ngx_del_timer(c->read);
  2421.     }

  2423.     if (c->write->timer_set) {
  2424.         c->write->delayed = 0;
  2425.         ngx_del_timer(c->write);
  2426.     }

  2428.     if (c->read->eof) {
  2429.         ngx_http_close_request(r, 0);
  2430.         return;
  2431.     }

  2433.     ngx_http_finalize_connection(r);
  2434. }


  2437. static void
  2438. ‌ngx_http_terminate_request(ngx_http_request_t *r, ngx_int_t rc)
  2439. {
  2440.     ngx_http_cleanup_t    *cln;
  2441.     ngx_http_request_t    *mr;
  2442.     ngx_http_ephemeral_t  *e;

  2444.     mr = r->main;

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

  2449.     if (rc > 0 && (mr->headers_out.status == 0 || mr->connection->sent == 0)) {
  2450.         mr->headers_out.status = rc;
  2451.     }

  2453.     cln = mr->cleanup;
  2454.     mr->cleanup = NULL;

  2456.     while (cln) {
  2457.         if (cln->handler) {
  2458.             cln->handler(cln->data);
  2459.         }

  2461.         cln = cln->next;
  2462.     }

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

  2468.     if (mr->write_event_handler) {

  2470.         if (mr->blocked) {
  2471.             return;
  2472.         }

  2474.         e = ngx_http_ephemeral(mr);
  2475.         mr->posted_requests = NULL;
  2476.         mr->write_event_handler = ngx_http_terminate_handler;
  2477.         (void) ngx_http_post_request(mr, &e->terminal_posted_request);
  2478.         return;
  2479.     }

  2481.     ngx_http_close_request(mr, rc);
  2482. }


  2485. static void
  2486. ‌ngx_http_terminate_handler(ngx_http_request_t *r)
  2487. {
  2488.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2489.                    "http terminate handler count:%d", r->count);

  2491.     r->count = 1;

  2493.     ngx_http_close_request(r, 0);
  2494. }


  2497. static void
  2498. ‌ngx_http_finalize_connection(ngx_http_request_t *r)
  2499. {
  2500.     ngx_http_core_loc_conf_t  *clcf;

  2502. #if (NGX_HTTP_SPDY)
  2503.     if (r->spdy_stream) {
  2504.         ngx_http_close_request(r, 0);
  2505.         return;
  2506.     }
  2507. #endif

  2509.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  2513.         if (r->discard_body) {
  2514.             r->read_event_handler = ngx_http_discarded_request_body_handler;
  2515.             ngx_add_timer(r->connection->read, clcf->lingering_timeout);

  2517.             if (r->lingering_time == 0) {
  2518.                 r->lingering_time = ngx_time()
  2519.                                       + (time_t) (clcf->lingering_time / 1000);
  2520.             }
  2521.         }

  2523.         ngx_http_close_request(r, 0);
  2524.         return;
  2525.     }

  2527.     if (!ngx_terminate
  2528.          && !ngx_exiting
  2529.          && r->keepalive
  2530.          && clcf->keepalive_timeout > 0)
  2531.     {
  2532.         ngx_http_set_keepalive(r);
  2533.         return;
  2534.     }

  2536.     if (clcf->lingering_close == NGX_HTTP_LINGERING_ALWAYS
  2537.         || (clcf->lingering_close == NGX_HTTP_LINGERING_ON
  2538.             && (r->lingering_close
  2539.                 || r->header_in->pos < r->header_in->last
  2540.                 || r->connection->read->ready)))
  2541.     {
  2542.         ngx_http_set_lingering_close(r);
  2543.         return;
  2544.     }

  2546.     ngx_http_close_request(r, 0);
  2547. }


  2550. static ngx_int_t
  2551. ‌ngx_http_set_write_handler(ngx_http_request_t *r)
  2552. {
  2553.     ngx_event_t               *wev;
  2554.     ngx_http_core_loc_conf_t  *clcf;

  2556.     r->http_state = NGX_HTTP_WRITING_REQUEST_STATE;

  2558.     r->read_event_handler = r->discard_body ?
  2559.                                 ngx_http_discarded_request_body_handler:
  2560.                                 ngx_http_test_reading;
  2561.     r->write_event_handler = ngx_http_writer;

  2563. #if (NGX_HTTP_SPDY)
  2564.     if (r->spdy_stream) {
  2565.         return NGX_OK;
  2566.     }
  2567. #endif

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

  2571.     if (wev->ready && wev->delayed) {
  2572.         return NGX_OK;
  2573.     }

  2575.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  2576.     if (!wev->delayed) {
  2577.         ngx_add_timer(wev, clcf->send_timeout);
  2578.     }

  2580.     if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  2581.         ngx_http_close_request(r, 0);
  2582.         return NGX_ERROR;
  2583.     }

  2585.     return NGX_OK;
  2586. }


  2589. static void
  2590. ‌ngx_http_writer(ngx_http_request_t *r)
  2591. {
  2592.     int                        rc;
  2593.     ngx_event_t               *wev;
  2594.     ngx_connection_t          *c;
  2595.     ngx_http_core_loc_conf_t  *clcf;

  2597.     c = r->connection;
  2598.     wev = c->write;

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

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

  2605.     if (wev->timedout) {
  2606.         if (!wev->delayed) {
  2607.             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  2608.                           "client timed out");
  2609.             c->timedout = 1;

  2611.             ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  2612.             return;
  2613.         }

  2615.         wev->timedout = 0;
  2616.         wev->delayed = 0;

  2618.         if (!wev->ready) {
  2619.             ngx_add_timer(wev, clcf->send_timeout);

  2621.             if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  2622.                 ngx_http_close_request(r, 0);
  2623.             }

  2625.             return;
  2626.         }

  2628.     }

  2630.     if (wev->delayed || r->aio) {
  2631.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0,
  2632.                        "http writer delayed");

  2634.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  2635.             ngx_http_close_request(r, 0);
  2636.         }

  2638.         return;
  2639.     }

  2641.     rc = ngx_http_output_filter(r, NULL);

  2643.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2644.                    "http writer output filter: %d, \"%V?%V\"",
  2645.                    rc, &r->uri, &r->args);

  2647.     if (rc == NGX_ERROR) {
  2648.         ngx_http_finalize_request(r, rc);
  2649.         return;
  2650.     }

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

  2654. #if (NGX_HTTP_SPDY)
  2655.         if (r->spdy_stream) {
  2656.             return;
  2657.         }
  2658. #endif

  2660.         if (!wev->delayed) {
  2661.             ngx_add_timer(wev, clcf->send_timeout);
  2662.         }

  2664.         if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  2665.             ngx_http_close_request(r, 0);
  2666.         }

  2668.         return;
  2669.     }

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

  2674.     r->write_event_handler = ngx_http_request_empty_handler;

  2676.     ngx_http_finalize_request(r, rc);
  2677. }


  2680. static void
  2681. ‌ngx_http_request_finalizer(ngx_http_request_t *r)
  2682. {
  2683.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2684.                    "http finalizer done: \"%V?%V\"", &r->uri, &r->args);

  2686.     ngx_http_finalize_request(r, 0);
  2687. }


  2690. void
  2691. ‌ngx_http_block_reading(ngx_http_request_t *r)
  2692. {
  2693.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2694.                    "http reading blocked");

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

  2698.     if ((ngx_event_flags & NGX_USE_LEVEL_EVENT)
  2699.         && r->connection->read->active)
  2700.     {
  2701.         if (ngx_del_event(r->connection->read, NGX_READ_EVENT, 0) != NGX_OK) {
  2702.             ngx_http_close_request(r, 0);
  2703.         }
  2704.     }
  2705. }


  2708. void
  2709. ‌ngx_http_test_reading(ngx_http_request_t *r)
  2710. {
  2711.     int                n;
  2712.     char               buf[1];
  2713.     ngx_err_t          err;
  2714.     ngx_event_t       *rev;
  2715.     ngx_connection_t  *c;

  2717.     c = r->connection;
  2718.     rev = c->read;

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

  2722. #if (NGX_HTTP_SPDY)

  2724.     if (r->spdy_stream) {
  2725.         if (c->error) {
  2726.             err = 0;
  2727.             goto closed;
  2728.         }

  2730.         return;
  2731.     }

  2733. #endif

  2735. #if (NGX_HAVE_KQUEUE)

  2737.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  2739.         if (!rev->pending_eof) {
  2740.             return;
  2741.         }

  2743.         rev->eof = 1;
  2744.         c->error = 1;
  2745.         err = rev->kq_errno;

  2747.         goto closed;
  2748.     }

  2750. #endif

  2752. #if (NGX_HAVE_EPOLLRDHUP)

  2754.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && rev->pending_eof) {
  2755.         socklen_t  len;

  2757.         rev->eof = 1;
  2758.         c->error = 1;

  2760.         err = 0;
  2761.         len = sizeof(ngx_err_t);

  2763.         /*
  2764.          * BSDs and Linux return 0 and set a pending error in err
  2765.          * Solaris returns -1 and sets errno
  2766.          */

  2768.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  2769.             == -1)
  2770.         {
  2771.             err = ngx_socket_errno;
  2772.         }

  2774.         goto closed;
  2775.     }

  2777. #endif

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

  2781.     if (n == 0) {
  2782.         rev->eof = 1;
  2783.         c->error = 1;
  2784.         err = 0;

  2786.         goto closed;

  2788.     } else if (n == -1) {
  2789.         err = ngx_socket_errno;

  2791.         if (err != NGX_EAGAIN) {
  2792.             rev->eof = 1;
  2793.             c->error = 1;

  2795.             goto closed;
  2796.         }
  2797.     }

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

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

  2803.         if (ngx_del_event(rev, NGX_READ_EVENT, 0) != NGX_OK) {
  2804.             ngx_http_close_request(r, 0);
  2805.         }
  2806.     }

  2808.     return;

  2810. closed:

  2812.     if (err) {
  2813.         rev->error = 1;
  2814.     }

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

  2819.     ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  2820. }


  2823. static void
  2824. ‌ngx_http_set_keepalive(ngx_http_request_t *r)
  2825. {
  2826.     int                        tcp_nodelay;
  2827.     ngx_int_t                  i;
  2828.     ngx_buf_t                 *b, *f;
  2829.     ngx_event_t               *rev, *wev;
  2830.     ngx_connection_t          *c;
  2831.     ngx_http_connection_t     *hc;
  2832.     ngx_http_core_srv_conf_t  *cscf;
  2833.     ngx_http_core_loc_conf_t  *clcf;

  2835.     c = r->connection;
  2836.     rev = c->read;

  2838.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  2842.     if (r->discard_body) {
  2843.         r->write_event_handler = ngx_http_request_empty_handler;
  2844.         r->lingering_time = ngx_time() + (time_t) (clcf->lingering_time / 1000);
  2845.         ngx_add_timer(rev, clcf->lingering_timeout);
  2846.         return;
  2847.     }

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

  2851.     hc = r->http_connection;
  2852.     b = r->header_in;

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

  2856.         /* the pipelined request */

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

  2860.             /*
  2861.              * If the large header buffers were allocated while the previous
  2862.              * request processing then we do not use c->buffer for
  2863.              * the pipelined request (see ngx_http_create_request()).
  2864.              *
  2865.              * Now we would move the large header buffers to the free list.
  2866.              */

  2868.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  2870.             if (hc->free == NULL) {
  2871.                 hc->free = ngx_palloc(c->pool,
  2872.                   cscf->large_client_header_buffers.num * sizeof(ngx_buf_t *));

  2874.                 if (hc->free == NULL) {
  2875.                     ngx_http_close_request(r, 0);
  2876.                     return;
  2877.                 }
  2878.             }

  2880.             for (i = 0; i < hc->nbusy - 1; i++) {
  2881.                 f = hc->busy[i];
  2882.                 hc->free[hc->nfree++] = f;
  2883.                 f->pos = f->start;
  2884.                 f->last = f->start;
  2885.             }

  2887.             hc->busy[0] = b;
  2888.             hc->nbusy = 1;
  2889.         }
  2890.     }

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

  2895.     ngx_http_free_request(r, 0);

  2897.     c->data = hc;

  2899.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  2900.         ngx_http_close_connection(c);
  2901.         return;
  2902.     }

  2904.     wev = c->write;
  2905.     wev->handler = ngx_http_empty_handler;

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

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

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

  2913.         r = ngx_http_create_request(c);
  2914.         if (r == NULL) {
  2915.             ngx_http_close_connection(c);
  2916.             return;
  2917.         }

  2919.         r->pipeline = 1;

  2921.         c->data = r;

  2923.         c->sent = 0;
  2924.         c->destroyed = 0;

  2926.         if (rev->timer_set) {
  2927.             ngx_del_timer(rev);
  2928.         }

  2930.         rev->handler = ngx_http_process_request_line;
  2931.         ngx_post_event(rev, &ngx_posted_events);
  2932.         return;
  2933.     }

  2935.     /*
  2936.      * To keep a memory footprint as small as possible for an idle keepalive
  2937.      * connection we try to free c->buffer's memory if it was allocated outside
  2938.      * the c->pool.  The large header buffers are always allocated outside the
  2939.      * c->pool and are freed too.
  2940.      */

  2942.     b = c->buffer;

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

  2946.         /*
  2947.          * the special note for ngx_http_keepalive_handler() that
  2948.          * c->buffer's memory was freed
  2949.          */

  2951.         b->pos = NULL;

  2953.     } else {
  2954.         b->pos = b->start;
  2955.         b->last = b->start;
  2956.     }

  2958.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, "hc free: %p %d",
  2959.                    hc->free, hc->nfree);

  2961.     if (hc->free) {
  2962.         for (i = 0; i < hc->nfree; i++) {
  2963.             ngx_pfree(c->pool, hc->free[i]->start);
  2964.             hc->free[i] = NULL;
  2965.         }

  2967.         hc->nfree = 0;
  2968.     }

  2970.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, "hc busy: %p %d",
  2971.                    hc->busy, hc->nbusy);

  2973.     if (hc->busy) {
  2974.         for (i = 0; i < hc->nbusy; i++) {
  2975.             ngx_pfree(c->pool, hc->busy[i]->start);
  2976.             hc->busy[i] = NULL;
  2977.         }

  2979.         hc->nbusy = 0;
  2980.     }

  2982. #if (NGX_HTTP_SSL)
  2983.     if (c->ssl) {
  2984.         ngx_ssl_free_buffer(c);
  2985.     }
  2986. #endif

  2988.     rev->handler = ngx_http_keepalive_handler;

  2990.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  2991.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  2992.             ngx_http_close_connection(c);
  2993.             return;
  2994.         }
  2995.     }

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

  2999.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  3000.         if (ngx_tcp_push(c->fd) == -1) {
  3001.             ngx_connection_error(c, ngx_socket_errno, ngx_tcp_push_n " failed");
  3002.             ngx_http_close_connection(c);
  3003.             return;
  3004.         }

  3006.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  3007.         tcp_nodelay = ngx_tcp_nodelay_and_tcp_nopush ? 1 : 0;

  3009.     } else {
  3010.         tcp_nodelay = 1;
  3011.     }

  3013.     if (tcp_nodelay
  3014.         && clcf->tcp_nodelay
  3015.         && c->tcp_nodelay == NGX_TCP_NODELAY_UNSET)
  3016.     {
  3017.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "tcp_nodelay");

  3019.         if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
  3020.                        (const void *) &tcp_nodelay, sizeof(int))
  3021.             == -1)
  3022.         {
  3023. #if (NGX_SOLARIS)
  3024.             /* Solaris returns EINVAL if a socket has been shut down */
  3025.             c->log_error = NGX_ERROR_IGNORE_EINVAL;
  3026. #endif

  3028.             ngx_connection_error(c, ngx_socket_errno,
  3029.                                  "setsockopt(TCP_NODELAY) failed");

  3031.             c->log_error = NGX_ERROR_INFO;
  3032.             ngx_http_close_connection(c);
  3033.             return;
  3034.         }

  3036.         c->tcp_nodelay = NGX_TCP_NODELAY_SET;
  3037.     }

  3039. #if 0
  3040.     /* if ngx_http_request_t was freed then we need some other place */
  3041.     r->http_state = NGX_HTTP_KEEPALIVE_STATE;
  3042. #endif

  3044.     c->idle = 1;
  3045.     ngx_reusable_connection(c, 1);

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

  3049.     if (rev->ready) {
  3050.         ngx_post_event(rev, &ngx_posted_events);
  3051.     }
  3052. }


  3055. static void
  3056. ‌ngx_http_keepalive_handler(ngx_event_t *rev)
  3057. {
  3058.     size_t             size;
  3059.     ssize_t            n;
  3060.     ngx_buf_t         *b;
  3061.     ngx_connection_t  *c;

  3063.     c = rev->data;

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

  3067.     if (rev->timedout || c->close) {
  3068.         ngx_http_close_connection(c);
  3069.         return;
  3070.     }

  3072. #if (NGX_HAVE_KQUEUE)

  3074.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  3075.         if (rev->pending_eof) {
  3076.             c->log->handler = NULL;
  3077.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  3078.                           "kevent() reported that client %V closed "
  3079.                           "keepalive connection", &c->addr_text);
  3080. #if (NGX_HTTP_SSL)
  3081.             if (c->ssl) {
  3082.                 c->ssl->no_send_shutdown = 1;
  3083.             }
  3084. #endif
  3085.             ngx_http_close_connection(c);
  3086.             return;
  3087.         }
  3088.     }

  3090. #endif

  3092.     b = c->buffer;
  3093.     size = b->end - b->start;

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

  3097.         /*
  3098.          * The c->buffer's memory was freed by ngx_http_set_keepalive().
  3099.          * However, the c->buffer->start and c->buffer->end were not changed
  3100.          * to keep the buffer size.
  3101.          */

  3103.         b->pos = ngx_palloc(c->pool, size);
  3104.         if (b->pos == NULL) {
  3105.             ngx_http_close_connection(c);
  3106.             return;
  3107.         }

  3109.         b->start = b->pos;
  3110.         b->last = b->pos;
  3111.         b->end = b->pos + size;
  3112.     }

  3114.     /*
  3115.      * MSIE closes a keepalive connection with RST flag
  3116.      * so we ignore ECONNRESET here.
  3117.      */

  3119.     c->log_error = NGX_ERROR_IGNORE_ECONNRESET;
  3120.     ngx_set_socket_errno(0);

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

  3125.     if (n == NGX_AGAIN) {
  3126.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3127.             ngx_http_close_connection(c);
  3128.             return;
  3129.         }

  3131.         /*
  3132.          * Like ngx_http_set_keepalive() we are trying to not hold
  3133.          * c->buffer's memory for a keepalive connection.
  3134.          */

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

  3138.             /*
  3139.              * the special note that c->buffer's memory was freed
  3140.              */

  3142.             b->pos = NULL;
  3143.         }

  3145.         return;
  3146.     }

  3148.     if (n == NGX_ERROR) {
  3149.         ngx_http_close_connection(c);
  3150.         return;
  3151.     }

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

  3155.     if (n == 0) {
  3156.         ngx_log_error(NGX_LOG_INFO, c->log, ngx_socket_errno,
  3157.                       "client %V closed keepalive connection", &c->addr_text);
  3158.         ngx_http_close_connection(c);
  3159.         return;
  3160.     }

  3162.     b->last += n;

  3164.     c->log->handler = ngx_http_log_error;
  3165.     c->log->action = "reading client request line";

  3167.     c->idle = 0;
  3168.     ngx_reusable_connection(c, 0);

  3170.     c->data = ngx_http_create_request(c);
  3171.     if (c->data == NULL) {
  3172.         ngx_http_close_connection(c);
  3173.         return;
  3174.     }

  3176.     c->sent = 0;
  3177.     c->destroyed = 0;

  3179.     ngx_del_timer(rev);

  3181.     rev->handler = ngx_http_process_request_line;
  3182.     ngx_http_process_request_line(rev);
  3183. }


  3186. static void
  3187. ‌ngx_http_set_lingering_close(ngx_http_request_t *r)
  3188. {
  3189.     ngx_event_t               *rev, *wev;
  3190.     ngx_connection_t          *c;
  3191.     ngx_http_core_loc_conf_t  *clcf;

  3193.     c = r->connection;

  3195.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3197.     rev = c->read;
  3198.     rev->handler = ngx_http_lingering_close_handler;

  3200.     r->lingering_time = ngx_time() + (time_t) (clcf->lingering_time / 1000);
  3201.     ngx_add_timer(rev, clcf->lingering_timeout);

  3203.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3204.         ngx_http_close_request(r, 0);
  3205.         return;
  3206.     }

  3208.     wev = c->write;
  3209.     wev->handler = ngx_http_empty_handler;

  3211.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  3212.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  3213.             ngx_http_close_request(r, 0);
  3214.             return;
  3215.         }
  3216.     }

  3218.     if (ngx_shutdown_socket(c->fd, NGX_WRITE_SHUTDOWN) == -1) {
  3219.         ngx_connection_error(c, ngx_socket_errno,
  3220.                              ngx_shutdown_socket_n " failed");
  3221.         ngx_http_close_request(r, 0);
  3222.         return;
  3223.     }

  3225.     if (rev->ready) {
  3226.         ngx_http_lingering_close_handler(rev);
  3227.     }
  3228. }


  3231. static void
  3232. ‌ngx_http_lingering_close_handler(ngx_event_t *rev)
  3233. {
  3234.     ssize_t                    n;
  3235.     ngx_msec_t                 timer;
  3236.     ngx_connection_t          *c;
  3237.     ngx_http_request_t        *r;
  3238.     ngx_http_core_loc_conf_t  *clcf;
  3239.     u_char                     buffer[NGX_HTTP_LINGERING_BUFFER_SIZE];

  3241.     c = rev->data;
  3242.     r = c->data;

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

  3247.     if (rev->timedout) {
  3248.         ngx_http_close_request(r, 0);
  3249.         return;
  3250.     }

  3252.     timer = (ngx_msec_t) r->lingering_time - (ngx_msec_t) ngx_time();
  3253.     if ((ngx_msec_int_t) timer <= 0) {
  3254.         ngx_http_close_request(r, 0);
  3255.         return;
  3256.     }

  3258.     do {
  3259.         n = c->recv(c, buffer, NGX_HTTP_LINGERING_BUFFER_SIZE);

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

  3263.         if (n == NGX_ERROR || n == 0) {
  3264.             ngx_http_close_request(r, 0);
  3265.             return;
  3266.         }

  3268.     } while (rev->ready);

  3270.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3271.         ngx_http_close_request(r, 0);
  3272.         return;
  3273.     }

  3275.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3277.     timer *= 1000;

  3279.     if (timer > clcf->lingering_timeout) {
  3280.         timer = clcf->lingering_timeout;
  3281.     }

  3283.     ngx_add_timer(rev, timer);
  3284. }


  3287. void
  3288. ‌ngx_http_empty_handler(ngx_event_t *wev)
  3289. {
  3290.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, wev->log, 0, "http empty handler");

  3292.     return;
  3293. }


  3296. void
  3297. ‌ngx_http_request_empty_handler(ngx_http_request_t *r)
  3298. {
  3299.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3300.                    "http request empty handler");

  3302.     return;
  3303. }


  3306. ngx_int_t
  3307. ‌ngx_http_send_special(ngx_http_request_t *r, ngx_uint_t flags)
  3308. {
  3309.     ngx_buf_t    *b;
  3310.     ngx_chain_t   out;

  3312.     b = ngx_calloc_buf(r->pool);
  3313.     if (b == NULL) {
  3314.         return NGX_ERROR;
  3315.     }

  3317.     if (flags & NGX_HTTP_LAST) {

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

  3322.         } else {
  3323.             b->sync = 1;
  3324.             b->last_in_chain = 1;
  3325.         }
  3326.     }

  3328.     if (flags & NGX_HTTP_FLUSH) {
  3329.         b->flush = 1;
  3330.     }

  3332.     out.buf = b;
  3333.     out.next = NULL;

  3335.     return ngx_http_output_filter(r, &out);
  3336. }


  3339. static ngx_int_t
  3340. ‌ngx_http_post_action(ngx_http_request_t *r)
  3341. {
  3342.     ngx_http_core_loc_conf_t  *clcf;

  3344.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3346.     if (clcf->post_action.data == NULL) {
  3347.         return NGX_DECLINED;
  3348.     }

  3350.     if (r->post_action && r->uri_changes == 0) {
  3351.         return NGX_DECLINED;
  3352.     }

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

  3357.     r->main->count--;

  3359.     r->http_version = NGX_HTTP_VERSION_9;
  3360.     r->header_only = 1;
  3361.     r->post_action = 1;

  3363.     r->read_event_handler = ngx_http_block_reading;

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

  3368.     } else {
  3369.         ngx_http_named_location(r, &clcf->post_action);
  3370.     }

  3372.     return NGX_OK;
  3373. }


  3376. static void
  3377. ‌ngx_http_close_request(ngx_http_request_t *r, ngx_int_t rc)
  3378. {
  3379.     ngx_connection_t  *c;

  3381.     r = r->main;
  3382.     c = r->connection;

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

  3387.     if (r->count == 0) {
  3388.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "http request count is zero");
  3389.     }

  3391.     r->count--;

  3393.     if (r->count || r->blocked) {
  3394.         return;
  3395.     }

  3397. #if (NGX_HTTP_SPDY)
  3398.     if (r->spdy_stream) {
  3399.         ngx_http_spdy_close_stream(r->spdy_stream, rc);
  3400.         return;
  3401.     }
  3402. #endif

  3404.     ngx_http_free_request(r, rc);
  3405.     ngx_http_close_connection(c);
  3406. }


  3409. void
  3410. ‌ngx_http_free_request(ngx_http_request_t *r, ngx_int_t rc)
  3411. {
  3412.     ngx_log_t                 *log;
  3413.     ngx_pool_t                *pool;
  3414.     struct linger              linger;
  3415.     ngx_http_cleanup_t        *cln;
  3416.     ngx_http_log_ctx_t        *ctx;
  3417.     ngx_http_core_loc_conf_t  *clcf;

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

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

  3423.     if (r->pool == NULL) {
  3424.         ngx_log_error(NGX_LOG_ALERT, log, 0, "http request already closed");
  3425.         return;
  3426.     }

  3428.     cln = r->cleanup;
  3429.     r->cleanup = NULL;

  3431.     while (cln) {
  3432.         if (cln->handler) {
  3433.             cln->handler(cln->data);
  3434.         }

  3436.         cln = cln->next;
  3437.     }

  3439. #if (NGX_STAT_STUB)

  3441.     if (r->stat_reading) {
  3442.         (void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
  3443.     }

  3445.     if (r->stat_writing) {
  3446.         (void) ngx_atomic_fetch_add(ngx_stat_writing, -1);
  3447.     }

  3449. #endif

  3451.     if (rc > 0 && (r->headers_out.status == 0 || r->connection->sent == 0)) {
  3452.         r->headers_out.status = rc;
  3453.     }

  3455.     log->action = "logging request";

  3457.     ngx_http_log_request(r);

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

  3461.     if (r->connection->timedout) {
  3462.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3464.         if (clcf->reset_timedout_connection) {
  3465.             linger.l_onoff = 1;
  3466.             linger.l_linger = 0;

  3468.             if (setsockopt(r->connection->fd, SOL_SOCKET, SO_LINGER,
  3469.                            (const void *) &linger, sizeof(struct linger)) == -1)
  3470.             {
  3471.                 ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
  3472.                               "setsockopt(SO_LINGER) failed");
  3473.             }
  3474.         }
  3475.     }

  3477.     /* the various request strings were allocated from r->pool */
  3478.     ctx = log->data;
  3479.     ctx->request = NULL;

  3481.     r->request_line.len = 0;

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

  3485.     /*
  3486.      * Setting r->pool to NULL will increase probability to catch double close
  3487.      * of request since the request object is allocated from its own pool.
  3488.      */

  3490.     pool = r->pool;
  3491.     r->pool = NULL;

  3493.     ngx_destroy_pool(pool);
  3494. }


  3497. static void
  3498. ‌ngx_http_log_request(ngx_http_request_t *r)
  3499. {
  3500.     ngx_uint_t                  i, n;
  3501.     ngx_http_handler_pt        *log_handler;
  3502.     ngx_http_core_main_conf_t  *cmcf;

  3504.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  3506.     log_handler = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.elts;
  3507.     n = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.nelts;

  3509.     for (i = 0; i < n; i++) {
  3510.         log_handler[i](r);
  3511.     }
  3512. }


  3515. void
  3516. ‌ngx_http_close_connection(ngx_connection_t *c)
  3517. {
  3518.     ngx_pool_t  *pool;

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

  3523. #if (NGX_HTTP_SSL)

  3525.     if (c->ssl) {
  3526.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  3527.             c->ssl->handler = ngx_http_close_connection;
  3528.             return;
  3529.         }
  3530.     }

  3532. #endif

  3534. #if (NGX_STAT_STUB)
  3535.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  3536. #endif

  3538.     c->destroyed = 1;

  3540.     pool = c->pool;

  3542.     ngx_close_connection(c);

  3544.     ngx_destroy_pool(pool);
  3545. }


  3548. static u_char *
  3549. ‌ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len)
  3550. {
  3551.     u_char              *p;
  3552.     ngx_http_request_t  *r;
  3553.     ngx_http_log_ctx_t  *ctx;

  3555.     if (log->action) {
  3556.         p = ngx_snprintf(buf, len, " while %s", log->action);
  3557.         len -= p - buf;
  3558.         buf = p;
  3559.     }

  3561.     ctx = log->data;

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

  3566.     r = ctx->request;

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

  3571.     } else {
  3572.         p = ngx_snprintf(p, len, ", server: %V",
  3573.                          &ctx->connection->listening->addr_text);
  3574.     }

  3576.     return p;
  3577. }


  3580. static u_char *
  3581. ‌ngx_http_log_error_handler(ngx_http_request_t *r, ngx_http_request_t *sr,
  3582.     u_char *buf, size_t len)
  3583. {
  3584.     char                      *uri_separator;
  3585.     u_char                    *p;
  3586.     ngx_http_upstream_t       *u;
  3587.     ngx_http_core_srv_conf_t  *cscf;

  3589.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  3591.     p = ngx_snprintf(buf, len, ", server: %V", &cscf->server_name);
  3592.     len -= p - buf;
  3593.     buf = p;

  3595.     if (r->request_line.data == NULL && r->request_start) {
  3596.         for (p = r->request_start; p < r->header_in->last; p++) {
  3597.             if (*p == CR || *p == LF) {
  3598.                 break;
  3599.             }
  3600.         }

  3602.         r->request_line.len = p - r->request_start;
  3603.         r->request_line.data = r->request_start;
  3604.     }

  3606.     if (r->request_line.len) {
  3607.         p = ngx_snprintf(buf, len, ", request: \"%V\"", &r->request_line);
  3608.         len -= p - buf;
  3609.         buf = p;
  3610.     }

  3612.     if (r != sr) {
  3613.         p = ngx_snprintf(buf, len, ", subrequest: \"%V\"", &sr->uri);
  3614.         len -= p - buf;
  3615.         buf = p;
  3616.     }

  3618.     u = sr->upstream;

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

  3622.         uri_separator = "";

  3624. #if (NGX_HAVE_UNIX_DOMAIN)
  3625.         if (u->peer.sockaddr && u->peer.sockaddr->sa_family == AF_UNIX) {
  3626.             uri_separator = ":";
  3627.         }
  3628. #endif

  3630.         p = ngx_snprintf(buf, len, ", upstream: \"%V%V%s%V\"",
  3631.                          &u->schema, u->peer.name,
  3632.                          uri_separator, &u->uri);
  3633.         len -= p - buf;
  3634.         buf = p;
  3635.     }

  3637.     if (r->headers_in.host) {
  3638.         p = ngx_snprintf(buf, len, ", host: \"%V\"",
  3639.                          &r->headers_in.host->value);
  3640.         len -= p - buf;
  3641.         buf = p;
  3642.     }

  3644.     if (r->headers_in.referer) {
  3645.         p = ngx_snprintf(buf, len, ", referrer: \"%V\"",
  3646.                          &r->headers_in.referer->value);
  3647.         buf = p;
  3648.     }

  3650.     return buf;
  3651. }

One Level Up Top Level