One Level Up Top Level

src/http/v2/ngx_http_v2.c - nginx

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Nginx, Inc.
  4. * Copyright (C) Valentin V. Bartenev
  5. */


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


  14. /* errors */
  15. ‌#define NGX_HTTP_V2_NO_ERROR                     0x0
  16. ‌#define NGX_HTTP_V2_PROTOCOL_ERROR               0x1
  17. ‌#define NGX_HTTP_V2_INTERNAL_ERROR               0x2
  18. ‌#define NGX_HTTP_V2_FLOW_CTRL_ERROR              0x3
  19. ‌#define NGX_HTTP_V2_SETTINGS_TIMEOUT             0x4
  20. ‌#define NGX_HTTP_V2_STREAM_CLOSED                0x5
  21. ‌#define NGX_HTTP_V2_SIZE_ERROR                   0x6
  22. ‌#define NGX_HTTP_V2_REFUSED_STREAM               0x7
  23. ‌#define NGX_HTTP_V2_CANCEL                       0x8
  24. ‌#define NGX_HTTP_V2_COMP_ERROR                   0x9
  25. ‌#define NGX_HTTP_V2_CONNECT_ERROR                0xa
  26. ‌#define NGX_HTTP_V2_ENHANCE_YOUR_CALM            0xb
  27. ‌#define NGX_HTTP_V2_INADEQUATE_SECURITY          0xc
  28. ‌#define NGX_HTTP_V2_HTTP_1_1_REQUIRED            0xd

  30. /* frame sizes */
  31. ‌#define NGX_HTTP_V2_SETTINGS_ACK_SIZE            0
  32. ‌#define NGX_HTTP_V2_RST_STREAM_SIZE              4
  33. ‌#define NGX_HTTP_V2_PRIORITY_SIZE                5
  34. ‌#define NGX_HTTP_V2_PING_SIZE                    8
  35. ‌#define NGX_HTTP_V2_GOAWAY_SIZE                  8
  36. ‌#define NGX_HTTP_V2_WINDOW_UPDATE_SIZE           4

  38. ‌#define NGX_HTTP_V2_SETTINGS_PARAM_SIZE          6

  40. /* settings fields */
  41. ‌#define NGX_HTTP_V2_HEADER_TABLE_SIZE_SETTING    0x1
  42. ‌#define NGX_HTTP_V2_ENABLE_PUSH_SETTING          0x2
  43. ‌#define NGX_HTTP_V2_MAX_STREAMS_SETTING          0x3
  44. ‌#define NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING     0x4
  45. ‌#define NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING       0x5

  47. ‌#define NGX_HTTP_V2_FRAME_BUFFER_SIZE            24

  49. ‌#define NGX_HTTP_V2_ROOT                         (void *) -1


  52. static void ngx_http_v2_read_handler(ngx_event_t *rev);
  53. static void ngx_http_v2_write_handler(ngx_event_t *wev);
  54. static void ngx_http_v2_handle_connection(ngx_http_v2_connection_t *h2c);
  55. static void ngx_http_v2_lingering_close(ngx_connection_t *c);
  56. static void ngx_http_v2_lingering_close_handler(ngx_event_t *rev);

  58. static u_char *ngx_http_v2_state_preface(ngx_http_v2_connection_t *h2c,
  59.     u_char *pos, u_char *end);
  60. static u_char *ngx_http_v2_state_preface_end(ngx_http_v2_connection_t *h2c,
  61.     u_char *pos, u_char *end);
  62. static u_char *ngx_http_v2_state_head(ngx_http_v2_connection_t *h2c,
  63.     u_char *pos, u_char *end);
  64. static u_char *ngx_http_v2_state_data(ngx_http_v2_connection_t *h2c,
  65.     u_char *pos, u_char *end);
  66. static u_char *ngx_http_v2_state_read_data(ngx_http_v2_connection_t *h2c,
  67.     u_char *pos, u_char *end);
  68. static u_char *ngx_http_v2_state_headers(ngx_http_v2_connection_t *h2c,
  69.     u_char *pos, u_char *end);
  70. static u_char *ngx_http_v2_state_header_block(ngx_http_v2_connection_t *h2c,
  71.     u_char *pos, u_char *end);
  72. static u_char *ngx_http_v2_state_field_len(ngx_http_v2_connection_t *h2c,
  73.     u_char *pos, u_char *end);
  74. static u_char *ngx_http_v2_state_field_huff(ngx_http_v2_connection_t *h2c,
  75.     u_char *pos, u_char *end);
  76. static u_char *ngx_http_v2_state_field_raw(ngx_http_v2_connection_t *h2c,
  77.     u_char *pos, u_char *end);
  78. static u_char *ngx_http_v2_state_field_skip(ngx_http_v2_connection_t *h2c,
  79.     u_char *pos, u_char *end);
  80. static u_char *ngx_http_v2_state_process_header(ngx_http_v2_connection_t *h2c,
  81.     u_char *pos, u_char *end);
  82. static u_char *ngx_http_v2_state_header_complete(ngx_http_v2_connection_t *h2c,
  83.     u_char *pos, u_char *end);
  84. static u_char *ngx_http_v2_handle_continuation(ngx_http_v2_connection_t *h2c,
  85.     u_char *pos, u_char *end, ngx_http_v2_handler_pt handler);
  86. static u_char *ngx_http_v2_state_priority(ngx_http_v2_connection_t *h2c,
  87.     u_char *pos, u_char *end);
  88. static u_char *ngx_http_v2_state_rst_stream(ngx_http_v2_connection_t *h2c,
  89.     u_char *pos, u_char *end);
  90. static u_char *ngx_http_v2_state_settings(ngx_http_v2_connection_t *h2c,
  91.     u_char *pos, u_char *end);
  92. static u_char *ngx_http_v2_state_settings_params(ngx_http_v2_connection_t *h2c,
  93.     u_char *pos, u_char *end);
  94. static u_char *ngx_http_v2_state_push_promise(ngx_http_v2_connection_t *h2c,
  95.     u_char *pos, u_char *end);
  96. static u_char *ngx_http_v2_state_ping(ngx_http_v2_connection_t *h2c,
  97.     u_char *pos, u_char *end);
  98. static u_char *ngx_http_v2_state_goaway(ngx_http_v2_connection_t *h2c,
  99.     u_char *pos, u_char *end);
  100. static u_char *ngx_http_v2_state_window_update(ngx_http_v2_connection_t *h2c,
  101.     u_char *pos, u_char *end);
  102. static u_char *ngx_http_v2_state_continuation(ngx_http_v2_connection_t *h2c,
  103.     u_char *pos, u_char *end);
  104. static u_char *ngx_http_v2_state_complete(ngx_http_v2_connection_t *h2c,
  105.     u_char *pos, u_char *end);
  106. static u_char *ngx_http_v2_state_skip_padded(ngx_http_v2_connection_t *h2c,
  107.     u_char *pos, u_char *end);
  108. static u_char *ngx_http_v2_state_skip(ngx_http_v2_connection_t *h2c,
  109.     u_char *pos, u_char *end);
  110. static u_char *ngx_http_v2_state_save(ngx_http_v2_connection_t *h2c,
  111.     u_char *pos, u_char *end, ngx_http_v2_handler_pt handler);
  112. static u_char *ngx_http_v2_state_headers_save(ngx_http_v2_connection_t *h2c,
  113.     u_char *pos, u_char *end, ngx_http_v2_handler_pt handler);
  114. static u_char *ngx_http_v2_connection_error(ngx_http_v2_connection_t *h2c,
  115.     ngx_uint_t err);

  117. static ngx_int_t ngx_http_v2_parse_int(ngx_http_v2_connection_t *h2c,
  118.     u_char **pos, u_char *end, ngx_uint_t prefix);

  120. static ngx_http_v2_stream_t *ngx_http_v2_create_stream(
  121.     ngx_http_v2_connection_t *h2c);
  122. static ngx_http_v2_node_t *ngx_http_v2_get_node_by_id(
  123.     ngx_http_v2_connection_t *h2c, ngx_uint_t sid, ngx_uint_t alloc);
  124. static ngx_http_v2_node_t *ngx_http_v2_get_closed_node(
  125.     ngx_http_v2_connection_t *h2c);
  126. ‌#define ngx_http_v2_index_size(h2scf)  (h2scf->streams_index_mask + 1)
  127. ‌#define ngx_http_v2_index(h2scf, sid)  ((sid >> 1) & h2scf->streams_index_mask)

  129. static ngx_int_t ngx_http_v2_send_settings(ngx_http_v2_connection_t *h2c);
  130. static ngx_int_t ngx_http_v2_settings_frame_handler(
  131.     ngx_http_v2_connection_t *h2c, ngx_http_v2_out_frame_t *frame);
  132. static ngx_int_t ngx_http_v2_send_window_update(ngx_http_v2_connection_t *h2c,
  133.     ngx_uint_t sid, size_t window);
  134. static ngx_int_t ngx_http_v2_send_rst_stream(ngx_http_v2_connection_t *h2c,
  135.     ngx_uint_t sid, ngx_uint_t status);
  136. static ngx_int_t ngx_http_v2_send_goaway(ngx_http_v2_connection_t *h2c,
  137.     ngx_uint_t status);

  139. static ngx_http_v2_out_frame_t *ngx_http_v2_get_frame(
  140.     ngx_http_v2_connection_t *h2c, size_t length, ngx_uint_t type,
  141.     u_char flags, ngx_uint_t sid);
  142. static ngx_int_t ngx_http_v2_frame_handler(ngx_http_v2_connection_t *h2c,
  143.     ngx_http_v2_out_frame_t *frame);

  145. static ngx_int_t ngx_http_v2_validate_header(ngx_http_request_t *r,
  146.     ngx_http_v2_header_t *header);
  147. static ngx_int_t ngx_http_v2_pseudo_header(ngx_http_request_t *r,
  148.     ngx_http_v2_header_t *header);
  149. static ngx_int_t ngx_http_v2_parse_path(ngx_http_request_t *r,
  150.     ngx_str_t *value);
  151. static ngx_int_t ngx_http_v2_parse_method(ngx_http_request_t *r,
  152.     ngx_str_t *value);
  153. static ngx_int_t ngx_http_v2_parse_scheme(ngx_http_request_t *r,
  154.     ngx_str_t *value);
  155. static ngx_int_t ngx_http_v2_parse_authority(ngx_http_request_t *r,
  156.     ngx_str_t *value);
  157. static ngx_int_t ngx_http_v2_construct_request_line(ngx_http_request_t *r);
  158. static ngx_int_t ngx_http_v2_cookie(ngx_http_request_t *r,
  159.     ngx_http_v2_header_t *header);
  160. static ngx_int_t ngx_http_v2_construct_cookie_header(ngx_http_request_t *r);
  161. static ngx_int_t ngx_http_v2_construct_host_header(ngx_http_request_t *r);
  162. static void ngx_http_v2_run_request(ngx_http_request_t *r);
  163. static ngx_int_t ngx_http_v2_process_request_body(ngx_http_request_t *r,
  164.     u_char *pos, size_t size, ngx_uint_t last, ngx_uint_t flush);
  165. static ngx_int_t ngx_http_v2_filter_request_body(ngx_http_request_t *r);
  166. static void ngx_http_v2_read_client_request_body_handler(ngx_http_request_t *r);

  168. static ngx_int_t ngx_http_v2_terminate_stream(ngx_http_v2_connection_t *h2c,
  169.     ngx_http_v2_stream_t *stream, ngx_uint_t status);
  170. static void ngx_http_v2_close_stream_handler(ngx_event_t *ev);
  171. static void ngx_http_v2_retry_close_stream_handler(ngx_event_t *ev);
  172. static void ngx_http_v2_handle_connection_handler(ngx_event_t *rev);
  173. static void ngx_http_v2_idle_handler(ngx_event_t *rev);
  174. static void ngx_http_v2_finalize_connection(ngx_http_v2_connection_t *h2c,
  175.     ngx_uint_t status);

  177. static ngx_int_t ngx_http_v2_adjust_windows(ngx_http_v2_connection_t *h2c,
  178.     ssize_t delta);
  179. static void ngx_http_v2_set_dependency(ngx_http_v2_connection_t *h2c,
  180.     ngx_http_v2_node_t *node, ngx_uint_t depend, ngx_uint_t exclusive);
  181. static void ngx_http_v2_node_children_update(ngx_http_v2_node_t *node);

  183. static void ngx_http_v2_pool_cleanup(void *data);


  186. ‌static ngx_http_v2_handler_pt ngx_http_v2_frame_states[] = {
  187.     ngx_http_v2_state_data,               /* NGX_HTTP_V2_DATA_FRAME */
  188.     ngx_http_v2_state_headers,            /* NGX_HTTP_V2_HEADERS_FRAME */
  189.     ngx_http_v2_state_priority,           /* NGX_HTTP_V2_PRIORITY_FRAME */
  190.     ngx_http_v2_state_rst_stream,         /* NGX_HTTP_V2_RST_STREAM_FRAME */
  191.     ngx_http_v2_state_settings,           /* NGX_HTTP_V2_SETTINGS_FRAME */
  192.     ngx_http_v2_state_push_promise,       /* NGX_HTTP_V2_PUSH_PROMISE_FRAME */
  193.     ngx_http_v2_state_ping,               /* NGX_HTTP_V2_PING_FRAME */
  194.     ngx_http_v2_state_goaway,             /* NGX_HTTP_V2_GOAWAY_FRAME */
  195.     ngx_http_v2_state_window_update,      /* NGX_HTTP_V2_WINDOW_UPDATE_FRAME */
  196.     ngx_http_v2_state_continuation        /* NGX_HTTP_V2_CONTINUATION_FRAME */
  197. };

  199. ‌#define NGX_HTTP_V2_FRAME_STATES                                              \
  200.     (sizeof(ngx_http_v2_frame_states) / sizeof(ngx_http_v2_handler_pt))


  203. void
  204. ‌ngx_http_v2_init(ngx_event_t *rev)
  205. {
  206.     u_char                    *p, *end;
  207.     ngx_connection_t          *c;
  208.     ngx_pool_cleanup_t        *cln;
  209.     ngx_http_connection_t     *hc;
  210.     ngx_http_v2_srv_conf_t    *h2scf;
  211.     ngx_http_v2_main_conf_t   *h2mcf;
  212.     ngx_http_v2_connection_t  *h2c;
  213.     ngx_http_core_srv_conf_t  *cscf;

  215.     c = rev->data;
  216.     hc = c->data;

  218.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "init http2 connection");

  220.     c->log->action = "processing HTTP/2 connection";

  222.     h2mcf = ngx_http_get_module_main_conf(hc->conf_ctx, ngx_http_v2_module);

  224.     if (h2mcf->recv_buffer == NULL) {
  225.         h2mcf->recv_buffer = ngx_palloc(ngx_cycle->pool,
  226.                                         h2mcf->recv_buffer_size);
  227.         if (h2mcf->recv_buffer == NULL) {
  228.             ngx_http_close_connection(c);
  229.             return;
  230.         }
  231.     }

  233.     h2c = ngx_pcalloc(c->pool, sizeof(ngx_http_v2_connection_t));
  234.     if (h2c == NULL) {
  235.         ngx_http_close_connection(c);
  236.         return;
  237.     }

  239.     h2c->connection = c;
  240.     h2c->http_connection = hc;

  242.     h2c->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  243.     h2c->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  245.     h2c->init_window = NGX_HTTP_V2_DEFAULT_WINDOW;

  247.     h2c->frame_size = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;

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

  251.     h2c->priority_limit = ngx_max(h2scf->concurrent_streams, 100);

  253.     h2c->pool = ngx_create_pool(h2scf->pool_size, h2c->connection->log);
  254.     if (h2c->pool == NULL) {
  255.         ngx_http_close_connection(c);
  256.         return;
  257.     }

  259.     cln = ngx_pool_cleanup_add(c->pool, 0);
  260.     if (cln == NULL) {
  261.         ngx_http_close_connection(c);
  262.         return;
  263.     }

  265.     cln->handler = ngx_http_v2_pool_cleanup;
  266.     cln->data = h2c;

  268.     h2c->streams_index = ngx_pcalloc(c->pool, ngx_http_v2_index_size(h2scf)
  269.                                               * sizeof(ngx_http_v2_node_t *));
  270.     if (h2c->streams_index == NULL) {
  271.         ngx_http_close_connection(c);
  272.         return;
  273.     }

  275.     if (ngx_http_v2_send_settings(h2c) == NGX_ERROR) {
  276.         ngx_http_close_connection(c);
  277.         return;
  278.     }

  280.     if (ngx_http_v2_send_window_update(h2c, 0, NGX_HTTP_V2_MAX_WINDOW
  281.                                                - NGX_HTTP_V2_DEFAULT_WINDOW)
  282.         == NGX_ERROR)
  283.     {
  284.         ngx_http_close_connection(c);
  285.         return;
  286.     }

  288.     h2c->state.handler = ngx_http_v2_state_preface;

  290.     ngx_queue_init(&h2c->waiting);
  291.     ngx_queue_init(&h2c->dependencies);
  292.     ngx_queue_init(&h2c->closed);

  294.     c->data = h2c;

  296.     if (ngx_exiting) {
  297.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  298.         return;
  299.     }

  301.     rev->handler = ngx_http_v2_read_handler;
  302.     c->write->handler = ngx_http_v2_write_handler;

  304.     if (!rev->timer_set) {
  305.         cscf = ngx_http_get_module_srv_conf(hc->conf_ctx,
  306.                                             ngx_http_core_module);
  307.         ngx_add_timer(rev, cscf->client_header_timeout);
  308.     }

  310.     c->idle = 1;
  311.     ngx_reusable_connection(c, 0);

  313.     if (c->buffer) {
  314.         p = c->buffer->pos;
  315.         end = c->buffer->last;

  317.         do {
  318.             p = h2c->state.handler(h2c, p, end);

  320.             if (p == NULL) {
  321.                 return;
  322.             }

  324.         } while (p != end);

  326.         h2c->total_bytes += p - c->buffer->pos;
  327.         c->buffer->pos = p;
  328.     }

  330.     ngx_http_v2_read_handler(rev);
  331. }


  334. static void
  335. ‌ngx_http_v2_read_handler(ngx_event_t *rev)
  336. {
  337.     u_char                    *p, *end;
  338.     size_t                     available;
  339.     ssize_t                    n;
  340.     ngx_connection_t          *c;
  341.     ngx_http_v2_main_conf_t   *h2mcf;
  342.     ngx_http_v2_connection_t  *h2c;

  344.     c = rev->data;
  345.     h2c = c->data;

  347.     if (rev->timedout) {
  348.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  349.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  350.         return;
  351.     }

  353.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http2 read handler");

  355.     h2c->blocked = 1;
  356.     h2c->new_streams = 0;

  358.     if (c->close) {
  359.         c->close = 0;

  361.         if (c->error) {
  362.             ngx_http_v2_finalize_connection(h2c, 0);
  363.             return;
  364.         }

  366.         if (!h2c->processing) {
  367.             ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  368.             return;
  369.         }

  371.         if (!h2c->goaway) {
  372.             h2c->goaway = 1;

  374.             if (ngx_http_v2_send_goaway(h2c, NGX_HTTP_V2_NO_ERROR)
  375.                 == NGX_ERROR)
  376.             {
  377.                 ngx_http_v2_finalize_connection(h2c, 0);
  378.                 return;
  379.             }

  381.             if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  382.                 ngx_http_v2_finalize_connection(h2c, 0);
  383.                 return;
  384.             }
  385.         }

  387.         h2c->blocked = 0;

  389.         return;
  390.     }

  392.     h2mcf = ngx_http_get_module_main_conf(h2c->http_connection->conf_ctx,
  393.                                           ngx_http_v2_module);

  395.     available = h2mcf->recv_buffer_size - NGX_HTTP_V2_STATE_BUFFER_SIZE;

  397.     do {
  398.         p = h2mcf->recv_buffer;
  399.         end = ngx_cpymem(p, h2c->state.buffer, h2c->state.buffer_used);

  401.         n = c->recv(c, end, available);

  403.         if (n == NGX_AGAIN) {
  404.             break;
  405.         }

  407.         if (n == 0 && (h2c->state.incomplete || h2c->processing)) {
  408.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  409.                           "client prematurely closed connection");
  410.         }

  412.         if (n == 0 || n == NGX_ERROR) {
  413.             c->error = 1;
  414.             ngx_http_v2_finalize_connection(h2c, 0);
  415.             return;
  416.         }

  418.         end += n;

  420.         h2c->state.buffer_used = 0;
  421.         h2c->state.incomplete = 0;

  423.         do {
  424.             p = h2c->state.handler(h2c, p, end);

  426.             if (p == NULL) {
  427.                 return;
  428.             }

  430.         } while (p != end);

  432.         h2c->total_bytes += n;

  434.         if (h2c->total_bytes / 8 > h2c->payload_bytes + 1048576) {
  435.             ngx_log_error(NGX_LOG_INFO, c->log, 0, "http2 flood detected");
  436.             ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  437.             return;
  438.         }

  440.     } while (rev->ready);

  442.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  443.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  444.         return;
  445.     }

  447.     if (h2c->last_out && ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  448.         ngx_http_v2_finalize_connection(h2c, 0);
  449.         return;
  450.     }

  452.     h2c->blocked = 0;

  454.     ngx_http_v2_handle_connection(h2c);
  455. }


  458. static void
  459. ‌ngx_http_v2_write_handler(ngx_event_t *wev)
  460. {
  461.     ngx_int_t                  rc;
  462.     ngx_connection_t          *c;
  463.     ngx_http_v2_connection_t  *h2c;

  465.     c = wev->data;
  466.     h2c = c->data;

  468.     if (wev->timedout) {
  469.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  470.                        "http2 write event timed out");
  471.         c->error = 1;
  472.         c->timedout = 1;
  473.         ngx_http_v2_finalize_connection(h2c, 0);
  474.         return;
  475.     }

  477.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http2 write handler");

  479.     if (h2c->last_out == NULL && !c->buffered) {

  481.         if (wev->timer_set) {
  482.             ngx_del_timer(wev);
  483.         }

  485.         ngx_http_v2_handle_connection(h2c);
  486.         return;
  487.     }

  489.     h2c->blocked = 1;

  491.     rc = ngx_http_v2_send_output_queue(h2c);

  493.     if (rc == NGX_ERROR) {
  494.         ngx_http_v2_finalize_connection(h2c, 0);
  495.         return;
  496.     }

  498.     h2c->blocked = 0;

  500.     if (rc == NGX_AGAIN) {
  501.         return;
  502.     }

  504.     ngx_http_v2_handle_connection(h2c);
  505. }


  508. ngx_int_t
  509. ‌ngx_http_v2_send_output_queue(ngx_http_v2_connection_t *h2c)
  510. {
  511.     int                        tcp_nodelay;
  512.     ngx_chain_t               *cl;
  513.     ngx_event_t               *wev;
  514.     ngx_connection_t          *c;
  515.     ngx_http_v2_out_frame_t   *out, *frame, *fn;
  516.     ngx_http_core_loc_conf_t  *clcf;

  518.     c = h2c->connection;
  519.     wev = c->write;

  521.     if (c->error) {
  522.         goto error;
  523.     }

  525.     if (!wev->ready) {
  526.         return NGX_AGAIN;
  527.     }

  529.     cl = NULL;
  530.     out = NULL;

  532.     for (frame = h2c->last_out; frame; frame = fn) {
  533.         frame->last->next = cl;
  534.         cl = frame->first;

  536.         fn = frame->next;
  537.         frame->next = out;
  538.         out = frame;

  540.         ngx_log_debug4(NGX_LOG_DEBUG_HTTP, c->log, 0,
  541.                        "http2 frame out: %p sid:%ui bl:%d len:%uz",
  542.                        out, out->stream ? out->stream->node->id : 0,
  543.                        out->blocked, out->length);
  544.     }

  546.     cl = c->send_chain(c, cl, 0);

  548.     if (cl == NGX_CHAIN_ERROR) {
  549.         goto error;
  550.     }

  552.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  553.                                         ngx_http_core_module);

  555.     if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
  556.         goto error;
  557.     }

  559.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  560.         if (ngx_tcp_push(c->fd) == -1) {
  561.             ngx_connection_error(c, ngx_socket_errno, ngx_tcp_push_n " failed");
  562.             goto error;
  563.         }

  565.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  566.         tcp_nodelay = ngx_tcp_nodelay_and_tcp_nopush ? 1 : 0;

  568.     } else {
  569.         tcp_nodelay = 1;
  570.     }

  572.     if (tcp_nodelay && clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  573.         goto error;
  574.     }

  576.     for ( /* void */ ; out; out = fn) {
  577.         fn = out->next;

  579.         if (out->handler(h2c, out) != NGX_OK) {
  580.             out->blocked = 1;
  581.             break;
  582.         }

  584.         ngx_log_debug4(NGX_LOG_DEBUG_HTTP, c->log, 0,
  585.                        "http2 frame sent: %p sid:%ui bl:%d len:%uz",
  586.                        out, out->stream ? out->stream->node->id : 0,
  587.                        out->blocked, out->length);
  588.     }

  590.     frame = NULL;

  592.     for ( /* void */ ; out; out = fn) {
  593.         fn = out->next;
  594.         out->next = frame;
  595.         frame = out;
  596.     }

  598.     h2c->last_out = frame;

  600.     if (!wev->ready) {
  601.         ngx_add_timer(wev, clcf->send_timeout);
  602.         return NGX_AGAIN;
  603.     }

  605.     if (wev->timer_set) {
  606.         ngx_del_timer(wev);
  607.     }

  609.     return NGX_OK;

  611. error:

  613.     c->error = 1;

  615.     if (!h2c->blocked) {
  616.         ngx_post_event(wev, &ngx_posted_events);
  617.     }

  619.     return NGX_ERROR;
  620. }


  623. static void
  624. ‌ngx_http_v2_handle_connection(ngx_http_v2_connection_t *h2c)
  625. {
  626.     ngx_int_t                  rc;
  627.     ngx_connection_t          *c;
  628.     ngx_http_core_loc_conf_t  *clcf;

  630.     if (h2c->last_out || h2c->processing) {
  631.         return;
  632.     }

  634.     c = h2c->connection;

  636.     if (c->error) {
  637.         ngx_http_close_connection(c);
  638.         return;
  639.     }

  641.     if (c->buffered) {
  642.         h2c->blocked = 1;

  644.         rc = ngx_http_v2_send_output_queue(h2c);

  646.         h2c->blocked = 0;

  648.         if (rc == NGX_ERROR) {
  649.             ngx_http_close_connection(c);
  650.             return;
  651.         }

  653.         if (rc == NGX_AGAIN) {
  654.             return;
  655.         }

  657.         /* rc == NGX_OK */
  658.     }

  660.     if (h2c->goaway) {
  661.         ngx_http_v2_lingering_close(c);
  662.         return;
  663.     }

  665.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  666.                                         ngx_http_core_module);

  668.     if (!c->read->timer_set) {
  669.         ngx_add_timer(c->read, clcf->keepalive_timeout);
  670.     }

  672.     ngx_reusable_connection(c, 1);

  674.     if (h2c->state.incomplete) {
  675.         return;
  676.     }

  678.     ngx_destroy_pool(h2c->pool);

  680.     h2c->pool = NULL;
  681.     h2c->free_frames = NULL;
  682.     h2c->frames = 0;
  683.     h2c->free_fake_connections = NULL;

  685. #if (NGX_HTTP_SSL)
  686.     if (c->ssl) {
  687.         ngx_ssl_free_buffer(c);
  688.     }
  689. #endif

  691.     c->destroyed = 1;

  693.     c->write->handler = ngx_http_empty_handler;
  694.     c->read->handler = ngx_http_v2_idle_handler;

  696.     if (c->write->timer_set) {
  697.         ngx_del_timer(c->write);
  698.     }
  699. }


  702. static void
  703. ‌ngx_http_v2_lingering_close(ngx_connection_t *c)
  704. {
  705.     ngx_event_t               *rev, *wev;
  706.     ngx_http_v2_connection_t  *h2c;
  707.     ngx_http_core_loc_conf_t  *clcf;

  709.     h2c = c->data;

  711.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  712.                                         ngx_http_core_module);

  714.     if (clcf->lingering_close == NGX_HTTP_LINGERING_OFF) {
  715.         ngx_http_close_connection(c);
  716.         return;
  717.     }

  719.     if (h2c->lingering_time == 0) {
  720.         h2c->lingering_time = ngx_time()
  721.                               + (time_t) (clcf->lingering_time / 1000);
  722.     }

  724. #if (NGX_HTTP_SSL)
  725.     if (c->ssl) {
  726.         ngx_int_t  rc;

  728.         rc = ngx_ssl_shutdown(c);

  730.         if (rc == NGX_ERROR) {
  731.             ngx_http_close_connection(c);
  732.             return;
  733.         }

  735.         if (rc == NGX_AGAIN) {
  736.             c->ssl->handler = ngx_http_v2_lingering_close;
  737.             return;
  738.         }
  739.     }
  740. #endif

  742.     rev = c->read;
  743.     rev->handler = ngx_http_v2_lingering_close_handler;

  745.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  746.         ngx_http_close_connection(c);
  747.         return;
  748.     }

  750.     wev = c->write;
  751.     wev->handler = ngx_http_empty_handler;

  753.     if (wev->active && (ngx_event_flags & NGX_USE_LEVEL_EVENT)) {
  754.         if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) != NGX_OK) {
  755.             ngx_http_close_connection(c);
  756.             return;
  757.         }
  758.     }

  760.     if (ngx_shutdown_socket(c->fd, NGX_WRITE_SHUTDOWN) == -1) {
  761.         ngx_connection_error(c, ngx_socket_errno,
  762.                              ngx_shutdown_socket_n " failed");
  763.         ngx_http_close_connection(c);
  764.         return;
  765.     }

  767.     c->close = 0;
  768.     ngx_reusable_connection(c, 1);

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

  772.     if (rev->ready) {
  773.         ngx_http_v2_lingering_close_handler(rev);
  774.     }
  775. }


  778. static void
  779. ‌ngx_http_v2_lingering_close_handler(ngx_event_t *rev)
  780. {
  781.     ssize_t                    n;
  782.     ngx_msec_t                 timer;
  783.     ngx_connection_t          *c;
  784.     ngx_http_core_loc_conf_t  *clcf;
  785.     ngx_http_v2_connection_t  *h2c;
  786.     u_char                     buffer[NGX_HTTP_LINGERING_BUFFER_SIZE];

  788.     c = rev->data;
  789.     h2c = c->data;

  791.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  792.                    "http2 lingering close handler");

  794.     if (rev->timedout || c->close) {
  795.         ngx_http_close_connection(c);
  796.         return;
  797.     }

  799.     timer = (ngx_msec_t) h2c->lingering_time - (ngx_msec_t) ngx_time();
  800.     if ((ngx_msec_int_t) timer <= 0) {
  801.         ngx_http_close_connection(c);
  802.         return;
  803.     }

  805.     do {
  806.         n = c->recv(c, buffer, NGX_HTTP_LINGERING_BUFFER_SIZE);

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

  810.         if (n == NGX_AGAIN) {
  811.             break;
  812.         }

  814.         if (n == NGX_ERROR || n == 0) {
  815.             ngx_http_close_connection(c);
  816.             return;
  817.         }

  819.     } while (rev->ready);

  821.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  822.         ngx_http_close_connection(c);
  823.         return;
  824.     }

  826.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  827.                                         ngx_http_core_module);
  828.     timer *= 1000;

  830.     if (timer > clcf->lingering_timeout) {
  831.         timer = clcf->lingering_timeout;
  832.     }

  834.     ngx_add_timer(rev, timer);
  835. }


  838. static u_char *
  839. ‌ngx_http_v2_state_preface(ngx_http_v2_connection_t *h2c, u_char *pos,
  840.     u_char *end)
  841. {
  842.     static const u_char preface[] = NGX_HTTP_V2_PREFACE_START;

  844.     if ((size_t) (end - pos) < sizeof(preface) - 1) {
  845.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_preface);
  846.     }

  848.     if (ngx_memcmp(pos, preface, sizeof(preface) - 1) != 0) {
  849.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  850.                       "invalid connection preface");

  852.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  853.     }

  855.     return ngx_http_v2_state_preface_end(h2c, pos + sizeof(preface) - 1, end);
  856. }


  859. static u_char *
  860. ‌ngx_http_v2_state_preface_end(ngx_http_v2_connection_t *h2c, u_char *pos,
  861.     u_char *end)
  862. {
  863.     static const u_char preface[] = NGX_HTTP_V2_PREFACE_END;

  865.     if ((size_t) (end - pos) < sizeof(preface) - 1) {
  866.         return ngx_http_v2_state_save(h2c, pos, end,
  867.                                       ngx_http_v2_state_preface_end);
  868.     }

  870.     if (ngx_memcmp(pos, preface, sizeof(preface) - 1) != 0) {
  871.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  872.                       "invalid connection preface");

  874.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  875.     }

  877.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  878.                    "http2 preface verified");

  880.     return ngx_http_v2_state_head(h2c, pos + sizeof(preface) - 1, end);
  881. }


  884. static u_char *
  885. ‌ngx_http_v2_state_head(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  886. {
  887.     uint32_t    head;
  888.     ngx_uint_t  type;

  890.     if (end - pos < NGX_HTTP_V2_FRAME_HEADER_SIZE) {
  891.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_head);
  892.     }

  894.     head = ngx_http_v2_parse_uint32(pos);

  896.     h2c->state.length = ngx_http_v2_parse_length(head);
  897.     h2c->state.flags = pos[4];

  899.     h2c->state.sid = ngx_http_v2_parse_sid(&pos[5]);

  901.     pos += NGX_HTTP_V2_FRAME_HEADER_SIZE;

  903.     type = ngx_http_v2_parse_type(head);

  905.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  906.                    "http2 frame type:%ui f:%Xd l:%uz sid:%ui",
  907.                    type, h2c->state.flags, h2c->state.length, h2c->state.sid);

  909.     if (type >= NGX_HTTP_V2_FRAME_STATES) {
  910.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  911.                       "client sent frame with unknown type %ui", type);
  912.         return ngx_http_v2_state_skip(h2c, pos, end);
  913.     }

  915.     return ngx_http_v2_frame_states[type](h2c, pos, end);
  916. }


  919. static u_char *
  920. ‌ngx_http_v2_state_data(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  921. {
  922.     size_t                 size;
  923.     ngx_http_v2_node_t    *node;
  924.     ngx_http_v2_stream_t  *stream;

  926.     size = h2c->state.length;

  928.     if (h2c->state.flags & NGX_HTTP_V2_PADDED_FLAG) {

  930.         if (h2c->state.length == 0) {
  931.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  932.                           "client sent padded DATA frame "
  933.                           "with incorrect length: 0");

  935.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  936.         }

  938.         if (end - pos == 0) {
  939.             return ngx_http_v2_state_save(h2c, pos, end,
  940.                                           ngx_http_v2_state_data);
  941.         }

  943.         h2c->state.padding = *pos++;

  945.         if (h2c->state.padding >= size) {
  946.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  947.                           "client sent padded DATA frame "
  948.                           "with incorrect length: %uz, padding: %uz",
  949.                           size, h2c->state.padding);

  951.             return ngx_http_v2_connection_error(h2c,
  952.                                                 NGX_HTTP_V2_PROTOCOL_ERROR);
  953.         }

  955.         h2c->state.length -= 1 + h2c->state.padding;
  956.     }

  958.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  959.                    "http2 DATA frame");

  961.     if (h2c->state.sid == 0) {
  962.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  963.                       "client sent DATA frame with incorrect identifier");

  965.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  966.     }

  968.     if (size > h2c->recv_window) {
  969.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  970.                       "client violated connection flow control: "
  971.                       "received DATA frame length %uz, available window %uz",
  972.                       size, h2c->recv_window);

  974.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
  975.     }

  977.     h2c->recv_window -= size;

  979.     if (h2c->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4) {

  981.         if (ngx_http_v2_send_window_update(h2c, 0, NGX_HTTP_V2_MAX_WINDOW
  982.                                                    - h2c->recv_window)
  983.             == NGX_ERROR)
  984.         {
  985.             return ngx_http_v2_connection_error(h2c,
  986.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  987.         }

  989.         h2c->recv_window = NGX_HTTP_V2_MAX_WINDOW;
  990.     }

  992.     node = ngx_http_v2_get_node_by_id(h2c, h2c->state.sid, 0);

  994.     if (node == NULL || node->stream == NULL) {
  995.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  996.                        "unknown http2 stream");

  998.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  999.     }

  1001.     stream = node->stream;

  1003.     if (size > stream->recv_window) {
  1004.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1005.                       "client violated flow control for stream %ui: "
  1006.                       "received DATA frame length %uz, available window %uz",
  1007.                       node->id, size, stream->recv_window);

  1009.         if (ngx_http_v2_terminate_stream(h2c, stream,
  1010.                                          NGX_HTTP_V2_FLOW_CTRL_ERROR)
  1011.             == NGX_ERROR)
  1012.         {
  1013.             return ngx_http_v2_connection_error(h2c,
  1014.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1015.         }

  1017.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1018.     }

  1020.     stream->recv_window -= size;

  1022.     if (stream->no_flow_control
  1023.         && stream->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4)
  1024.     {
  1025.         if (ngx_http_v2_send_window_update(h2c, node->id,
  1026.                                            NGX_HTTP_V2_MAX_WINDOW
  1027.                                            - stream->recv_window)
  1028.             == NGX_ERROR)
  1029.         {
  1030.             return ngx_http_v2_connection_error(h2c,
  1031.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1032.         }

  1034.         stream->recv_window = NGX_HTTP_V2_MAX_WINDOW;
  1035.     }

  1037.     if (stream->in_closed) {
  1038.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1039.                       "client sent DATA frame for half-closed stream %ui",
  1040.                       node->id);

  1042.         if (ngx_http_v2_terminate_stream(h2c, stream,
  1043.                                          NGX_HTTP_V2_STREAM_CLOSED)
  1044.             == NGX_ERROR)
  1045.         {
  1046.             return ngx_http_v2_connection_error(h2c,
  1047.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1048.         }

  1050.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1051.     }

  1053.     h2c->state.stream = stream;

  1055.     return ngx_http_v2_state_read_data(h2c, pos, end);
  1056. }


  1059. static u_char *
  1060. ‌ngx_http_v2_state_read_data(ngx_http_v2_connection_t *h2c, u_char *pos,
  1061.     u_char *end)
  1062. {
  1063.     size_t                   size;
  1064.     ngx_buf_t               *buf;
  1065.     ngx_int_t                rc;
  1066.     ngx_connection_t        *fc;
  1067.     ngx_http_request_t      *r;
  1068.     ngx_http_v2_stream_t    *stream;
  1069.     ngx_http_v2_srv_conf_t  *h2scf;

  1071.     stream = h2c->state.stream;

  1073.     if (stream == NULL) {
  1074.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1075.     }

  1077.     if (stream->skip_data) {
  1078.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1079.                        "skipping http2 DATA frame");

  1081.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1082.     }

  1084.     r = stream->request;
  1085.     fc = r->connection;

  1087.     if (r->reading_body && !r->request_body_no_buffering) {
  1088.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1089.                        "skipping http2 DATA frame");

  1091.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1092.     }

  1094.     if (r->headers_in.content_length_n < 0 && !r->headers_in.chunked) {
  1095.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1096.                        "skipping http2 DATA frame");

  1098.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1099.     }

  1101.     size = end - pos;

  1103.     if (size >= h2c->state.length) {
  1104.         size = h2c->state.length;
  1105.         stream->in_closed = h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG;
  1106.     }

  1108.     h2c->payload_bytes += size;

  1110.     if (r->request_body) {
  1111.         rc = ngx_http_v2_process_request_body(r, pos, size,
  1112.                                               stream->in_closed, 0);

  1114.         if (rc != NGX_OK && rc != NGX_AGAIN) {
  1115.             stream->skip_data = 1;
  1116.             ngx_http_finalize_request(r, rc);
  1117.         }

  1119.         ngx_http_run_posted_requests(fc);

  1121.     } else if (size) {
  1122.         buf = stream->preread;

  1124.         if (buf == NULL) {
  1125.             h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

  1127.             buf = ngx_create_temp_buf(r->pool, h2scf->preread_size);
  1128.             if (buf == NULL) {
  1129.                 return ngx_http_v2_connection_error(h2c,
  1130.                                                     NGX_HTTP_V2_INTERNAL_ERROR);
  1131.             }

  1133.             stream->preread = buf;
  1134.         }

  1136.         if (size > (size_t) (buf->end - buf->last)) {
  1137.             ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  1138.                           "http2 preread buffer overflow");
  1139.             return ngx_http_v2_connection_error(h2c,
  1140.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1141.         }

  1143.         buf->last = ngx_cpymem(buf->last, pos, size);
  1144.     }

  1146.     pos += size;
  1147.     h2c->state.length -= size;

  1149.     if (h2c->state.length) {
  1150.         return ngx_http_v2_state_save(h2c, pos, end,
  1151.                                       ngx_http_v2_state_read_data);
  1152.     }

  1154.     if (h2c->state.padding) {
  1155.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1156.     }

  1158.     return ngx_http_v2_state_complete(h2c, pos, end);
  1159. }


  1162. static u_char *
  1163. ‌ngx_http_v2_state_headers(ngx_http_v2_connection_t *h2c, u_char *pos,
  1164.     u_char *end)
  1165. {
  1166.     size_t                     size;
  1167.     ngx_uint_t                 padded, priority, depend, dependency, excl,
  1168.                                weight;
  1169.     ngx_uint_t                 status;
  1170.     ngx_http_v2_node_t        *node;
  1171.     ngx_http_v2_stream_t      *stream;
  1172.     ngx_http_v2_srv_conf_t    *h2scf;
  1173.     ngx_http_core_srv_conf_t  *cscf;
  1174.     ngx_http_core_loc_conf_t  *clcf;

  1176.     padded = h2c->state.flags & NGX_HTTP_V2_PADDED_FLAG;
  1177.     priority = h2c->state.flags & NGX_HTTP_V2_PRIORITY_FLAG;

  1179.     size = 0;

  1181.     if (padded) {
  1182.         size++;
  1183.     }

  1185.     if (priority) {
  1186.         size += sizeof(uint32_t) + 1;
  1187.     }

  1189.     if (h2c->state.length < size) {
  1190.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1191.                       "client sent HEADERS frame with incorrect length %uz",
  1192.                       h2c->state.length);

  1194.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1195.     }

  1197.     if (h2c->state.length == size) {
  1198.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1199.                       "client sent HEADERS frame with empty header block");

  1201.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1202.     }

  1204.     if (h2c->goaway) {
  1205.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1206.                        "skipping http2 HEADERS frame");
  1207.         return ngx_http_v2_state_skip(h2c, pos, end);
  1208.     }

  1210.     if ((size_t) (end - pos) < size) {
  1211.         return ngx_http_v2_state_save(h2c, pos, end,
  1212.                                       ngx_http_v2_state_headers);
  1213.     }

  1215.     h2c->state.length -= size;

  1217.     if (padded) {
  1218.         h2c->state.padding = *pos++;

  1220.         if (h2c->state.padding > h2c->state.length) {
  1221.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1222.                           "client sent padded HEADERS frame "
  1223.                           "with incorrect length: %uz, padding: %uz",
  1224.                           h2c->state.length, h2c->state.padding);

  1226.             return ngx_http_v2_connection_error(h2c,
  1227.                                                 NGX_HTTP_V2_PROTOCOL_ERROR);
  1228.         }

  1230.         h2c->state.length -= h2c->state.padding;
  1231.     }

  1233.     depend = 0;
  1234.     excl = 0;
  1235.     weight = NGX_HTTP_V2_DEFAULT_WEIGHT;

  1237.     if (priority) {
  1238.         dependency = ngx_http_v2_parse_uint32(pos);

  1240.         depend = dependency & 0x7fffffff;
  1241.         excl = dependency >> 31;
  1242.         weight = pos[4] + 1;

  1244.         pos += sizeof(uint32_t) + 1;
  1245.     }

  1247.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1248.                    "http2 HEADERS frame sid:%ui "
  1249.                    "depends on %ui excl:%ui weight:%ui",
  1250.                    h2c->state.sid, depend, excl, weight);

  1252.     if (h2c->state.sid % 2 == 0 || h2c->state.sid <= h2c->last_sid) {
  1253.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1254.                       "client sent HEADERS frame with incorrect identifier "
  1255.                       "%ui, the last was %ui", h2c->state.sid, h2c->last_sid);

  1257.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1258.     }

  1260.     if (depend == h2c->state.sid) {
  1261.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1262.                       "client sent HEADERS frame for stream %ui "
  1263.                       "with incorrect dependency", h2c->state.sid);

  1265.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1266.     }

  1268.     h2c->last_sid = h2c->state.sid;

  1270.     h2c->state.pool = ngx_create_pool(1024, h2c->connection->log);
  1271.     if (h2c->state.pool == NULL) {
  1272.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1273.     }

  1275.     cscf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  1276.                                         ngx_http_core_module);

  1278.     h2c->state.header_limit = cscf->large_client_header_buffers.size
  1279.                               * cscf->large_client_header_buffers.num;

  1281.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  1282.                                          ngx_http_v2_module);

  1284.     if (h2c->processing >= h2scf->concurrent_streams) {
  1285.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1286.                       "concurrent streams exceeded %ui", h2c->processing);

  1288.         status = NGX_HTTP_V2_REFUSED_STREAM;
  1289.         goto rst_stream;
  1290.     }

  1292.     if (h2c->new_streams++ >= 2 * h2scf->concurrent_streams) {
  1293.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1294.                       "client sent too many streams at once");

  1296.         status = NGX_HTTP_V2_REFUSED_STREAM;
  1297.         goto rst_stream;
  1298.     }

  1300.     if (!h2c->settings_ack
  1301.         && !(h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG)
  1302.         && h2scf->preread_size < NGX_HTTP_V2_DEFAULT_WINDOW)
  1303.     {
  1304.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1305.                       "client sent stream with data "
  1306.                       "before settings were acknowledged");

  1308.         status = NGX_HTTP_V2_REFUSED_STREAM;
  1309.         goto rst_stream;
  1310.     }

  1312.     node = ngx_http_v2_get_node_by_id(h2c, h2c->state.sid, 1);

  1314.     if (node == NULL) {
  1315.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1316.     }

  1318.     if (node->parent) {
  1319.         ngx_queue_remove(&node->reuse);
  1320.         h2c->closed_nodes--;
  1321.     }

  1323.     stream = ngx_http_v2_create_stream(h2c);
  1324.     if (stream == NULL) {
  1325.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1326.     }

  1328.     h2c->state.stream = stream;

  1330.     stream->pool = h2c->state.pool;
  1331.     h2c->state.keep_pool = 1;

  1333.     stream->request->request_length = h2c->state.length;

  1335.     stream->in_closed = h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG;
  1336.     stream->node = node;

  1338.     node->stream = stream;

  1340.     if (priority || node->parent == NULL) {
  1341.         node->weight = weight;
  1342.         ngx_http_v2_set_dependency(h2c, node, depend, excl);
  1343.     }

  1345.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  1346.                                         ngx_http_core_module);

  1348.     if (clcf->keepalive_timeout == 0
  1349.         || h2c->connection->requests >= clcf->keepalive_requests
  1350.         || ngx_current_msec - h2c->connection->start_time
  1351.            > clcf->keepalive_time)
  1352.     {
  1353.         h2c->goaway = 1;

  1355.         if (ngx_http_v2_send_goaway(h2c, NGX_HTTP_V2_NO_ERROR) == NGX_ERROR) {
  1356.             return ngx_http_v2_connection_error(h2c,
  1357.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1358.         }
  1359.     }

  1361.     return ngx_http_v2_state_header_block(h2c, pos, end);

  1363. rst_stream:

  1365.     if (h2c->refused_streams++ > ngx_max(h2scf->concurrent_streams, 100)) {
  1366.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1367.                       "client sent too many refused streams");
  1368.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_NO_ERROR);
  1369.     }

  1371.     if (ngx_http_v2_send_rst_stream(h2c, h2c->state.sid, status) != NGX_OK) {
  1372.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1373.     }

  1375.     return ngx_http_v2_state_header_block(h2c, pos, end);
  1376. }


  1379. static u_char *
  1380. ‌ngx_http_v2_state_header_block(ngx_http_v2_connection_t *h2c, u_char *pos,
  1381.     u_char *end)
  1382. {
  1383.     u_char      ch;
  1384.     ngx_int_t   value;
  1385.     ngx_uint_t  indexed, size_update, prefix;

  1387.     if (end - pos < 1) {
  1388.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1389.                                               ngx_http_v2_state_header_block);
  1390.     }

  1392.     if (!(h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG)
  1393.         && h2c->state.length < NGX_HTTP_V2_INT_OCTETS)
  1394.     {
  1395.         return ngx_http_v2_handle_continuation(h2c, pos, end,
  1396.                                                ngx_http_v2_state_header_block);
  1397.     }

  1399.     size_update = 0;
  1400.     indexed = 0;

  1402.     ch = *pos;

  1404.     if (ch >= (1 << 7)) {
  1405.         /* indexed header field */
  1406.         indexed = 1;
  1407.         prefix = ngx_http_v2_prefix(7);

  1409.     } else if (ch >= (1 << 6)) {
  1410.         /* literal header field with incremental indexing */
  1411.         h2c->state.index = 1;
  1412.         prefix = ngx_http_v2_prefix(6);

  1414.     } else if (ch >= (1 << 5)) {
  1415.         /* dynamic table size update */
  1416.         size_update = 1;
  1417.         prefix = ngx_http_v2_prefix(5);

  1419.     } else if (ch >= (1 << 4)) {
  1420.         /* literal header field never indexed */
  1421.         prefix = ngx_http_v2_prefix(4);

  1423.     } else {
  1424.         /* literal header field without indexing */
  1425.         prefix = ngx_http_v2_prefix(4);
  1426.     }

  1428.     value = ngx_http_v2_parse_int(h2c, &pos, end, prefix);

  1430.     if (value < 0) {
  1431.         if (value == NGX_AGAIN) {
  1432.             return ngx_http_v2_state_headers_save(h2c, pos, end,
  1433.                                                ngx_http_v2_state_header_block);
  1434.         }

  1436.         if (value == NGX_DECLINED) {
  1437.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1438.                           "client sent header block with too long %s value",
  1439.                           size_update ? "size update" : "header index");

  1441.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1442.         }

  1444.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1445.                       "client sent header block with incorrect length");

  1447.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1448.     }

  1450.     if (indexed) {
  1451.         if (ngx_http_v2_get_indexed_header(h2c, value, 0) != NGX_OK) {
  1452.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1453.         }

  1455.         return ngx_http_v2_state_process_header(h2c, pos, end);
  1456.     }

  1458.     if (size_update) {
  1459.         if (ngx_http_v2_table_size(h2c, value) != NGX_OK) {
  1460.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1461.         }

  1463.         return ngx_http_v2_state_header_complete(h2c, pos, end);
  1464.     }

  1466.     if (value == 0) {
  1467.         h2c->state.parse_name = 1;

  1469.     } else if (ngx_http_v2_get_indexed_header(h2c, value, 1) != NGX_OK) {
  1470.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1471.     }

  1473.     h2c->state.parse_value = 1;

  1475.     return ngx_http_v2_state_field_len(h2c, pos, end);
  1476. }


  1479. static u_char *
  1480. ‌ngx_http_v2_state_field_len(ngx_http_v2_connection_t *h2c, u_char *pos,
  1481.     u_char *end)
  1482. {
  1483.     size_t                     alloc;
  1484.     ngx_int_t                  len;
  1485.     ngx_uint_t                 huff;
  1486.     ngx_http_core_srv_conf_t  *cscf;

  1488.     if (!(h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG)
  1489.         && h2c->state.length < NGX_HTTP_V2_INT_OCTETS)
  1490.     {
  1491.         return ngx_http_v2_handle_continuation(h2c, pos, end,
  1492.                                                ngx_http_v2_state_field_len);
  1493.     }

  1495.     if (h2c->state.length < 1) {
  1496.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1497.                       "client sent header block with incorrect length");

  1499.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1500.     }

  1502.     if (end - pos < 1) {
  1503.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1504.                                               ngx_http_v2_state_field_len);
  1505.     }

  1507.     huff = *pos >> 7;
  1508.     len = ngx_http_v2_parse_int(h2c, &pos, end, ngx_http_v2_prefix(7));

  1510.     if (len < 0) {
  1511.         if (len == NGX_AGAIN) {
  1512.             return ngx_http_v2_state_headers_save(h2c, pos, end,
  1513.                                                   ngx_http_v2_state_field_len);
  1514.         }

  1516.         if (len == NGX_DECLINED) {
  1517.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1518.                         "client sent header field with too long length value");

  1520.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1521.         }

  1523.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1524.                       "client sent header block with incorrect length");

  1526.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1527.     }

  1529.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1530.                    "http2 %s string, len:%i",
  1531.                    huff ? "encoded" : "raw", len);

  1533.     cscf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  1534.                                         ngx_http_core_module);

  1536.     if ((size_t) len > cscf->large_client_header_buffers.size) {
  1537.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1538.                       "client sent too large header field");

  1540.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_ENHANCE_YOUR_CALM);
  1541.     }

  1543.     h2c->state.field_rest = len;

  1545.     if (h2c->state.stream == NULL && !h2c->state.index) {
  1546.         return ngx_http_v2_state_field_skip(h2c, pos, end);
  1547.     }

  1549.     alloc = (huff ? len * 8 / 5 : len) + 1;

  1551.     h2c->state.field_start = ngx_pnalloc(h2c->state.pool, alloc);
  1552.     if (h2c->state.field_start == NULL) {
  1553.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1554.     }

  1556.     h2c->state.field_end = h2c->state.field_start;

  1558.     if (huff) {
  1559.         return ngx_http_v2_state_field_huff(h2c, pos, end);
  1560.     }

  1562.     return ngx_http_v2_state_field_raw(h2c, pos, end);
  1563. }


  1566. static u_char *
  1567. ‌ngx_http_v2_state_field_huff(ngx_http_v2_connection_t *h2c, u_char *pos,
  1568.     u_char *end)
  1569. {
  1570.     size_t  size;

  1572.     size = end - pos;

  1574.     if (size > h2c->state.field_rest) {
  1575.         size = h2c->state.field_rest;
  1576.     }

  1578.     if (size > h2c->state.length) {
  1579.         size = h2c->state.length;
  1580.     }

  1582.     h2c->state.length -= size;
  1583.     h2c->state.field_rest -= size;

  1585.     if (ngx_http_huff_decode(&h2c->state.field_state, pos, size,
  1586.                              &h2c->state.field_end,
  1587.                              h2c->state.field_rest == 0,
  1588.                              h2c->connection->log)
  1589.         != NGX_OK)
  1590.     {
  1591.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1592.                       "client sent invalid encoded header field");

  1594.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1595.     }

  1597.     pos += size;

  1599.     if (h2c->state.field_rest == 0) {
  1600.         *h2c->state.field_end = '\0';
  1601.         return ngx_http_v2_state_process_header(h2c, pos, end);
  1602.     }

  1604.     if (h2c->state.length) {
  1605.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1606.                                               ngx_http_v2_state_field_huff);
  1607.     }

  1609.     if (h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG) {
  1610.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1611.                       "client sent header field with incorrect length");

  1613.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1614.     }

  1616.     return ngx_http_v2_handle_continuation(h2c, pos, end,
  1617.                                            ngx_http_v2_state_field_huff);
  1618. }


  1621. static u_char *
  1622. ‌ngx_http_v2_state_field_raw(ngx_http_v2_connection_t *h2c, u_char *pos,
  1623.     u_char *end)
  1624. {
  1625.     size_t  size;

  1627.     size = end - pos;

  1629.     if (size > h2c->state.field_rest) {
  1630.         size = h2c->state.field_rest;
  1631.     }

  1633.     if (size > h2c->state.length) {
  1634.         size = h2c->state.length;
  1635.     }

  1637.     h2c->state.length -= size;
  1638.     h2c->state.field_rest -= size;

  1640.     h2c->state.field_end = ngx_cpymem(h2c->state.field_end, pos, size);

  1642.     pos += size;

  1644.     if (h2c->state.field_rest == 0) {
  1645.         *h2c->state.field_end = '\0';
  1646.         return ngx_http_v2_state_process_header(h2c, pos, end);
  1647.     }

  1649.     if (h2c->state.length) {
  1650.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1651.                                               ngx_http_v2_state_field_raw);
  1652.     }

  1654.     if (h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG) {
  1655.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1656.                       "client sent header field with incorrect length");

  1658.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1659.     }

  1661.     return ngx_http_v2_handle_continuation(h2c, pos, end,
  1662.                                            ngx_http_v2_state_field_raw);
  1663. }


  1666. static u_char *
  1667. ‌ngx_http_v2_state_field_skip(ngx_http_v2_connection_t *h2c, u_char *pos,
  1668.     u_char *end)
  1669. {
  1670.     size_t  size;

  1672.     size = end - pos;

  1674.     if (size > h2c->state.field_rest) {
  1675.         size = h2c->state.field_rest;
  1676.     }

  1678.     if (size > h2c->state.length) {
  1679.         size = h2c->state.length;
  1680.     }

  1682.     h2c->state.length -= size;
  1683.     h2c->state.field_rest -= size;

  1685.     pos += size;

  1687.     if (h2c->state.field_rest == 0) {
  1688.         return ngx_http_v2_state_process_header(h2c, pos, end);
  1689.     }

  1691.     if (h2c->state.length) {
  1692.         return ngx_http_v2_state_save(h2c, pos, end,
  1693.                                       ngx_http_v2_state_field_skip);
  1694.     }

  1696.     if (h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG) {
  1697.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1698.                       "client sent header field with incorrect length");

  1700.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1701.     }

  1703.     return ngx_http_v2_handle_continuation(h2c, pos, end,
  1704.                                            ngx_http_v2_state_field_skip);
  1705. }


  1708. static u_char *
  1709. ‌ngx_http_v2_state_process_header(ngx_http_v2_connection_t *h2c, u_char *pos,
  1710.     u_char *end)
  1711. {
  1712.     size_t                      len;
  1713.     ngx_int_t                   rc;
  1714.     ngx_table_elt_t            *h;
  1715.     ngx_connection_t           *fc;
  1716.     ngx_http_header_t          *hh;
  1717.     ngx_http_request_t         *r;
  1718.     ngx_http_v2_header_t       *header;
  1719.     ngx_http_core_srv_conf_t   *cscf;
  1720.     ngx_http_core_main_conf_t  *cmcf;

  1722.     static ngx_str_t cookie = ngx_string("cookie");

  1724.     header = &h2c->state.header;

  1726.     if (h2c->state.parse_name) {
  1727.         h2c->state.parse_name = 0;

  1729.         header->name.len = h2c->state.field_end - h2c->state.field_start;
  1730.         header->name.data = h2c->state.field_start;

  1732.         if (header->name.len == 0) {
  1733.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1734.                           "client sent zero header name length");

  1736.             return ngx_http_v2_connection_error(h2c,
  1737.                                                 NGX_HTTP_V2_PROTOCOL_ERROR);
  1738.         }

  1740.         return ngx_http_v2_state_field_len(h2c, pos, end);
  1741.     }

  1743.     if (h2c->state.parse_value) {
  1744.         h2c->state.parse_value = 0;

  1746.         header->value.len = h2c->state.field_end - h2c->state.field_start;
  1747.         header->value.data = h2c->state.field_start;
  1748.     }

  1750.     len = header->name.len + header->value.len;

  1752.     if (len > h2c->state.header_limit) {
  1753.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1754.                       "client sent too large header");

  1756.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_ENHANCE_YOUR_CALM);
  1757.     }

  1759.     h2c->state.header_limit -= len;

  1761.     if (h2c->state.index) {
  1762.         if (ngx_http_v2_add_header(h2c, header) != NGX_OK) {
  1763.             return ngx_http_v2_connection_error(h2c,
  1764.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1765.         }

  1767.         h2c->state.index = 0;
  1768.     }

  1770.     if (h2c->state.stream == NULL) {
  1771.         return ngx_http_v2_state_header_complete(h2c, pos, end);
  1772.     }

  1774.     r = h2c->state.stream->request;
  1775.     fc = r->connection;

  1777.     /* TODO Optimization: validate headers while parsing. */
  1778.     if (ngx_http_v2_validate_header(r, header) != NGX_OK) {
  1779.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1780.         goto error;
  1781.     }

  1783.     if (header->name.data[0] == ':') {
  1784.         rc = ngx_http_v2_pseudo_header(r, header);

  1786.         if (rc == NGX_OK) {
  1787.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1788.                            "http2 header: \":%V: %V\"",
  1789.                            &header->name, &header->value);

  1791.             return ngx_http_v2_state_header_complete(h2c, pos, end);
  1792.         }

  1794.         if (rc == NGX_ABORT) {
  1795.             goto error;
  1796.         }

  1798.         if (rc == NGX_DECLINED) {
  1799.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1800.             goto error;
  1801.         }

  1803.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1804.     }

  1806.     if (r->invalid_header) {
  1807.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1809.         if (cscf->ignore_invalid_headers) {
  1810.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1811.                           "client sent invalid header: \"%V\"", &header->name);

  1813.             return ngx_http_v2_state_header_complete(h2c, pos, end);
  1814.         }
  1815.     }

  1817.     if (header->name.len == cookie.len
  1818.         && ngx_memcmp(header->name.data, cookie.data, cookie.len) == 0)
  1819.     {
  1820.         if (ngx_http_v2_cookie(r, header) != NGX_OK) {
  1821.             return ngx_http_v2_connection_error(h2c,
  1822.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1823.         }

  1825.     } else {
  1826.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1828.         if (r->headers_in.count++ >= cscf->max_headers) {
  1829.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1830.                           "client sent too many header lines");
  1831.             ngx_http_finalize_request(r, NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  1832.             goto error;
  1833.         }

  1835.         h = ngx_list_push(&r->headers_in.headers);
  1836.         if (h == NULL) {
  1837.             return ngx_http_v2_connection_error(h2c,
  1838.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1839.         }

  1841.         h->key.len = header->name.len;
  1842.         h->key.data = header->name.data;

  1844.         /*
  1845.          * TODO Optimization: precalculate hash
  1846.          * and handler for indexed headers.
  1847.          */
  1848.         h->hash = ngx_hash_key(h->key.data, h->key.len);

  1850.         h->value.len = header->value.len;
  1851.         h->value.data = header->value.data;

  1853.         h->lowcase_key = h->key.data;

  1855.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  1860.         if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1861.             goto error;
  1862.         }
  1863.     }

  1865.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1866.                    "http2 header: \"%V: %V\"",
  1867.                    &header->name, &header->value);

  1869.     return ngx_http_v2_state_header_complete(h2c, pos, end);

  1871. error:

  1873.     h2c->state.stream = NULL;

  1875.     ngx_http_run_posted_requests(fc);

  1877.     return ngx_http_v2_state_header_complete(h2c, pos, end);
  1878. }


  1881. static u_char *
  1882. ‌ngx_http_v2_state_header_complete(ngx_http_v2_connection_t *h2c, u_char *pos,
  1883.     u_char *end)
  1884. {
  1885.     ngx_http_v2_stream_t  *stream;

  1887.     if (h2c->state.length) {
  1888.         if (end - pos > 0) {
  1889.             h2c->state.handler = ngx_http_v2_state_header_block;
  1890.             return pos;
  1891.         }

  1893.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1894.                                               ngx_http_v2_state_header_block);
  1895.     }

  1897.     if (!(h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG)) {
  1898.         return ngx_http_v2_handle_continuation(h2c, pos, end,
  1899.                                              ngx_http_v2_state_header_complete);
  1900.     }

  1902.     stream = h2c->state.stream;

  1904.     if (stream) {
  1905.         ngx_http_v2_run_request(stream->request);
  1906.     }

  1908.     if (!h2c->state.keep_pool) {
  1909.         ngx_destroy_pool(h2c->state.pool);
  1910.     }

  1912.     h2c->state.pool = NULL;
  1913.     h2c->state.keep_pool = 0;

  1915.     if (h2c->state.padding) {
  1916.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1917.     }

  1919.     return ngx_http_v2_state_complete(h2c, pos, end);
  1920. }


  1923. static u_char *
  1924. ‌ngx_http_v2_handle_continuation(ngx_http_v2_connection_t *h2c, u_char *pos,
  1925.     u_char *end, ngx_http_v2_handler_pt handler)
  1926. {
  1927.     u_char    *p;
  1928.     size_t     len, skip;
  1929.     uint32_t   head;

  1931.     len = h2c->state.length;

  1933.     if (h2c->state.padding && (size_t) (end - pos) > len) {
  1934.         skip = ngx_min(h2c->state.padding, (end - pos) - len);

  1936.         h2c->state.padding -= skip;

  1938.         p = pos;
  1939.         pos += skip;
  1940.         ngx_memmove(pos, p, len);
  1941.     }

  1943.     if ((size_t) (end - pos) < len + NGX_HTTP_V2_FRAME_HEADER_SIZE) {
  1944.         return ngx_http_v2_state_headers_save(h2c, pos, end, handler);
  1945.     }

  1947.     p = pos + len;

  1949.     head = ngx_http_v2_parse_uint32(p);

  1951.     if (ngx_http_v2_parse_type(head) != NGX_HTTP_V2_CONTINUATION_FRAME) {
  1952.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1953.              "client sent inappropriate frame while CONTINUATION was expected");

  1955.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1956.     }

  1958.     h2c->state.flags |= p[4];

  1960.     if (h2c->state.sid != ngx_http_v2_parse_sid(&p[5])) {
  1961.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1962.                     "client sent CONTINUATION frame with incorrect identifier");

  1964.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1965.     }

  1967.     p = pos;
  1968.     pos += NGX_HTTP_V2_FRAME_HEADER_SIZE;

  1970.     ngx_memcpy(pos, p, len);

  1972.     len = ngx_http_v2_parse_length(head);

  1974.     h2c->state.length += len;

  1976.     if (h2c->state.stream) {
  1977.         h2c->state.stream->request->request_length += len;
  1978.     }

  1980.     h2c->state.handler = handler;
  1981.     return pos;
  1982. }


  1985. static u_char *
  1986. ‌ngx_http_v2_state_priority(ngx_http_v2_connection_t *h2c, u_char *pos,
  1987.     u_char *end)
  1988. {
  1989.     ngx_uint_t           depend, dependency, excl, weight;
  1990.     ngx_http_v2_node_t  *node;

  1992.     if (h2c->state.length != NGX_HTTP_V2_PRIORITY_SIZE) {
  1993.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1994.                       "client sent PRIORITY frame with incorrect length %uz",
  1995.                       h2c->state.length);

  1997.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1998.     }

  2000.     if (--h2c->priority_limit == 0) {
  2001.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2002.                       "client sent too many PRIORITY frames");

  2004.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_ENHANCE_YOUR_CALM);
  2005.     }

  2007.     if (end - pos < NGX_HTTP_V2_PRIORITY_SIZE) {
  2008.         return ngx_http_v2_state_save(h2c, pos, end,
  2009.                                       ngx_http_v2_state_priority);
  2010.     }

  2012.     dependency = ngx_http_v2_parse_uint32(pos);

  2014.     depend = dependency & 0x7fffffff;
  2015.     excl = dependency >> 31;
  2016.     weight = pos[4] + 1;

  2018.     pos += NGX_HTTP_V2_PRIORITY_SIZE;

  2020.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2021.                    "http2 PRIORITY frame sid:%ui "
  2022.                    "depends on %ui excl:%ui weight:%ui",
  2023.                    h2c->state.sid, depend, excl, weight);

  2025.     if (h2c->state.sid == 0) {
  2026.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2027.                       "client sent PRIORITY frame with incorrect identifier");

  2029.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2030.     }

  2032.     if (depend == h2c->state.sid) {
  2033.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2034.                       "client sent PRIORITY frame for stream %ui "
  2035.                       "with incorrect dependency", h2c->state.sid);

  2037.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2038.     }

  2040.     node = ngx_http_v2_get_node_by_id(h2c, h2c->state.sid, 1);

  2042.     if (node == NULL) {
  2043.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2044.     }

  2046.     node->weight = weight;

  2048.     if (node->stream == NULL) {
  2049.         if (node->parent == NULL) {
  2050.             h2c->closed_nodes++;

  2052.         } else {
  2053.             ngx_queue_remove(&node->reuse);
  2054.         }

  2056.         ngx_queue_insert_tail(&h2c->closed, &node->reuse);
  2057.     }

  2059.     ngx_http_v2_set_dependency(h2c, node, depend, excl);

  2061.     return ngx_http_v2_state_complete(h2c, pos, end);
  2062. }


  2065. static u_char *
  2066. ‌ngx_http_v2_state_rst_stream(ngx_http_v2_connection_t *h2c, u_char *pos,
  2067.     u_char *end)
  2068. {
  2069.     ngx_uint_t             status;
  2070.     ngx_event_t           *ev;
  2071.     ngx_connection_t      *fc;
  2072.     ngx_http_v2_node_t    *node;
  2073.     ngx_http_v2_stream_t  *stream;

  2075.     if (h2c->state.length != NGX_HTTP_V2_RST_STREAM_SIZE) {
  2076.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2077.                       "client sent RST_STREAM frame with incorrect length %uz",
  2078.                       h2c->state.length);

  2080.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2081.     }

  2083.     if (end - pos < NGX_HTTP_V2_RST_STREAM_SIZE) {
  2084.         return ngx_http_v2_state_save(h2c, pos, end,
  2085.                                       ngx_http_v2_state_rst_stream);
  2086.     }

  2088.     status = ngx_http_v2_parse_uint32(pos);

  2090.     pos += NGX_HTTP_V2_RST_STREAM_SIZE;

  2092.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2093.                    "http2 RST_STREAM frame, sid:%ui status:%ui",
  2094.                    h2c->state.sid, status);

  2096.     if (h2c->state.sid == 0) {
  2097.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2098.                       "client sent RST_STREAM frame with incorrect identifier");

  2100.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2101.     }

  2103.     node = ngx_http_v2_get_node_by_id(h2c, h2c->state.sid, 0);

  2105.     if (node == NULL || node->stream == NULL) {
  2106.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2107.                        "unknown http2 stream");

  2109.         return ngx_http_v2_state_complete(h2c, pos, end);
  2110.     }

  2112.     stream = node->stream;

  2114.     stream->in_closed = 1;
  2115.     stream->out_closed = 1;

  2117.     fc = stream->request->connection;
  2118.     fc->error = 1;

  2120.     switch (status) {

  2122.     case NGX_HTTP_V2_CANCEL:
  2123.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2124.                       "client canceled stream %ui", h2c->state.sid);
  2125.         break;

  2127.     case NGX_HTTP_V2_INTERNAL_ERROR:
  2128.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2129.                       "client terminated stream %ui due to internal error",
  2130.                       h2c->state.sid);
  2131.         break;

  2133.     default:
  2134.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2135.                       "client terminated stream %ui with status %ui",
  2136.                       h2c->state.sid, status);
  2137.         break;
  2138.     }

  2140.     ev = fc->read;
  2141.     ev->handler(ev);

  2143.     return ngx_http_v2_state_complete(h2c, pos, end);
  2144. }


  2147. static u_char *
  2148. ‌ngx_http_v2_state_settings(ngx_http_v2_connection_t *h2c, u_char *pos,
  2149.     u_char *end)
  2150. {
  2151.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2152.                    "http2 SETTINGS frame");

  2154.     if (h2c->state.sid) {
  2155.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2156.                       "client sent SETTINGS frame with incorrect identifier");

  2158.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2159.     }

  2161.     if (h2c->state.flags == NGX_HTTP_V2_ACK_FLAG) {

  2163.         if (h2c->state.length != 0) {
  2164.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2165.                           "client sent SETTINGS frame with the ACK flag "
  2166.                           "and nonzero length");

  2168.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2169.         }

  2171.         h2c->settings_ack = 1;

  2173.         return ngx_http_v2_state_complete(h2c, pos, end);
  2174.     }

  2176.     if (h2c->state.length % NGX_HTTP_V2_SETTINGS_PARAM_SIZE) {
  2177.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2178.                       "client sent SETTINGS frame with incorrect length %uz",
  2179.                       h2c->state.length);

  2181.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2182.     }

  2184.     return ngx_http_v2_state_settings_params(h2c, pos, end);
  2185. }


  2188. static u_char *
  2189. ‌ngx_http_v2_state_settings_params(ngx_http_v2_connection_t *h2c, u_char *pos,
  2190.     u_char *end)
  2191. {
  2192.     ssize_t                   window_delta;
  2193.     ngx_uint_t                id, value;
  2194.     ngx_http_v2_out_frame_t  *frame;

  2196.     window_delta = 0;

  2198.     while (h2c->state.length) {
  2199.         if (end - pos < NGX_HTTP_V2_SETTINGS_PARAM_SIZE) {
  2200.             return ngx_http_v2_state_save(h2c, pos, end,
  2201.                                           ngx_http_v2_state_settings_params);
  2202.         }

  2204.         h2c->state.length -= NGX_HTTP_V2_SETTINGS_PARAM_SIZE;

  2206.         id = ngx_http_v2_parse_uint16(pos);
  2207.         value = ngx_http_v2_parse_uint32(&pos[2]);

  2209.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2210.                        "http2 setting %ui:%ui", id, value);

  2212.         switch (id) {

  2214.         case NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING:

  2216.             if (value > NGX_HTTP_V2_MAX_WINDOW) {
  2217.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2218.                               "client sent SETTINGS frame with incorrect "
  2219.                               "INITIAL_WINDOW_SIZE value %ui", value);

  2221.                 return ngx_http_v2_connection_error(h2c,
  2222.                                                   NGX_HTTP_V2_FLOW_CTRL_ERROR);
  2223.             }

  2225.             window_delta = value - h2c->init_window;
  2226.             break;

  2228.         case NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING:

  2230.             if (value > NGX_HTTP_V2_MAX_FRAME_SIZE
  2231.                 || value < NGX_HTTP_V2_DEFAULT_FRAME_SIZE)
  2232.             {
  2233.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2234.                               "client sent SETTINGS frame with incorrect "
  2235.                               "MAX_FRAME_SIZE value %ui", value);

  2237.                 return ngx_http_v2_connection_error(h2c,
  2238.                                                     NGX_HTTP_V2_PROTOCOL_ERROR);
  2239.             }

  2241.             h2c->frame_size = value;
  2242.             break;

  2244.         case NGX_HTTP_V2_ENABLE_PUSH_SETTING:

  2246.             if (value > 1) {
  2247.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2248.                               "client sent SETTINGS frame with incorrect "
  2249.                               "ENABLE_PUSH value %ui", value);

  2251.                 return ngx_http_v2_connection_error(h2c,
  2252.                                                     NGX_HTTP_V2_PROTOCOL_ERROR);
  2253.             }

  2255.             break;

  2257.         case NGX_HTTP_V2_HEADER_TABLE_SIZE_SETTING:

  2259.             h2c->table_update = 1;
  2260.             break;

  2262.         default:
  2263.             break;
  2264.         }

  2266.         pos += NGX_HTTP_V2_SETTINGS_PARAM_SIZE;
  2267.     }

  2269.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_SETTINGS_ACK_SIZE,
  2270.                                   NGX_HTTP_V2_SETTINGS_FRAME,
  2271.                                   NGX_HTTP_V2_ACK_FLAG, 0);
  2272.     if (frame == NULL) {
  2273.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2274.     }

  2276.     ngx_http_v2_queue_ordered_frame(h2c, frame);

  2278.     if (window_delta) {
  2279.         h2c->init_window += window_delta;

  2281.         if (ngx_http_v2_adjust_windows(h2c, window_delta) != NGX_OK) {
  2282.             return ngx_http_v2_connection_error(h2c,
  2283.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  2284.         }
  2285.     }

  2287.     return ngx_http_v2_state_complete(h2c, pos, end);
  2288. }


  2291. static u_char *
  2292. ‌ngx_http_v2_state_push_promise(ngx_http_v2_connection_t *h2c, u_char *pos,
  2293.     u_char *end)
  2294. {
  2295.     ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2296.                   "client sent PUSH_PROMISE frame");

  2298.     return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2299. }


  2302. static u_char *
  2303. ‌ngx_http_v2_state_ping(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  2304. {
  2305.     ngx_buf_t                *buf;
  2306.     ngx_http_v2_out_frame_t  *frame;

  2308.     if (h2c->state.length != NGX_HTTP_V2_PING_SIZE) {
  2309.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2310.                       "client sent PING frame with incorrect length %uz",
  2311.                       h2c->state.length);

  2313.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2314.     }

  2316.     if (end - pos < NGX_HTTP_V2_PING_SIZE) {
  2317.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_ping);
  2318.     }

  2320.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2321.                    "http2 PING frame");

  2323.     if (h2c->state.sid) {
  2324.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2325.                       "client sent PING frame with incorrect identifier");

  2327.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2328.     }

  2330.     if (h2c->state.flags & NGX_HTTP_V2_ACK_FLAG) {
  2331.         return ngx_http_v2_state_skip(h2c, pos, end);
  2332.     }

  2334.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_PING_SIZE,
  2335.                                   NGX_HTTP_V2_PING_FRAME,
  2336.                                   NGX_HTTP_V2_ACK_FLAG, 0);
  2337.     if (frame == NULL) {
  2338.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2339.     }

  2341.     buf = frame->first->buf;

  2343.     buf->last = ngx_cpymem(buf->last, pos, NGX_HTTP_V2_PING_SIZE);

  2345.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2347.     return ngx_http_v2_state_complete(h2c, pos + NGX_HTTP_V2_PING_SIZE, end);
  2348. }


  2351. static u_char *
  2352. ‌ngx_http_v2_state_goaway(ngx_http_v2_connection_t *h2c, u_char *pos,
  2353.     u_char *end)
  2354. {
  2355. #if (NGX_DEBUG)
  2356.     ngx_uint_t  last_sid, error;
  2357. #endif

  2359.     if (h2c->state.length < NGX_HTTP_V2_GOAWAY_SIZE) {
  2360.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2361.                       "client sent GOAWAY frame "
  2362.                       "with incorrect length %uz", h2c->state.length);

  2364.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2365.     }

  2367.     if (end - pos < NGX_HTTP_V2_GOAWAY_SIZE) {
  2368.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_goaway);
  2369.     }

  2371.     if (h2c->state.sid) {
  2372.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2373.                       "client sent GOAWAY frame with incorrect identifier");

  2375.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2376.     }

  2378. #if (NGX_DEBUG)
  2379.     h2c->state.length -= NGX_HTTP_V2_GOAWAY_SIZE;

  2381.     last_sid = ngx_http_v2_parse_sid(pos);
  2382.     error = ngx_http_v2_parse_uint32(&pos[4]);

  2384.     pos += NGX_HTTP_V2_GOAWAY_SIZE;

  2386.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2387.                    "http2 GOAWAY frame: last sid %ui, error %ui",
  2388.                    last_sid, error);
  2389. #endif

  2391.     return ngx_http_v2_state_skip(h2c, pos, end);
  2392. }


  2395. static u_char *
  2396. ‌ngx_http_v2_state_window_update(ngx_http_v2_connection_t *h2c, u_char *pos,
  2397.     u_char *end)
  2398. {
  2399.     size_t                 window;
  2400.     ngx_event_t           *wev;
  2401.     ngx_queue_t           *q;
  2402.     ngx_http_v2_node_t    *node;
  2403.     ngx_http_v2_stream_t  *stream;

  2405.     if (h2c->state.length != NGX_HTTP_V2_WINDOW_UPDATE_SIZE) {
  2406.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2407.                       "client sent WINDOW_UPDATE frame "
  2408.                       "with incorrect length %uz", h2c->state.length);

  2410.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2411.     }

  2413.     if (end - pos < NGX_HTTP_V2_WINDOW_UPDATE_SIZE) {
  2414.         return ngx_http_v2_state_save(h2c, pos, end,
  2415.                                       ngx_http_v2_state_window_update);
  2416.     }

  2418.     window = ngx_http_v2_parse_window(pos);

  2420.     pos += NGX_HTTP_V2_WINDOW_UPDATE_SIZE;

  2422.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2423.                    "http2 WINDOW_UPDATE frame sid:%ui window:%uz",
  2424.                    h2c->state.sid, window);

  2426.     if (window == 0) {
  2427.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2428.                       "client sent WINDOW_UPDATE frame "
  2429.                       "with incorrect window increment 0");

  2431.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2432.     }

  2434.     if (h2c->state.sid) {
  2435.         node = ngx_http_v2_get_node_by_id(h2c, h2c->state.sid, 0);

  2437.         if (node == NULL || node->stream == NULL) {
  2438.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2439.                            "unknown http2 stream");

  2441.             return ngx_http_v2_state_complete(h2c, pos, end);
  2442.         }

  2444.         stream = node->stream;

  2446.         if (window > (size_t) (NGX_HTTP_V2_MAX_WINDOW - stream->send_window)) {

  2448.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2449.                           "client violated flow control for stream %ui: "
  2450.                           "received WINDOW_UPDATE frame "
  2451.                           "with window increment %uz "
  2452.                           "not allowed for window %z",
  2453.                           h2c->state.sid, window, stream->send_window);

  2455.             if (ngx_http_v2_terminate_stream(h2c, stream,
  2456.                                              NGX_HTTP_V2_FLOW_CTRL_ERROR)
  2457.                 == NGX_ERROR)
  2458.             {
  2459.                 return ngx_http_v2_connection_error(h2c,
  2460.                                                     NGX_HTTP_V2_INTERNAL_ERROR);
  2461.             }

  2463.             return ngx_http_v2_state_complete(h2c, pos, end);
  2464.         }

  2466.         stream->send_window += window;

  2468.         if (stream->exhausted) {
  2469.             stream->exhausted = 0;

  2471.             wev = stream->request->connection->write;

  2473.             wev->active = 0;
  2474.             wev->ready = 1;

  2476.             if (!wev->delayed) {
  2477.                 wev->handler(wev);
  2478.             }
  2479.         }

  2481.         return ngx_http_v2_state_complete(h2c, pos, end);
  2482.     }

  2484.     if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
  2485.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2486.                       "client violated connection flow control: "
  2487.                       "received WINDOW_UPDATE frame "
  2488.                       "with window increment %uz "
  2489.                       "not allowed for window %uz",
  2490.                       window, h2c->send_window);

  2492.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
  2493.     }

  2495.     h2c->send_window += window;

  2497.     while (!ngx_queue_empty(&h2c->waiting)) {
  2498.         q = ngx_queue_head(&h2c->waiting);

  2500.         ngx_queue_remove(q);

  2502.         stream = ngx_queue_data(q, ngx_http_v2_stream_t, queue);

  2504.         stream->waiting = 0;

  2506.         wev = stream->request->connection->write;

  2508.         wev->active = 0;
  2509.         wev->ready = 1;

  2511.         if (!wev->delayed) {
  2512.             wev->handler(wev);

  2514.             if (h2c->send_window == 0) {
  2515.                 break;
  2516.             }
  2517.         }
  2518.     }

  2520.     return ngx_http_v2_state_complete(h2c, pos, end);
  2521. }


  2524. static u_char *
  2525. ‌ngx_http_v2_state_continuation(ngx_http_v2_connection_t *h2c, u_char *pos,
  2526.     u_char *end)
  2527. {
  2528.     ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2529.                   "client sent unexpected CONTINUATION frame");

  2531.     return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2532. }


  2535. static u_char *
  2536. ‌ngx_http_v2_state_complete(ngx_http_v2_connection_t *h2c, u_char *pos,
  2537.     u_char *end)
  2538. {
  2539.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2540.                    "http2 frame complete pos:%p end:%p", pos, end);

  2542.     if (pos > end) {
  2543.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  2544.                       "receive buffer overrun");

  2546.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2547.     }

  2549.     h2c->state.stream = NULL;
  2550.     h2c->state.handler = ngx_http_v2_state_head;

  2552.     return pos;
  2553. }


  2556. static u_char *
  2557. ‌ngx_http_v2_state_skip_padded(ngx_http_v2_connection_t *h2c, u_char *pos,
  2558.     u_char *end)
  2559. {
  2560.     h2c->state.length += h2c->state.padding;
  2561.     h2c->state.padding = 0;

  2563.     return ngx_http_v2_state_skip(h2c, pos, end);
  2564. }


  2567. static u_char *
  2568. ‌ngx_http_v2_state_skip(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  2569. {
  2570.     size_t  size;

  2572.     size = end - pos;

  2574.     if (size < h2c->state.length) {
  2575.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2576.                        "http2 frame skip %uz of %uz", size, h2c->state.length);

  2578.         h2c->state.length -= size;
  2579.         return ngx_http_v2_state_save(h2c, end, end, ngx_http_v2_state_skip);
  2580.     }

  2582.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2583.                    "http2 frame skip %uz", h2c->state.length);

  2585.     return ngx_http_v2_state_complete(h2c, pos + h2c->state.length, end);
  2586. }


  2589. static u_char *
  2590. ‌ngx_http_v2_state_save(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end,
  2591.     ngx_http_v2_handler_pt handler)
  2592. {
  2593.     size_t  size;

  2595.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2596.                    "http2 frame state save pos:%p end:%p handler:%p",
  2597.                    pos, end, handler);

  2599.     size = end - pos;

  2601.     if (size > NGX_HTTP_V2_STATE_BUFFER_SIZE) {
  2602.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  2603.                       "state buffer overflow: %uz bytes required", size);

  2605.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2606.     }

  2608.     ngx_memcpy(h2c->state.buffer, pos, size);

  2610.     h2c->state.buffer_used = size;
  2611.     h2c->state.handler = handler;
  2612.     h2c->state.incomplete = 1;

  2614.     return end;
  2615. }


  2618. static u_char *
  2619. ‌ngx_http_v2_state_headers_save(ngx_http_v2_connection_t *h2c, u_char *pos,
  2620.     u_char *end, ngx_http_v2_handler_pt handler)
  2621. {
  2622.     ngx_event_t               *rev;
  2623.     ngx_http_request_t        *r;
  2624.     ngx_http_core_srv_conf_t  *cscf;

  2626.     if (h2c->state.stream) {
  2627.         r = h2c->state.stream->request;
  2628.         rev = r->connection->read;

  2630.         if (!rev->timer_set) {
  2631.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2632.             ngx_add_timer(rev, cscf->client_header_timeout);
  2633.         }
  2634.     }

  2636.     return ngx_http_v2_state_save(h2c, pos, end, handler);
  2637. }


  2640. static u_char *
  2641. ‌ngx_http_v2_connection_error(ngx_http_v2_connection_t *h2c,
  2642.     ngx_uint_t err)
  2643. {
  2644.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2645.                    "http2 state connection error");

  2647.     ngx_http_v2_finalize_connection(h2c, err);

  2649.     return NULL;
  2650. }


  2653. static ngx_int_t
  2654. ‌ngx_http_v2_parse_int(ngx_http_v2_connection_t *h2c, u_char **pos, u_char *end,
  2655.     ngx_uint_t prefix)
  2656. {
  2657.     u_char      *start, *p;
  2658.     ngx_uint_t   value, octet, shift;

  2660.     start = *pos;
  2661.     p = start;

  2663.     value = *p++ & prefix;

  2665.     if (value != prefix) {
  2666.         if (h2c->state.length == 0) {
  2667.             return NGX_ERROR;
  2668.         }

  2670.         h2c->state.length--;

  2672.         *pos = p;
  2673.         return value;
  2674.     }

  2676.     if (end - start > NGX_HTTP_V2_INT_OCTETS) {
  2677.         end = start + NGX_HTTP_V2_INT_OCTETS;
  2678.     }

  2680.     for (shift = 0; p != end; shift += 7) {
  2681.         octet = *p++;

  2683.         value += (octet & 0x7f) << shift;

  2685.         if (octet < 128) {
  2686.             if ((size_t) (p - start) > h2c->state.length) {
  2687.                 return NGX_ERROR;
  2688.             }

  2690.             h2c->state.length -= p - start;

  2692.             *pos = p;
  2693.             return value;
  2694.         }
  2695.     }

  2697.     if ((size_t) (end - start) >= h2c->state.length) {
  2698.         return NGX_ERROR;
  2699.     }

  2701.     if (end == start + NGX_HTTP_V2_INT_OCTETS) {
  2702.         return NGX_DECLINED;
  2703.     }

  2705.     return NGX_AGAIN;
  2706. }


  2709. static ngx_int_t
  2710. ‌ngx_http_v2_send_settings(ngx_http_v2_connection_t *h2c)
  2711. {
  2712.     size_t                    len;
  2713.     ngx_buf_t                *buf;
  2714.     ngx_chain_t              *cl;
  2715.     ngx_http_v2_srv_conf_t   *h2scf;
  2716.     ngx_http_v2_out_frame_t  *frame;

  2718.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2719.                    "http2 send SETTINGS frame");

  2721.     frame = ngx_palloc(h2c->pool, sizeof(ngx_http_v2_out_frame_t));
  2722.     if (frame == NULL) {
  2723.         return NGX_ERROR;
  2724.     }

  2726.     cl = ngx_alloc_chain_link(h2c->pool);
  2727.     if (cl == NULL) {
  2728.         return NGX_ERROR;
  2729.     }

  2731.     len = NGX_HTTP_V2_SETTINGS_PARAM_SIZE * 3;

  2733.     buf = ngx_create_temp_buf(h2c->pool, NGX_HTTP_V2_FRAME_HEADER_SIZE + len);
  2734.     if (buf == NULL) {
  2735.         return NGX_ERROR;
  2736.     }

  2738.     buf->last_buf = 1;

  2740.     cl->buf = buf;
  2741.     cl->next = NULL;

  2743.     frame->first = cl;
  2744.     frame->last = cl;
  2745.     frame->handler = ngx_http_v2_settings_frame_handler;
  2746.     frame->stream = NULL;
  2747. #if (NGX_DEBUG)
  2748.     frame->length = len;
  2749. #endif
  2750.     frame->blocked = 0;

  2752.     buf->last = ngx_http_v2_write_len_and_type(buf->last, len,
  2753.                                                NGX_HTTP_V2_SETTINGS_FRAME);

  2755.     *buf->last++ = NGX_HTTP_V2_NO_FLAG;

  2757.     buf->last = ngx_http_v2_write_sid(buf->last, 0);

  2759.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  2760.                                          ngx_http_v2_module);

  2762.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2763.                                          NGX_HTTP_V2_MAX_STREAMS_SETTING);
  2764.     buf->last = ngx_http_v2_write_uint32(buf->last,
  2765.                                          h2scf->concurrent_streams);

  2767.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2768.                                          NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING);
  2769.     buf->last = ngx_http_v2_write_uint32(buf->last, h2scf->preread_size);

  2771.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2772.                                          NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING);
  2773.     buf->last = ngx_http_v2_write_uint32(buf->last,
  2774.                                          NGX_HTTP_V2_MAX_FRAME_SIZE);

  2776.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2778.     return NGX_OK;
  2779. }


  2782. static ngx_int_t
  2783. ‌ngx_http_v2_settings_frame_handler(ngx_http_v2_connection_t *h2c,
  2784.     ngx_http_v2_out_frame_t *frame)
  2785. {
  2786.     ngx_buf_t  *buf;

  2788.     buf = frame->first->buf;

  2790.     if (buf->pos != buf->last) {
  2791.         return NGX_AGAIN;
  2792.     }

  2794.     ngx_free_chain(h2c->pool, frame->first);

  2796.     return NGX_OK;
  2797. }


  2800. static ngx_int_t
  2801. ‌ngx_http_v2_send_window_update(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  2802.     size_t window)
  2803. {
  2804.     ngx_buf_t                *buf;
  2805.     ngx_http_v2_out_frame_t  *frame;

  2807.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2808.                    "http2 send WINDOW_UPDATE frame sid:%ui, window:%uz",
  2809.                    sid, window);

  2811.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_WINDOW_UPDATE_SIZE,
  2812.                                   NGX_HTTP_V2_WINDOW_UPDATE_FRAME,
  2813.                                   NGX_HTTP_V2_NO_FLAG, sid);
  2814.     if (frame == NULL) {
  2815.         return NGX_ERROR;
  2816.     }

  2818.     buf = frame->first->buf;

  2820.     buf->last = ngx_http_v2_write_uint32(buf->last, window);

  2822.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2824.     return NGX_OK;
  2825. }


  2828. static ngx_int_t
  2829. ‌ngx_http_v2_send_rst_stream(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  2830.     ngx_uint_t status)
  2831. {
  2832.     ngx_buf_t                *buf;
  2833.     ngx_http_v2_out_frame_t  *frame;

  2835.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2836.                    "http2 send RST_STREAM frame sid:%ui, status:%ui",
  2837.                    sid, status);

  2839.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_RST_STREAM_SIZE,
  2840.                                   NGX_HTTP_V2_RST_STREAM_FRAME,
  2841.                                   NGX_HTTP_V2_NO_FLAG, sid);
  2842.     if (frame == NULL) {
  2843.         return NGX_ERROR;
  2844.     }

  2846.     buf = frame->first->buf;

  2848.     buf->last = ngx_http_v2_write_uint32(buf->last, status);

  2850.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2852.     return NGX_OK;
  2853. }


  2856. static ngx_int_t
  2857. ‌ngx_http_v2_send_goaway(ngx_http_v2_connection_t *h2c, ngx_uint_t status)
  2858. {
  2859.     ngx_buf_t                *buf;
  2860.     ngx_http_v2_out_frame_t  *frame;

  2862.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2863.                    "http2 send GOAWAY frame: last sid %ui, error %ui",
  2864.                    h2c->last_sid, status);

  2866.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_GOAWAY_SIZE,
  2867.                                   NGX_HTTP_V2_GOAWAY_FRAME,
  2868.                                   NGX_HTTP_V2_NO_FLAG, 0);
  2869.     if (frame == NULL) {
  2870.         return NGX_ERROR;
  2871.     }

  2873.     buf = frame->first->buf;

  2875.     buf->last = ngx_http_v2_write_sid(buf->last, h2c->last_sid);
  2876.     buf->last = ngx_http_v2_write_uint32(buf->last, status);

  2878.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2880.     return NGX_OK;
  2881. }


  2884. static ngx_http_v2_out_frame_t *
  2885. ‌ngx_http_v2_get_frame(ngx_http_v2_connection_t *h2c, size_t length,
  2886.     ngx_uint_t type, u_char flags, ngx_uint_t sid)
  2887. {
  2888.     ngx_buf_t                *buf;
  2889.     ngx_pool_t               *pool;
  2890.     ngx_http_v2_out_frame_t  *frame;

  2892.     frame = h2c->free_frames;

  2894.     if (frame) {
  2895.         h2c->free_frames = frame->next;

  2897.         buf = frame->first->buf;
  2898.         buf->pos = buf->start;

  2900.         frame->blocked = 0;

  2902.     } else if (h2c->frames < 10000) {
  2903.         pool = h2c->pool ? h2c->pool : h2c->connection->pool;

  2905.         frame = ngx_pcalloc(pool, sizeof(ngx_http_v2_out_frame_t));
  2906.         if (frame == NULL) {
  2907.             return NULL;
  2908.         }

  2910.         frame->first = ngx_alloc_chain_link(pool);
  2911.         if (frame->first == NULL) {
  2912.             return NULL;
  2913.         }

  2915.         buf = ngx_create_temp_buf(pool, NGX_HTTP_V2_FRAME_BUFFER_SIZE);
  2916.         if (buf == NULL) {
  2917.             return NULL;
  2918.         }

  2920.         buf->last_buf = 1;

  2922.         frame->first->buf = buf;
  2923.         frame->last = frame->first;

  2925.         frame->handler = ngx_http_v2_frame_handler;

  2927.         h2c->frames++;

  2929.     } else {
  2930.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2931.                       "http2 flood detected");

  2933.         h2c->connection->error = 1;
  2934.         return NULL;
  2935.     }

  2937. #if (NGX_DEBUG)
  2938.     if (length > NGX_HTTP_V2_FRAME_BUFFER_SIZE - NGX_HTTP_V2_FRAME_HEADER_SIZE)
  2939.     {
  2940.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  2941.                       "requested control frame is too large: %uz", length);
  2942.         return NULL;
  2943.     }
  2944. #endif

  2946.     frame->length = length;

  2948.     buf->last = ngx_http_v2_write_len_and_type(buf->pos, length, type);

  2950.     *buf->last++ = flags;

  2952.     buf->last = ngx_http_v2_write_sid(buf->last, sid);

  2954.     return frame;
  2955. }


  2958. static ngx_int_t
  2959. ‌ngx_http_v2_frame_handler(ngx_http_v2_connection_t *h2c,
  2960.     ngx_http_v2_out_frame_t *frame)
  2961. {
  2962.     ngx_buf_t  *buf;

  2964.     buf = frame->first->buf;

  2966.     if (buf->pos != buf->last) {
  2967.         return NGX_AGAIN;
  2968.     }

  2970.     frame->next = h2c->free_frames;
  2971.     h2c->free_frames = frame;

  2973.     h2c->total_bytes += NGX_HTTP_V2_FRAME_HEADER_SIZE + frame->length;

  2975.     return NGX_OK;
  2976. }


  2979. static ngx_http_v2_stream_t *
  2980. ‌ngx_http_v2_create_stream(ngx_http_v2_connection_t *h2c)
  2981. {
  2982.     ngx_log_t                 *log;
  2983.     ngx_event_t               *rev, *wev;
  2984.     ngx_connection_t          *fc;
  2985.     ngx_http_log_ctx_t        *ctx;
  2986.     ngx_http_request_t        *r;
  2987.     ngx_http_v2_stream_t      *stream;
  2988.     ngx_http_v2_srv_conf_t    *h2scf;
  2989.     ngx_http_core_srv_conf_t  *cscf;

  2991.     fc = h2c->free_fake_connections;

  2993.     if (fc) {
  2994.         h2c->free_fake_connections = fc->data;

  2996.         rev = fc->read;
  2997.         wev = fc->write;
  2998.         log = fc->log;
  2999.         ctx = log->data;

  3001.     } else {
  3002.         fc = ngx_palloc(h2c->pool, sizeof(ngx_connection_t));
  3003.         if (fc == NULL) {
  3004.             return NULL;
  3005.         }

  3007.         rev = ngx_palloc(h2c->pool, sizeof(ngx_event_t));
  3008.         if (rev == NULL) {
  3009.             return NULL;
  3010.         }

  3012.         wev = ngx_palloc(h2c->pool, sizeof(ngx_event_t));
  3013.         if (wev == NULL) {
  3014.             return NULL;
  3015.         }

  3017.         log = ngx_palloc(h2c->pool, sizeof(ngx_log_t));
  3018.         if (log == NULL) {
  3019.             return NULL;
  3020.         }

  3022.         ctx = ngx_palloc(h2c->pool, sizeof(ngx_http_log_ctx_t));
  3023.         if (ctx == NULL) {
  3024.             return NULL;
  3025.         }

  3027.         ctx->connection = fc;
  3028.         ctx->request = NULL;
  3029.         ctx->current_request = NULL;
  3030.     }

  3032.     ngx_memcpy(log, h2c->connection->log, sizeof(ngx_log_t));

  3034.     log->data = ctx;
  3035.     log->action = "reading client request headers";

  3037.     ngx_memzero(rev, sizeof(ngx_event_t));

  3039.     rev->data = fc;
  3040.     rev->ready = 1;
  3041.     rev->handler = ngx_http_v2_close_stream_handler;
  3042.     rev->log = log;

  3044.     ngx_memcpy(wev, rev, sizeof(ngx_event_t));

  3046.     wev->write = 1;

  3048.     ngx_memcpy(fc, h2c->connection, sizeof(ngx_connection_t));

  3050.     fc->data = h2c->http_connection;
  3051.     fc->read = rev;
  3052.     fc->write = wev;
  3053.     fc->sent = 0;
  3054.     fc->log = log;
  3055.     fc->buffered = 0;
  3056.     fc->sndlowat = 1;
  3057.     fc->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;

  3059.     r = ngx_http_create_request(fc);
  3060.     if (r == NULL) {
  3061.         return NULL;
  3062.     }

  3064.     ngx_str_set(&r->http_protocol, "HTTP/2.0");

  3066.     r->http_version = NGX_HTTP_VERSION_20;
  3067.     r->valid_location = 1;

  3069.     fc->data = r;
  3070.     h2c->connection->requests++;

  3072.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  3074.     r->header_in = ngx_create_temp_buf(r->pool,
  3075.                                        cscf->client_header_buffer_size);
  3076.     if (r->header_in == NULL) {
  3077.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3078.         return NULL;
  3079.     }

  3081.     if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  3082.                       sizeof(ngx_table_elt_t))
  3083.         != NGX_OK)
  3084.     {
  3085.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3086.         return NULL;
  3087.     }

  3089.     r->headers_in.connection_type = NGX_HTTP_CONNECTION_CLOSE;

  3091.     stream = ngx_pcalloc(r->pool, sizeof(ngx_http_v2_stream_t));
  3092.     if (stream == NULL) {
  3093.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3094.         return NULL;
  3095.     }

  3097.     r->stream = stream;

  3099.     stream->request = r;
  3100.     stream->connection = h2c;

  3102.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

  3104.     stream->send_window = h2c->init_window;
  3105.     stream->recv_window = h2scf->preread_size;

  3107.     h2c->processing++;

  3109.     h2c->priority_limit += h2scf->concurrent_streams;

  3111.     if (h2c->connection->read->timer_set) {
  3112.         ngx_del_timer(h2c->connection->read);
  3113.     }

  3115.     return stream;
  3116. }


  3119. static ngx_http_v2_node_t *
  3120. ‌ngx_http_v2_get_node_by_id(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  3121.     ngx_uint_t alloc)
  3122. {
  3123.     ngx_uint_t               index;
  3124.     ngx_http_v2_node_t      *node;
  3125.     ngx_http_v2_srv_conf_t  *h2scf;

  3127.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  3128.                                          ngx_http_v2_module);

  3130.     index = ngx_http_v2_index(h2scf, sid);

  3132.     for (node = h2c->streams_index[index]; node; node = node->index) {

  3134.         if (node->id == sid) {
  3135.             return node;
  3136.         }
  3137.     }

  3139.     if (!alloc) {
  3140.         return NULL;
  3141.     }

  3143.     if (h2c->closed_nodes < 32) {
  3144.         node = ngx_pcalloc(h2c->connection->pool, sizeof(ngx_http_v2_node_t));
  3145.         if (node == NULL) {
  3146.             return NULL;
  3147.         }

  3149.     } else {
  3150.         node = ngx_http_v2_get_closed_node(h2c);
  3151.     }

  3153.     node->id = sid;

  3155.     ngx_queue_init(&node->children);

  3157.     node->index = h2c->streams_index[index];
  3158.     h2c->streams_index[index] = node;

  3160.     return node;
  3161. }


  3164. static ngx_http_v2_node_t *
  3165. ‌ngx_http_v2_get_closed_node(ngx_http_v2_connection_t *h2c)
  3166. {
  3167.     ngx_uint_t               weight;
  3168.     ngx_queue_t             *q, *children;
  3169.     ngx_http_v2_node_t      *node, **next, *n, *parent, *child;
  3170.     ngx_http_v2_srv_conf_t  *h2scf;

  3172.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  3173.                                          ngx_http_v2_module);

  3175.     h2c->closed_nodes--;

  3177.     q = ngx_queue_head(&h2c->closed);

  3179.     ngx_queue_remove(q);

  3181.     node = ngx_queue_data(q, ngx_http_v2_node_t, reuse);

  3183.     next = &h2c->streams_index[ngx_http_v2_index(h2scf, node->id)];

  3185.     for ( ;; ) {
  3186.         n = *next;

  3188.         if (n == node) {
  3189.             *next = n->index;
  3190.             break;
  3191.         }

  3193.         next = &n->index;
  3194.     }

  3196.     ngx_queue_remove(&node->queue);

  3198.     weight = 0;

  3200.     for (q = ngx_queue_head(&node->children);
  3201.          q != ngx_queue_sentinel(&node->children);
  3202.          q = ngx_queue_next(q))
  3203.     {
  3204.         child = ngx_queue_data(q, ngx_http_v2_node_t, queue);
  3205.         weight += child->weight;
  3206.     }

  3208.     parent = node->parent;

  3210.     for (q = ngx_queue_head(&node->children);
  3211.          q != ngx_queue_sentinel(&node->children);
  3212.          q = ngx_queue_next(q))
  3213.     {
  3214.         child = ngx_queue_data(q, ngx_http_v2_node_t, queue);
  3215.         child->parent = parent;
  3216.         child->weight = node->weight * child->weight / weight;

  3218.         if (child->weight == 0) {
  3219.             child->weight = 1;
  3220.         }
  3221.     }

  3223.     if (parent == NGX_HTTP_V2_ROOT) {
  3224.         node->rank = 0;
  3225.         node->rel_weight = 1.0;

  3227.         children = &h2c->dependencies;

  3229.     } else {
  3230.         node->rank = parent->rank;
  3231.         node->rel_weight = parent->rel_weight;

  3233.         children = &parent->children;
  3234.     }

  3236.     ngx_http_v2_node_children_update(node);
  3237.     ngx_queue_add(children, &node->children);

  3239.     ngx_memzero(node, sizeof(ngx_http_v2_node_t));

  3241.     return node;
  3242. }


  3245. static ngx_int_t
  3246. ‌ngx_http_v2_validate_header(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3247. {
  3248.     u_char                     ch;
  3249.     ngx_uint_t                 i;
  3250.     ngx_http_core_srv_conf_t  *cscf;

  3252.     r->invalid_header = 0;

  3254.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  3256.     for (i = (header->name.data[0] == ':'); i != header->name.len; i++) {
  3257.         ch = header->name.data[i];

  3259.         if ((ch >= 'a' && ch <= 'z')
  3260.             || (ch == '-')
  3261.             || (ch >= '0' && ch <= '9')
  3262.             || (ch == '_' && cscf->underscores_in_headers))
  3263.         {
  3264.             continue;
  3265.         }

  3267.         if (ch <= 0x20 || ch == 0x7f || ch == ':'
  3268.             || (ch >= 'A' && ch <= 'Z'))
  3269.         {
  3270.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3271.                           "client sent invalid header name: \"%V\"",
  3272.                           &header->name);

  3274.             return NGX_ERROR;
  3275.         }

  3277.         r->invalid_header = 1;
  3278.     }

  3280.     for (i = 0; i != header->value.len; i++) {
  3281.         ch = header->value.data[i];

  3283.         if (ch == '\0' || ch == LF || ch == CR) {
  3284.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3285.                           "client sent header \"%V\" with "
  3286.                           "invalid value: \"%V\"",
  3287.                           &header->name, &header->value);

  3289.             return NGX_ERROR;
  3290.         }
  3291.     }

  3293.     return NGX_OK;
  3294. }


  3297. static ngx_int_t
  3298. ‌ngx_http_v2_pseudo_header(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3299. {
  3300.     header->name.len--;
  3301.     header->name.data++;

  3303.     switch (header->name.len) {
  3304.     case 4:
  3305.         if (ngx_memcmp(header->name.data, "path", sizeof("path") - 1)
  3306.             == 0)
  3307.         {
  3308.             return ngx_http_v2_parse_path(r, &header->value);
  3309.         }

  3311.         break;

  3313.     case 6:
  3314.         if (ngx_memcmp(header->name.data, "method", sizeof("method") - 1)
  3315.             == 0)
  3316.         {
  3317.             return ngx_http_v2_parse_method(r, &header->value);
  3318.         }

  3320.         if (ngx_memcmp(header->name.data, "scheme", sizeof("scheme") - 1)
  3321.             == 0)
  3322.         {
  3323.             return ngx_http_v2_parse_scheme(r, &header->value);
  3324.         }

  3326.         break;

  3328.     case 9:
  3329.         if (ngx_memcmp(header->name.data, "authority", sizeof("authority") - 1)
  3330.             == 0)
  3331.         {
  3332.             return ngx_http_v2_parse_authority(r, &header->value);
  3333.         }

  3335.         break;
  3336.     }

  3338.     ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3339.                   "client sent unknown pseudo-header \":%V\"",
  3340.                   &header->name);

  3342.     return NGX_DECLINED;
  3343. }


  3346. static ngx_int_t
  3347. ‌ngx_http_v2_parse_path(ngx_http_request_t *r, ngx_str_t *value)
  3348. {
  3349.     if (r->unparsed_uri.len) {
  3350.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3351.                       "client sent duplicate :path header");

  3353.         return NGX_DECLINED;
  3354.     }

  3356.     if (value->len == 0) {
  3357.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3358.                       "client sent empty :path header");

  3360.         return NGX_DECLINED;
  3361.     }

  3363.     r->uri_start = value->data;
  3364.     r->uri_end = value->data + value->len;

  3366.     if (ngx_http_parse_uri(r) != NGX_OK) {
  3367.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3368.                       "client sent invalid :path header: \"%V\"", value);

  3370.         return NGX_DECLINED;
  3371.     }

  3373.     if (ngx_http_process_request_uri(r) != NGX_OK) {
  3374.         /*
  3375.          * request has been finalized already
  3376.          * in ngx_http_process_request_uri()
  3377.          */
  3378.         return NGX_ABORT;
  3379.     }

  3381.     return NGX_OK;
  3382. }


  3385. static ngx_int_t
  3386. ‌ngx_http_v2_parse_method(ngx_http_request_t *r, ngx_str_t *value)
  3387. {
  3388.     size_t         k, len;
  3389.     ngx_uint_t     n;
  3390.     const u_char  *p, *m;

  3392.     /*
  3393.      * This array takes less than 256 sequential bytes,
  3394.      * and if typical CPU cache line size is 64 bytes,
  3395.      * it is prefetched for 4 load operations.
  3396.      */
  3397. ‌    static const struct {
  3398.         u_char            len;
  3399.         const u_char      method[11];
  3400.         uint32_t          value;
  3401.     } tests[] = {
  3402.         { 3, "GET",       NGX_HTTP_GET },
  3403.         { 4, "POST",      NGX_HTTP_POST },
  3404.         { 4, "HEAD",      NGX_HTTP_HEAD },
  3405.         { 7, "OPTIONS",   NGX_HTTP_OPTIONS },
  3406.         { 8, "PROPFIND",  NGX_HTTP_PROPFIND },
  3407.         { 3, "PUT",       NGX_HTTP_PUT },
  3408.         { 5, "MKCOL",     NGX_HTTP_MKCOL },
  3409.         { 6, "DELETE",    NGX_HTTP_DELETE },
  3410.         { 4, "COPY",      NGX_HTTP_COPY },
  3411.         { 4, "MOVE",      NGX_HTTP_MOVE },
  3412.         { 9, "PROPPATCH", NGX_HTTP_PROPPATCH },
  3413.         { 4, "LOCK",      NGX_HTTP_LOCK },
  3414.         { 6, "UNLOCK",    NGX_HTTP_UNLOCK },
  3415.         { 5, "PATCH",     NGX_HTTP_PATCH },
  3416.         { 5, "TRACE",     NGX_HTTP_TRACE },
  3417.         { 7, "CONNECT",   NGX_HTTP_CONNECT }
  3418.     }, *test;

  3420.     if (r->method_name.len) {
  3421.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3422.                       "client sent duplicate :method header");

  3424.         return NGX_DECLINED;
  3425.     }

  3427.     if (value->len == 0) {
  3428.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3429.                       "client sent empty :method header");

  3431.         return NGX_DECLINED;
  3432.     }

  3434.     r->method_name.len = value->len;
  3435.     r->method_name.data = value->data;

  3437.     len = r->method_name.len;
  3438.     n = sizeof(tests) / sizeof(tests[0]);
  3439.     test = tests;

  3441.     do {
  3442.         if (len == test->len) {
  3443.             p = r->method_name.data;
  3444.             m = test->method;
  3445.             k = len;

  3447.             do {
  3448.                 if (*p++ != *m++) {
  3449.                     goto next;
  3450.                 }
  3451.             } while (--k);

  3453.             r->method = test->value;
  3454.             return NGX_OK;
  3455.         }

  3457.     next:
  3458.         test++;

  3460.     } while (--n);

  3462.     p = r->method_name.data;

  3464.     do {
  3465.         if ((*p < 'A' || *p > 'Z') && *p != '_' && *p != '-') {
  3466.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3467.                           "client sent invalid method: \"%V\"",
  3468.                           &r->method_name);

  3470.             return NGX_DECLINED;
  3471.         }

  3473.         p++;

  3475.     } while (--len);

  3477.     return NGX_OK;
  3478. }


  3481. static ngx_int_t
  3482. ‌ngx_http_v2_parse_scheme(ngx_http_request_t *r, ngx_str_t *value)
  3483. {
  3484.     u_char      c, ch;
  3485.     ngx_uint_t  i;

  3487.     if (r->schema.len) {
  3488.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3489.                       "client sent duplicate :scheme header");

  3491.         return NGX_DECLINED;
  3492.     }

  3494.     if (value->len == 0) {
  3495.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3496.                       "client sent empty :scheme header");

  3498.         return NGX_DECLINED;
  3499.     }

  3501.     for (i = 0; i < value->len; i++) {
  3502.         ch = value->data[i];

  3504.         c = (u_char) (ch | 0x20);
  3505.         if (c >= 'a' && c <= 'z') {
  3506.             continue;
  3507.         }

  3509.         if (((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')
  3510.             && i > 0)
  3511.         {
  3512.             continue;
  3513.         }

  3515.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3516.                       "client sent invalid :scheme header: \"%V\"", value);

  3518.         return NGX_DECLINED;
  3519.     }

  3521.     r->schema = *value;

  3523.     return NGX_OK;
  3524. }


  3527. static ngx_int_t
  3528. ‌ngx_http_v2_parse_authority(ngx_http_request_t *r, ngx_str_t *value)
  3529. {
  3530.     ngx_int_t  rc;
  3531.     in_port_t  port;

  3533.     if (r->host_start) {
  3534.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3535.                       "client sent duplicate \":authority\" header");
  3536.         return NGX_DECLINED;
  3537.     }

  3539.     r->host_start = value->data;
  3540.     r->host_end = value->data + value->len;

  3542.     rc = ngx_http_validate_host(value, &port, r->pool, 0);

  3544.     if (rc == NGX_DECLINED) {
  3545.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3546.                       "client sent invalid \":authority\" header");
  3547.         return NGX_DECLINED;
  3548.     }

  3550.     if (rc == NGX_ERROR) {
  3551.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3552.         return NGX_ABORT;
  3553.     }

  3555.     if (ngx_http_set_virtual_server(r, value) == NGX_ERROR) {
  3556.         /*
  3557.          * request has been finalized already
  3558.          * in ngx_http_set_virtual_server()
  3559.          */
  3560.         return NGX_ABORT;
  3561.     }

  3563.     r->headers_in.server = *value;
  3564.     r->port = port;

  3566.     return NGX_OK;
  3567. }


  3570. static ngx_int_t
  3571. ‌ngx_http_v2_construct_request_line(ngx_http_request_t *r)
  3572. {
  3573.     u_char  *p;

  3575.     static const u_char ending[] = " HTTP/2.0";

  3577.     if (r->method_name.len == 0
  3578.         || r->schema.len == 0
  3579.         || r->unparsed_uri.len == 0)
  3580.     {
  3581.         if (r->method_name.len == 0) {
  3582.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3583.                           "client sent no :method header");

  3585.         } else if (r->schema.len == 0) {
  3586.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3587.                           "client sent no :scheme header");

  3589.         } else {
  3590.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3591.                           "client sent no :path header");
  3592.         }

  3594.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3595.         return NGX_ERROR;
  3596.     }

  3598.     r->request_line.len = r->method_name.len + 1
  3599.                           + r->unparsed_uri.len
  3600.                           + sizeof(ending) - 1;

  3602.     p = ngx_pnalloc(r->pool, r->request_line.len + 1);
  3603.     if (p == NULL) {
  3604.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3605.         return NGX_ERROR;
  3606.     }

  3608.     r->request_line.data = p;

  3610.     p = ngx_cpymem(p, r->method_name.data, r->method_name.len);

  3612.     *p++ = ' ';

  3614.     p = ngx_cpymem(p, r->unparsed_uri.data, r->unparsed_uri.len);

  3616.     ngx_memcpy(p, ending, sizeof(ending));

  3618.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3619.                    "http2 request line: \"%V\"", &r->request_line);

  3621.     return NGX_OK;
  3622. }


  3625. static ngx_int_t
  3626. ‌ngx_http_v2_cookie(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3627. {
  3628.     ngx_str_t    *val;
  3629.     ngx_array_t  *cookies;

  3631.     cookies = r->stream->cookies;

  3633.     if (cookies == NULL) {
  3634.         cookies = ngx_array_create(r->pool, 2, sizeof(ngx_str_t));
  3635.         if (cookies == NULL) {
  3636.             return NGX_ERROR;
  3637.         }

  3639.         r->stream->cookies = cookies;
  3640.     }

  3642.     val = ngx_array_push(cookies);
  3643.     if (val == NULL) {
  3644.         return NGX_ERROR;
  3645.     }

  3647.     val->len = header->value.len;
  3648.     val->data = header->value.data;

  3650.     return NGX_OK;
  3651. }


  3654. static ngx_int_t
  3655. ‌ngx_http_v2_construct_cookie_header(ngx_http_request_t *r)
  3656. {
  3657.     u_char                     *buf, *p, *end;
  3658.     size_t                      len;
  3659.     ngx_str_t                  *vals;
  3660.     ngx_uint_t                  i;
  3661.     ngx_array_t                *cookies;
  3662.     ngx_table_elt_t            *h;
  3663.     ngx_http_header_t          *hh;
  3664.     ngx_http_core_main_conf_t  *cmcf;

  3666.     static ngx_str_t cookie = ngx_string("cookie");

  3668.     cookies = r->stream->cookies;

  3670.     if (cookies == NULL) {
  3671.         return NGX_OK;
  3672.     }

  3674.     vals = cookies->elts;

  3676.     i = 0;
  3677.     len = 0;

  3679.     do {
  3680.         len += vals[i].len + 2;
  3681.     } while (++i != cookies->nelts);

  3683.     len -= 2;

  3685.     buf = ngx_pnalloc(r->pool, len + 1);
  3686.     if (buf == NULL) {
  3687.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3688.         return NGX_ERROR;
  3689.     }

  3691.     p = buf;
  3692.     end = buf + len;

  3694.     for (i = 0; /* void */ ; i++) {

  3696.         p = ngx_cpymem(p, vals[i].data, vals[i].len);

  3698.         if (p == end) {
  3699.             *p = '\0';
  3700.             break;
  3701.         }

  3703.         *p++ = ';'; *p++ = ' ';
  3704.     }

  3706.     h = ngx_list_push(&r->headers_in.headers);
  3707.     if (h == NULL) {
  3708.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3709.         return NGX_ERROR;
  3710.     }

  3712.     h->hash = ngx_hash(ngx_hash(ngx_hash(ngx_hash(
  3713.                                     ngx_hash('c', 'o'), 'o'), 'k'), 'i'), 'e');

  3715.     h->key.len = cookie.len;
  3716.     h->key.data = cookie.data;

  3718.     h->value.len = len;
  3719.     h->value.data = buf;

  3721.     h->lowcase_key = cookie.data;

  3723.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  3728.     if (hh == NULL) {
  3729.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3730.         return NGX_ERROR;
  3731.     }

  3733.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  3734.         /*
  3735.          * request has been finalized already
  3736.          * in ngx_http_process_header_line()
  3737.          */
  3738.         return NGX_ERROR;
  3739.     }

  3741.     return NGX_OK;
  3742. }


  3745. static ngx_int_t
  3746. ‌ngx_http_v2_construct_host_header(ngx_http_request_t *r)
  3747. {
  3748.     ngx_table_elt_t            *h;
  3749.     ngx_http_header_t          *hh;
  3750.     ngx_http_core_main_conf_t  *cmcf;

  3752.     static ngx_str_t host = ngx_string("host");

  3754.     h = ngx_list_push(&r->headers_in.headers);
  3755.     if (h == NULL) {
  3756.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3757.         return NGX_ERROR;
  3758.     }

  3760.     h->hash = ngx_hash(ngx_hash(ngx_hash('h', 'o'), 's'), 't');

  3762.     h->key.len = host.len;
  3763.     h->key.data = host.data;

  3765.     h->value.len = r->host_end - r->host_start;
  3766.     h->value.data = r->host_start;

  3768.     h->lowcase_key = host.data;

  3770.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  3775.     if (hh == NULL) {
  3776.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3777.         return NGX_ERROR;
  3778.     }

  3780.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  3781.         /*
  3782.          * request has been finalized already
  3783.          * in ngx_http_process_host()
  3784.          */
  3785.         return NGX_ERROR;
  3786.     }

  3788.     return NGX_OK;
  3789. }


  3792. static void
  3793. ‌ngx_http_v2_run_request(ngx_http_request_t *r)
  3794. {
  3795.     ngx_str_t                  host;
  3796.     ngx_connection_t          *fc;
  3797.     ngx_http_v2_srv_conf_t    *h2scf;
  3798.     ngx_http_v2_connection_t  *h2c;

  3800.     fc = r->connection;

  3802.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

  3804.     if (!h2scf->enable && !r->http_connection->addr_conf->http2) {
  3805.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3806.                       "client attempted to request the server name "
  3807.                       "for which the negotiated protocol is disabled");

  3809.         ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  3810.         goto failed;
  3811.     }

  3813.     if (ngx_http_v2_construct_request_line(r) != NGX_OK) {
  3814.         goto failed;
  3815.     }

  3817.     if (ngx_http_v2_construct_cookie_header(r) != NGX_OK) {
  3818.         goto failed;
  3819.     }

  3821.     r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  3823.     if (r->headers_in.connection) {
  3824.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3825.                       "client sent \"Connection\" header");
  3826.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3827.         goto failed;
  3828.     }

  3830.     if (r->headers_in.keep_alive) {
  3831.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3832.                       "client sent \"Keep-Alive\" header");
  3833.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3834.         goto failed;
  3835.     }

  3837.     if (r->headers_in.transfer_encoding) {
  3838.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3839.                       "client sent \"Transfer-Encoding\" header");
  3840.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3841.         goto failed;
  3842.     }

  3844.     if (r->headers_in.upgrade) {
  3845.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3846.                       "client sent \"Upgrade\" header");
  3847.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3848.         goto failed;
  3849.     }

  3851.     if (r->headers_in.te
  3852.         && (r->headers_in.te->next
  3853.             || r->headers_in.te->value.len != 8
  3854.             || ngx_strncasecmp(r->headers_in.te->value.data,
  3855.                                (u_char *) "trailers", 8) != 0))
  3856.     {
  3857.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3858.                       "client sent invalid \"TE\" header");
  3859.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3860.         goto failed;
  3861.     }

  3863.     if (r->headers_in.server.len == 0) {
  3864.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3865.                       "client sent neither \":authority\" nor \"Host\" header");
  3866.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3867.         goto failed;
  3868.     }

  3870.     if (r->host_end) {

  3872.         host.len = r->host_end - r->host_start;
  3873.         host.data = r->host_start;

  3875.         if (r->headers_in.host) {
  3876.             if (r->headers_in.host->value.len != host.len
  3877.                 || ngx_memcmp(r->headers_in.host->value.data, host.data,
  3878.                               host.len)
  3879.                    != 0)
  3880.             {
  3881.                 ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3882.                               "client sent \":authority\" and \"Host\" headers "
  3883.                               "with different values");
  3884.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3885.                 goto failed;
  3886.             }

  3888.         } else {
  3889.             /* compatibility for $http_host */

  3891.             if (ngx_http_v2_construct_host_header(r) != NGX_OK) {
  3892.                 goto failed;
  3893.             }
  3894.         }
  3895.     }

  3897.     if (r->headers_in.content_length) {
  3898.         r->headers_in.content_length_n =
  3899.                             ngx_atoof(r->headers_in.content_length->value.data,
  3900.                                       r->headers_in.content_length->value.len);

  3902.         if (r->headers_in.content_length_n == NGX_ERROR) {
  3903.             ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3904.                           "client sent invalid \"Content-Length\" header");
  3905.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3906.             goto failed;
  3907.         }

  3909.         if (r->headers_in.content_length_n > 0 && r->stream->in_closed) {
  3910.             ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3911.                           "client prematurely closed stream");

  3913.             r->stream->skip_data = 1;

  3915.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3916.             goto failed;
  3917.         }

  3919.     } else if (!r->stream->in_closed) {
  3920.         r->headers_in.chunked = 1;
  3921.     }

  3923.     if (r->method == NGX_HTTP_CONNECT) {
  3924.         ngx_log_error(NGX_LOG_INFO, fc->log, 0, "client sent CONNECT method");
  3925.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  3926.         goto failed;
  3927.     }

  3929.     if (r->method == NGX_HTTP_TRACE) {
  3930.         ngx_log_error(NGX_LOG_INFO, fc->log, 0, "client sent TRACE method");
  3931.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  3932.         goto failed;
  3933.     }

  3935.     h2c = r->stream->connection;

  3937.     h2c->payload_bytes += r->request_length;

  3939.     ngx_http_process_request(r);

  3941. failed:

  3943.     ngx_http_run_posted_requests(fc);
  3944. }


  3947. ngx_int_t
  3948. ‌ngx_http_v2_read_request_body(ngx_http_request_t *r)
  3949. {
  3950.     off_t                      len;
  3951.     size_t                     size;
  3952.     ngx_buf_t                 *buf;
  3953.     ngx_int_t                  rc;
  3954.     ngx_http_v2_stream_t      *stream;
  3955.     ngx_http_v2_srv_conf_t    *h2scf;
  3956.     ngx_http_request_body_t   *rb;
  3957.     ngx_http_core_loc_conf_t  *clcf;
  3958.     ngx_http_v2_connection_t  *h2c;

  3960.     stream = r->stream;
  3961.     rb = r->request_body;

  3963.     if (stream->skip_data) {
  3964.         r->request_body_no_buffering = 0;
  3965.         rb->post_handler(r);
  3966.         return NGX_OK;
  3967.     }

  3969.     rb->rest = 1;

  3971.     /* set rb->filter_need_buffering */

  3973.     rc = ngx_http_top_request_body_filter(r, NULL);

  3975.     if (rc != NGX_OK) {
  3976.         stream->skip_data = 1;
  3977.         return rc;
  3978.     }

  3980.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);
  3981.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3983.     len = r->headers_in.content_length_n;

  3985.     if (len < 0 || len > (off_t) clcf->client_body_buffer_size) {
  3986.         len = clcf->client_body_buffer_size;

  3988.     } else {
  3989.         len++;
  3990.     }

  3992.     if (r->request_body_no_buffering || rb->filter_need_buffering) {

  3994.         /*
  3995.          * We need a room to store data up to the stream's initial window size,
  3996.          * at least until this window will be exhausted.
  3997.          */

  3999.         if (len < (off_t) h2scf->preread_size) {
  4000.             len = h2scf->preread_size;
  4001.         }

  4003.         if (len > NGX_HTTP_V2_MAX_WINDOW) {
  4004.             len = NGX_HTTP_V2_MAX_WINDOW;
  4005.         }
  4006.     }

  4008.     rb->buf = ngx_create_temp_buf(r->pool, (size_t) len);

  4010.     if (rb->buf == NULL) {
  4011.         stream->skip_data = 1;
  4012.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4013.     }

  4015.     buf = stream->preread;

  4017.     if (stream->in_closed) {
  4018.         if (!rb->filter_need_buffering) {
  4019.             r->request_body_no_buffering = 0;
  4020.         }

  4022.         if (buf) {
  4023.             rc = ngx_http_v2_process_request_body(r, buf->pos,
  4024.                                                   buf->last - buf->pos, 1, 0);
  4025.             ngx_pfree(r->pool, buf->start);

  4027.         } else {
  4028.             rc = ngx_http_v2_process_request_body(r, NULL, 0, 1, 0);
  4029.         }

  4031.         if (rc != NGX_AGAIN) {
  4032.             return rc;
  4033.         }

  4035.         r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
  4036.         r->write_event_handler = ngx_http_request_empty_handler;

  4038.         return NGX_AGAIN;
  4039.     }

  4041.     if (buf) {
  4042.         rc = ngx_http_v2_process_request_body(r, buf->pos,
  4043.                                               buf->last - buf->pos, 0, 0);

  4045.         ngx_pfree(r->pool, buf->start);

  4047.         if (rc != NGX_OK && rc != NGX_AGAIN) {
  4048.             stream->skip_data = 1;
  4049.             return rc;
  4050.         }
  4051.     }

  4053.     if (r->request_body_no_buffering || rb->filter_need_buffering) {
  4054.         size = (size_t) len - h2scf->preread_size;

  4056.     } else {
  4057.         stream->no_flow_control = 1;
  4058.         size = NGX_HTTP_V2_MAX_WINDOW - stream->recv_window;
  4059.     }

  4061.     if (size) {
  4062.         if (ngx_http_v2_send_window_update(stream->connection,
  4063.                                            stream->node->id, size)
  4064.             == NGX_ERROR)
  4065.         {
  4066.             stream->skip_data = 1;
  4067.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4068.         }

  4070.         h2c = stream->connection;

  4072.         if (!h2c->blocked) {
  4073.             if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4074.                 stream->skip_data = 1;
  4075.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4076.             }
  4077.         }

  4079.         stream->recv_window += size;
  4080.     }

  4082.     if (!buf) {
  4083.         ngx_add_timer(r->connection->read, clcf->client_body_timeout);
  4084.     }

  4086.     r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
  4087.     r->write_event_handler = ngx_http_request_empty_handler;

  4089.     return NGX_AGAIN;
  4090. }


  4093. static ngx_int_t
  4094. ‌ngx_http_v2_process_request_body(ngx_http_request_t *r, u_char *pos,
  4095.     size_t size, ngx_uint_t last, ngx_uint_t flush)
  4096. {
  4097.     size_t                     n;
  4098.     ngx_int_t                  rc;
  4099.     ngx_connection_t          *fc;
  4100.     ngx_http_request_body_t   *rb;
  4101.     ngx_http_core_loc_conf_t  *clcf;

  4103.     fc = r->connection;
  4104.     rb = r->request_body;

  4106.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4107.                    "http2 process request body");

  4109.     if (size == 0 && !last && !flush) {
  4110.         return NGX_AGAIN;
  4111.     }

  4113.     for ( ;; ) {
  4114.         for ( ;; ) {
  4115.             if (rb->buf->last == rb->buf->end && size) {

  4117.                 if (r->request_body_no_buffering) {

  4119.                     /* should never happen due to flow control */

  4121.                     ngx_log_error(NGX_LOG_ALERT, fc->log, 0,
  4122.                                   "no space in http2 body buffer");

  4124.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4125.                 }

  4127.                 /* update chains */

  4129.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4130.                                "http2 body update chains");

  4132.                 rc = ngx_http_v2_filter_request_body(r);

  4134.                 if (rc != NGX_OK) {
  4135.                     return rc;
  4136.                 }

  4138.                 if (rb->busy != NULL) {
  4139.                     ngx_log_error(NGX_LOG_ALERT, fc->log, 0,
  4140.                                   "busy buffers after request body flush");
  4141.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4142.                 }

  4144.                 rb->buf->pos = rb->buf->start;
  4145.                 rb->buf->last = rb->buf->start;
  4146.             }

  4148.             /* copy body data to the buffer */

  4150.             n = rb->buf->end - rb->buf->last;

  4152.             if (n > size) {
  4153.                 n = size;
  4154.             }

  4156.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4157.                            "http2 request body recv %uz", n);

  4159.             if (n > 0) {
  4160.                 rb->buf->last = ngx_cpymem(rb->buf->last, pos, n);
  4161.                 pos += n;
  4162.                 size -= n;
  4163.             }

  4165.             if (size == 0 && last) {
  4166.                 rb->rest = 0;
  4167.             }

  4169.             if (size == 0) {
  4170.                 break;
  4171.             }
  4172.         }

  4174.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4175.                        "http2 request body rest %O", rb->rest);

  4177.         if (flush) {
  4178.             rc = ngx_http_v2_filter_request_body(r);

  4180.             if (rc != NGX_OK) {
  4181.                 return rc;
  4182.             }
  4183.         }

  4185.         if (rb->rest == 0 && rb->last_saved) {
  4186.             break;
  4187.         }

  4189.         if (size == 0) {
  4190.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  4191.             ngx_add_timer(fc->read, clcf->client_body_timeout);

  4193.             if (!flush) {
  4194.                 ngx_post_event(fc->read, &ngx_posted_events);
  4195.             }

  4197.             return NGX_AGAIN;
  4198.         }
  4199.     }

  4201.     if (fc->read->timer_set) {
  4202.         ngx_del_timer(fc->read);
  4203.     }

  4205.     if (r->request_body_no_buffering) {
  4206.         if (!flush) {
  4207.             ngx_post_event(fc->read, &ngx_posted_events);
  4208.         }

  4210.         return NGX_OK;
  4211.     }

  4213.     if (r->headers_in.chunked) {
  4214.         r->headers_in.content_length_n = rb->received;
  4215.     }

  4217.     r->read_event_handler = ngx_http_block_reading;
  4218.     rb->post_handler(r);

  4220.     return NGX_OK;
  4221. }


  4224. static ngx_int_t
  4225. ‌ngx_http_v2_filter_request_body(ngx_http_request_t *r)
  4226. {
  4227.     ngx_buf_t                 *b, *buf;
  4228.     ngx_int_t                  rc;
  4229.     ngx_chain_t               *cl;
  4230.     ngx_http_request_body_t   *rb;
  4231.     ngx_http_core_loc_conf_t  *clcf;

  4233.     rb = r->request_body;
  4234.     buf = rb->buf;

  4236.     if (buf->pos == buf->last && (rb->rest || rb->last_sent)) {
  4237.         cl = NULL;
  4238.         goto update;
  4239.     }

  4241.     cl = ngx_chain_get_free_buf(r->pool, &rb->free);
  4242.     if (cl == NULL) {
  4243.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4244.     }

  4246.     b = cl->buf;

  4248.     ngx_memzero(b, sizeof(ngx_buf_t));

  4250.     if (buf->pos != buf->last) {
  4251.         r->request_length += buf->last - buf->pos;
  4252.         rb->received += buf->last - buf->pos;

  4254.         if (r->headers_in.content_length_n != -1) {
  4255.             if (rb->received > r->headers_in.content_length_n) {
  4256.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  4257.                               "client intended to send body data "
  4258.                               "larger than declared");

  4260.                 return NGX_HTTP_BAD_REQUEST;
  4261.             }

  4263.         } else {
  4264.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4266.             if (clcf->client_max_body_size
  4267.                 && rb->received > clcf->client_max_body_size)
  4268.             {
  4269.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4270.                               "client intended to send too large chunked body: "
  4271.                               "%O bytes", rb->received);

  4273.                 return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  4274.             }
  4275.         }

  4277.         b->temporary = 1;
  4278.         b->pos = buf->pos;
  4279.         b->last = buf->last;
  4280.         b->start = b->pos;
  4281.         b->end = b->last;

  4283.         buf->pos = buf->last;
  4284.     }

  4286.     if (!rb->rest) {
  4287.         if (r->headers_in.content_length_n != -1
  4288.             && r->headers_in.content_length_n != rb->received)
  4289.         {
  4290.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  4291.                           "client prematurely closed stream: "
  4292.                           "only %O out of %O bytes of request body received",
  4293.                           rb->received, r->headers_in.content_length_n);

  4295.             return NGX_HTTP_BAD_REQUEST;
  4296.         }

  4298.         b->last_buf = 1;
  4299.         rb->last_sent = 1;
  4300.     }

  4302.     b->tag = (ngx_buf_tag_t) &ngx_http_v2_filter_request_body;
  4303.     b->flush = r->request_body_no_buffering;

  4305. update:

  4307.     rc = ngx_http_top_request_body_filter(r, cl);

  4309.     ngx_chain_update_chains(r->pool, &rb->free, &rb->busy, &cl,
  4310.                             (ngx_buf_tag_t) &ngx_http_v2_filter_request_body);

  4312.     return rc;
  4313. }


  4316. static void
  4317. ‌ngx_http_v2_read_client_request_body_handler(ngx_http_request_t *r)
  4318. {
  4319.     size_t                     window;
  4320.     ngx_buf_t                 *buf;
  4321.     ngx_int_t                  rc;
  4322.     ngx_connection_t          *fc;
  4323.     ngx_http_v2_stream_t      *stream;
  4324.     ngx_http_v2_connection_t  *h2c;

  4326.     fc = r->connection;

  4328.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4329.                    "http2 read client request body handler");

  4331.     if (fc->read->timedout) {
  4332.         ngx_log_error(NGX_LOG_INFO, fc->log, NGX_ETIMEDOUT, "client timed out");

  4334.         fc->timedout = 1;
  4335.         r->stream->skip_data = 1;

  4337.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  4338.         return;
  4339.     }

  4341.     if (fc->error) {
  4342.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4343.                       "client prematurely closed stream");

  4345.         r->stream->skip_data = 1;

  4347.         ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  4348.         return;
  4349.     }

  4351.     rc = ngx_http_v2_process_request_body(r, NULL, 0, r->stream->in_closed, 1);

  4353.     if (rc != NGX_OK && rc != NGX_AGAIN) {
  4354.         r->stream->skip_data = 1;
  4355.         ngx_http_finalize_request(r, rc);
  4356.         return;
  4357.     }

  4359.     if (rc == NGX_OK) {
  4360.         return;
  4361.     }

  4363.     if (r->stream->no_flow_control) {
  4364.         return;
  4365.     }

  4367.     if (r->request_body->rest == 0) {
  4368.         return;
  4369.     }

  4371.     if (r->request_body->busy != NULL) {
  4372.         return;
  4373.     }

  4375.     stream = r->stream;
  4376.     h2c = stream->connection;

  4378.     buf = r->request_body->buf;

  4380.     buf->pos = buf->start;
  4381.     buf->last = buf->start;

  4383.     window = buf->end - buf->start;

  4385.     if (h2c->state.stream == stream) {
  4386.         window -= h2c->state.length;
  4387.     }

  4389.     if (window <= stream->recv_window) {
  4390.         if (window < stream->recv_window) {
  4391.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  4392.                           "http2 negative window update");

  4394.             stream->skip_data = 1;

  4396.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4397.             return;
  4398.         }

  4400.         return;
  4401.     }

  4403.     if (ngx_http_v2_send_window_update(h2c, stream->node->id,
  4404.                                        window - stream->recv_window)
  4405.         == NGX_ERROR)
  4406.     {
  4407.         stream->skip_data = 1;
  4408.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4409.         return;
  4410.     }

  4412.     stream->recv_window = window;

  4414.     if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4415.         stream->skip_data = 1;
  4416.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4417.         return;
  4418.     }
  4419. }


  4422. ngx_int_t
  4423. ‌ngx_http_v2_read_unbuffered_request_body(ngx_http_request_t *r)
  4424. {
  4425.     size_t                     window;
  4426.     ngx_buf_t                 *buf;
  4427.     ngx_int_t                  rc;
  4428.     ngx_connection_t          *fc;
  4429.     ngx_http_v2_stream_t      *stream;
  4430.     ngx_http_v2_connection_t  *h2c;

  4432.     stream = r->stream;
  4433.     fc = r->connection;

  4435.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4436.                    "http2 read unbuffered request body");

  4438.     if (fc->read->timedout) {
  4439.         if (stream->recv_window) {
  4440.             stream->skip_data = 1;
  4441.             fc->timedout = 1;

  4443.             return NGX_HTTP_REQUEST_TIME_OUT;
  4444.         }

  4446.         fc->read->timedout = 0;
  4447.     }

  4449.     if (fc->error) {
  4450.         stream->skip_data = 1;
  4451.         return NGX_HTTP_BAD_REQUEST;
  4452.     }

  4454.     rc = ngx_http_v2_process_request_body(r, NULL, 0, r->stream->in_closed, 1);

  4456.     if (rc != NGX_OK && rc != NGX_AGAIN) {
  4457.         stream->skip_data = 1;
  4458.         return rc;
  4459.     }

  4461.     if (rc == NGX_OK) {
  4462.         return NGX_OK;
  4463.     }

  4465.     if (r->request_body->rest == 0) {
  4466.         return NGX_AGAIN;
  4467.     }

  4469.     if (r->request_body->busy != NULL) {
  4470.         return NGX_AGAIN;
  4471.     }

  4473.     buf = r->request_body->buf;

  4475.     buf->pos = buf->start;
  4476.     buf->last = buf->start;

  4478.     window = buf->end - buf->start;
  4479.     h2c = stream->connection;

  4481.     if (h2c->state.stream == stream) {
  4482.         window -= h2c->state.length;
  4483.     }

  4485.     if (window <= stream->recv_window) {
  4486.         if (window < stream->recv_window) {
  4487.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  4488.                           "http2 negative window update");
  4489.             stream->skip_data = 1;
  4490.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4491.         }

  4493.         return NGX_AGAIN;
  4494.     }

  4496.     if (ngx_http_v2_send_window_update(h2c, stream->node->id,
  4497.                                        window - stream->recv_window)
  4498.         == NGX_ERROR)
  4499.     {
  4500.         stream->skip_data = 1;
  4501.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4502.     }

  4504.     if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4505.         stream->skip_data = 1;
  4506.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4507.     }

  4509.     stream->recv_window = window;

  4511.     return NGX_AGAIN;
  4512. }


  4515. static ngx_int_t
  4516. ‌ngx_http_v2_terminate_stream(ngx_http_v2_connection_t *h2c,
  4517.     ngx_http_v2_stream_t *stream, ngx_uint_t status)
  4518. {
  4519.     ngx_event_t       *rev;
  4520.     ngx_connection_t  *fc;

  4522.     if (stream->rst_sent) {
  4523.         return NGX_OK;
  4524.     }

  4526.     if (ngx_http_v2_send_rst_stream(h2c, stream->node->id, status)
  4527.         == NGX_ERROR)
  4528.     {
  4529.         return NGX_ERROR;
  4530.     }

  4532.     stream->rst_sent = 1;
  4533.     stream->skip_data = 1;

  4535.     fc = stream->request->connection;
  4536.     fc->error = 1;

  4538.     rev = fc->read;
  4539.     rev->handler(rev);

  4541.     return NGX_OK;
  4542. }


  4545. void
  4546. ‌ngx_http_v2_close_stream(ngx_http_v2_stream_t *stream, ngx_int_t rc)
  4547. {
  4548.     ngx_pool_t                *pool;
  4549.     ngx_event_t               *ev;
  4550.     ngx_connection_t          *fc;
  4551.     ngx_http_v2_node_t        *node;
  4552.     ngx_http_v2_connection_t  *h2c;

  4554.     h2c = stream->connection;
  4555.     node = stream->node;

  4557.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  4558.                    "http2 close stream %ui, queued %ui, processing %ui",
  4559.                    node->id, stream->queued, h2c->processing);

  4561.     fc = stream->request->connection;

  4563.     if (stream->queued) {
  4564.         fc->error = 1;
  4565.         fc->write->handler = ngx_http_v2_retry_close_stream_handler;
  4566.         fc->read->handler = ngx_http_v2_retry_close_stream_handler;
  4567.         return;
  4568.     }

  4570.     if (!stream->rst_sent && !h2c->connection->error) {

  4572.         if (!stream->out_closed) {
  4573.             if (ngx_http_v2_send_rst_stream(h2c, node->id,
  4574.                                       fc->timedout ? NGX_HTTP_V2_PROTOCOL_ERROR
  4575.                                                    : NGX_HTTP_V2_INTERNAL_ERROR)
  4576.                 != NGX_OK)
  4577.             {
  4578.                 h2c->connection->error = 1;
  4579.             }

  4581.         } else if (!stream->in_closed) {
  4582.             if (ngx_http_v2_send_rst_stream(h2c, node->id, NGX_HTTP_V2_NO_ERROR)
  4583.                 != NGX_OK)
  4584.             {
  4585.                 h2c->connection->error = 1;
  4586.             }
  4587.         }
  4588.     }

  4590.     if (h2c->state.stream == stream) {
  4591.         h2c->state.stream = NULL;
  4592.     }

  4594.     node->stream = NULL;

  4596.     ngx_queue_insert_tail(&h2c->closed, &node->reuse);
  4597.     h2c->closed_nodes++;

  4599.     /*
  4600.      * This pool keeps decoded request headers which can be used by log phase
  4601.      * handlers in ngx_http_free_request().
  4602.      *
  4603.      * The pointer is stored into local variable because the stream object
  4604.      * will be destroyed after a call to ngx_http_free_request().
  4605.      */
  4606.     pool = stream->pool;

  4608.     h2c->frames -= stream->frames;

  4610.     ngx_http_free_request(stream->request, rc);

  4612.     if (pool != h2c->state.pool) {
  4613.         ngx_destroy_pool(pool);

  4615.     } else {
  4616.         /* pool will be destroyed when the complete header is parsed */
  4617.         h2c->state.keep_pool = 0;
  4618.     }

  4620.     ev = fc->read;

  4622.     if (ev->timer_set) {
  4623.         ngx_del_timer(ev);
  4624.     }

  4626.     if (ev->posted) {
  4627.         ngx_delete_posted_event(ev);
  4628.     }

  4630.     ev = fc->write;

  4632.     if (ev->timer_set) {
  4633.         ngx_del_timer(ev);
  4634.     }

  4636.     if (ev->posted) {
  4637.         ngx_delete_posted_event(ev);
  4638.     }

  4640.     fc->data = h2c->free_fake_connections;
  4641.     h2c->free_fake_connections = fc;

  4643.     h2c->processing--;

  4645.     if (h2c->processing || h2c->blocked) {
  4646.         return;
  4647.     }

  4649.     ev = h2c->connection->read;

  4651.     ev->handler = ngx_http_v2_handle_connection_handler;
  4652.     ngx_post_event(ev, &ngx_posted_events);
  4653. }


  4656. static void
  4657. ‌ngx_http_v2_close_stream_handler(ngx_event_t *ev)
  4658. {
  4659.     ngx_connection_t    *fc;
  4660.     ngx_http_request_t  *r;

  4662.     fc = ev->data;
  4663.     r = fc->data;

  4665.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4666.                    "http2 close stream handler");

  4668.     if (ev->timedout) {
  4669.         ngx_log_error(NGX_LOG_INFO, fc->log, NGX_ETIMEDOUT, "client timed out");

  4671.         fc->timedout = 1;

  4673.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_REQUEST_TIME_OUT);
  4674.         return;
  4675.     }

  4677.     ngx_http_v2_close_stream(r->stream, 0);
  4678. }


  4681. static void
  4682. ‌ngx_http_v2_retry_close_stream_handler(ngx_event_t *ev)
  4683. {
  4684.     ngx_connection_t    *fc;
  4685.     ngx_http_request_t  *r;

  4687.     fc = ev->data;
  4688.     r = fc->data;

  4690.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4691.                    "http2 retry close stream handler");

  4693.     ngx_http_v2_close_stream(r->stream, 0);
  4694. }


  4697. static void
  4698. ‌ngx_http_v2_handle_connection_handler(ngx_event_t *rev)
  4699. {
  4700.     ngx_connection_t          *c;
  4701.     ngx_http_v2_connection_t  *h2c;

  4703.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0,
  4704.                    "http2 handle connection handler");

  4706.     c = rev->data;
  4707.     h2c = c->data;

  4709.     if (c->error) {
  4710.         ngx_http_v2_finalize_connection(h2c, 0);
  4711.         return;
  4712.     }

  4714.     rev->handler = ngx_http_v2_read_handler;

  4716.     if (rev->ready) {
  4717.         ngx_http_v2_read_handler(rev);
  4718.         return;
  4719.     }

  4721.     if (h2c->last_out && ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4722.         ngx_http_v2_finalize_connection(h2c, 0);
  4723.         return;
  4724.     }

  4726.     ngx_http_v2_handle_connection(c->data);
  4727. }


  4730. static void
  4731. ‌ngx_http_v2_idle_handler(ngx_event_t *rev)
  4732. {
  4733.     ngx_connection_t          *c;
  4734.     ngx_http_v2_srv_conf_t    *h2scf;
  4735.     ngx_http_v2_connection_t  *h2c;
  4736.     ngx_http_core_loc_conf_t  *clcf;

  4738.     c = rev->data;
  4739.     h2c = c->data;

  4741.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http2 idle handler");

  4743.     if (rev->timedout || c->close) {
  4744.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  4745.         return;
  4746.     }

  4748. #if (NGX_HAVE_KQUEUE)

  4750.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  4751.         if (rev->pending_eof) {
  4752.             c->log->handler = NULL;
  4753.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  4754.                           "kevent() reported that client %V closed "
  4755.                           "idle connection", &c->addr_text);
  4756. #if (NGX_HTTP_SSL)
  4757.             if (c->ssl) {
  4758.                 c->ssl->no_send_shutdown = 1;
  4759.             }
  4760. #endif
  4761.             ngx_http_close_connection(c);
  4762.             return;
  4763.         }
  4764.     }

  4766. #endif

  4768.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  4769.                                         ngx_http_core_module);

  4771.     if (h2c->idle++ > 10 * clcf->keepalive_requests) {
  4772.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  4773.                       "http2 flood detected");
  4774.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  4775.         return;
  4776.     }

  4778.     c->destroyed = 0;
  4779.     ngx_reusable_connection(c, 0);

  4781.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4782.                                          ngx_http_v2_module);

  4784.     h2c->pool = ngx_create_pool(h2scf->pool_size, h2c->connection->log);
  4785.     if (h2c->pool == NULL) {
  4786.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  4787.         return;
  4788.     }

  4790.     c->write->handler = ngx_http_v2_write_handler;

  4792.     rev->handler = ngx_http_v2_read_handler;
  4793.     ngx_http_v2_read_handler(rev);
  4794. }


  4797. static void
  4798. ‌ngx_http_v2_finalize_connection(ngx_http_v2_connection_t *h2c,
  4799.     ngx_uint_t status)
  4800. {
  4801.     ngx_uint_t               i, size;
  4802.     ngx_event_t             *ev;
  4803.     ngx_connection_t        *c, *fc;
  4804.     ngx_http_request_t      *r;
  4805.     ngx_http_v2_node_t      *node;
  4806.     ngx_http_v2_stream_t    *stream;
  4807.     ngx_http_v2_srv_conf_t  *h2scf;

  4809.     c = h2c->connection;

  4811.     h2c->blocked = 1;

  4813.     if (!c->error && !h2c->goaway) {
  4814.         h2c->goaway = 1;

  4816.         if (ngx_http_v2_send_goaway(h2c, status) != NGX_ERROR) {
  4817.             (void) ngx_http_v2_send_output_queue(h2c);
  4818.         }
  4819.     }

  4821.     if (!h2c->processing) {
  4822.         goto done;
  4823.     }

  4825.     c->read->handler = ngx_http_empty_handler;
  4826.     c->write->handler = ngx_http_empty_handler;

  4828.     h2c->last_out = NULL;

  4830.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4831.                                          ngx_http_v2_module);

  4833.     size = ngx_http_v2_index_size(h2scf);

  4835.     for (i = 0; i < size; i++) {

  4837.         for (node = h2c->streams_index[i]; node; node = node->index) {
  4838.             stream = node->stream;

  4840.             if (stream == NULL) {
  4841.                 continue;
  4842.             }

  4844.             stream->waiting = 0;

  4846.             r = stream->request;
  4847.             fc = r->connection;

  4849.             fc->error = 1;

  4851.             if (stream->queued) {
  4852.                 stream->queued = 0;

  4854.                 ev = fc->write;
  4855.                 ev->active = 0;
  4856.                 ev->ready = 1;

  4858.             } else {
  4859.                 ev = fc->read;
  4860.             }

  4862.             ev->eof = 1;
  4863.             ev->handler(ev);
  4864.         }
  4865.     }

  4867.     h2c->blocked = 0;

  4869.     if (h2c->processing) {
  4870.         c->error = 1;
  4871.         return;
  4872.     }

  4874. done:

  4876.     if (c->error) {
  4877.         ngx_http_close_connection(c);
  4878.         return;
  4879.     }

  4881.     ngx_http_v2_lingering_close(c);
  4882. }


  4885. static ngx_int_t
  4886. ‌ngx_http_v2_adjust_windows(ngx_http_v2_connection_t *h2c, ssize_t delta)
  4887. {
  4888.     ngx_uint_t               i, size;
  4889.     ngx_event_t             *wev;
  4890.     ngx_http_v2_node_t      *node;
  4891.     ngx_http_v2_stream_t    *stream;
  4892.     ngx_http_v2_srv_conf_t  *h2scf;

  4894.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4895.                                          ngx_http_v2_module);

  4897.     size = ngx_http_v2_index_size(h2scf);

  4899.     for (i = 0; i < size; i++) {

  4901.         for (node = h2c->streams_index[i]; node; node = node->index) {
  4902.             stream = node->stream;

  4904.             if (stream == NULL) {
  4905.                 continue;
  4906.             }

  4908.             if (delta > 0
  4909.                 && stream->send_window
  4910.                       > (ssize_t) (NGX_HTTP_V2_MAX_WINDOW - delta))
  4911.             {
  4912.                 if (ngx_http_v2_terminate_stream(h2c, stream,
  4913.                                                  NGX_HTTP_V2_FLOW_CTRL_ERROR)
  4914.                     == NGX_ERROR)
  4915.                 {
  4916.                     return NGX_ERROR;
  4917.                 }

  4919.                 continue;
  4920.             }

  4922.             stream->send_window += delta;

  4924.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  4925.                            "http2:%ui adjusted window: %z",
  4926.                            node->id, stream->send_window);

  4928.             if (stream->send_window > 0 && stream->exhausted) {
  4929.                 stream->exhausted = 0;

  4931.                 wev = stream->request->connection->write;

  4933.                 wev->active = 0;
  4934.                 wev->ready = 1;

  4936.                 if (!wev->delayed) {
  4937.                     wev->handler(wev);
  4938.                 }
  4939.             }
  4940.         }
  4941.     }

  4943.     return NGX_OK;
  4944. }


  4947. static void
  4948. ‌ngx_http_v2_set_dependency(ngx_http_v2_connection_t *h2c,
  4949.     ngx_http_v2_node_t *node, ngx_uint_t depend, ngx_uint_t exclusive)
  4950. {
  4951.     ngx_queue_t         *children, *q;
  4952.     ngx_http_v2_node_t  *parent, *child, *next;

  4954.     parent = depend ? ngx_http_v2_get_node_by_id(h2c, depend, 0) : NULL;

  4956.     if (parent == NULL) {
  4957.         parent = NGX_HTTP_V2_ROOT;

  4959.         if (depend != 0) {
  4960.             exclusive = 0;
  4961.         }

  4963.         node->rank = 1;
  4964.         node->rel_weight = (1.0 / 256) * node->weight;

  4966.         children = &h2c->dependencies;

  4968.     } else {
  4969.         if (node->parent != NULL) {

  4971.             for (next = parent->parent;
  4972.                  next != NGX_HTTP_V2_ROOT && next->rank >= node->rank;
  4973.                  next = next->parent)
  4974.             {
  4975.                 if (next != node) {
  4976.                     continue;
  4977.                 }

  4979.                 ngx_queue_remove(&parent->queue);
  4980.                 ngx_queue_insert_after(&node->queue, &parent->queue);

  4982.                 parent->parent = node->parent;

  4984.                 if (node->parent == NGX_HTTP_V2_ROOT) {
  4985.                     parent->rank = 1;
  4986.                     parent->rel_weight = (1.0 / 256) * parent->weight;

  4988.                 } else {
  4989.                     parent->rank = node->parent->rank + 1;
  4990.                     parent->rel_weight = (node->parent->rel_weight / 256)
  4991.                                          * parent->weight;
  4992.                 }

  4994.                 if (!exclusive) {
  4995.                     ngx_http_v2_node_children_update(parent);
  4996.                 }

  4998.                 break;
  4999.             }
  5000.         }

  5002.         node->rank = parent->rank + 1;
  5003.         node->rel_weight = (parent->rel_weight / 256) * node->weight;

  5005.         if (parent->stream == NULL) {
  5006.             ngx_queue_remove(&parent->reuse);
  5007.             ngx_queue_insert_tail(&h2c->closed, &parent->reuse);
  5008.         }

  5010.         children = &parent->children;
  5011.     }

  5013.     if (exclusive) {
  5014.         for (q = ngx_queue_head(children);
  5015.              q != ngx_queue_sentinel(children);
  5016.              q = ngx_queue_next(q))
  5017.         {
  5018.             child = ngx_queue_data(q, ngx_http_v2_node_t, queue);
  5019.             child->parent = node;
  5020.         }

  5022.         ngx_queue_add(&node->children, children);
  5023.         ngx_queue_init(children);
  5024.     }

  5026.     if (node->parent != NULL) {
  5027.         ngx_queue_remove(&node->queue);
  5028.     }

  5030.     ngx_queue_insert_tail(children, &node->queue);

  5032.     node->parent = parent;

  5034.     ngx_http_v2_node_children_update(node);
  5035. }


  5038. static void
  5039. ‌ngx_http_v2_node_children_update(ngx_http_v2_node_t *node)
  5040. {
  5041.     ngx_queue_t         *q;
  5042.     ngx_http_v2_node_t  *child;

  5044.     for (q = ngx_queue_head(&node->children);
  5045.          q != ngx_queue_sentinel(&node->children);
  5046.          q = ngx_queue_next(q))
  5047.     {
  5048.         child = ngx_queue_data(q, ngx_http_v2_node_t, queue);

  5050.         child->rank = node->rank + 1;
  5051.         child->rel_weight = (node->rel_weight / 256) * child->weight;

  5053.         ngx_http_v2_node_children_update(child);
  5054.     }
  5055. }


  5058. static void
  5059. ‌ngx_http_v2_pool_cleanup(void *data)
  5060. {
  5061.     ngx_http_v2_connection_t  *h2c = data;

  5063.     if (h2c->state.pool) {
  5064.         ngx_destroy_pool(h2c->state.pool);
  5065.     }

  5067.     if (h2c->pool) {
  5068.         ngx_destroy_pool(h2c->pool);
  5069.     }
  5070. }

One Level Up Top Level