One Level Up Top Level

src/http/v2/ngx_http_v2.c - nginx-1.31.4 nginx/ @ 8d9666701

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 (ngx_http_v2_construct_request_line(r) != NGX_OK) {
  1807.         goto error;
  1808.     }

  1810.     if (r->invalid_header) {
  1811.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  1817.             return ngx_http_v2_state_header_complete(h2c, pos, end);
  1818.         }
  1819.     }

  1821.     if (header->name.len == cookie.len
  1822.         && ngx_memcmp(header->name.data, cookie.data, cookie.len) == 0)
  1823.     {
  1824.         if (ngx_http_v2_cookie(r, header) != NGX_OK) {
  1825.             return ngx_http_v2_connection_error(h2c,
  1826.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1827.         }

  1829.     } else {
  1830.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  1839.         h = ngx_list_push(&r->headers_in.headers);
  1840.         if (h == NULL) {
  1841.             return ngx_http_v2_connection_error(h2c,
  1842.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1843.         }

  1845.         h->key.len = header->name.len;
  1846.         h->key.data = header->name.data;

  1848.         /*
  1849.          * TODO Optimization: precalculate hash
  1850.          * and handler for indexed headers.
  1851.          */
  1852.         h->hash = ngx_hash_key(h->key.data, h->key.len);

  1854.         h->value.len = header->value.len;
  1855.         h->value.data = header->value.data;

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

  1859.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  1864.         if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1865.             goto error;
  1866.         }
  1867.     }

  1869.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1870.                    "http2 header: \"%V: %V\"",
  1871.                    &header->name, &header->value);

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

  1875. error:

  1877.     h2c->state.stream = NULL;

  1879.     ngx_http_run_posted_requests(fc);

  1881.     return ngx_http_v2_state_header_complete(h2c, pos, end);
  1882. }


  1885. static u_char *
  1886. ‌ngx_http_v2_state_header_complete(ngx_http_v2_connection_t *h2c, u_char *pos,
  1887.     u_char *end)
  1888. {
  1889.     ngx_http_v2_stream_t  *stream;

  1891.     if (h2c->state.length) {
  1892.         if (end - pos > 0) {
  1893.             h2c->state.handler = ngx_http_v2_state_header_block;
  1894.             return pos;
  1895.         }

  1897.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1898.                                               ngx_http_v2_state_header_block);
  1899.     }

  1901.     if (!(h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG)) {
  1902.         return ngx_http_v2_handle_continuation(h2c, pos, end,
  1903.                                              ngx_http_v2_state_header_complete);
  1904.     }

  1906.     stream = h2c->state.stream;

  1908.     if (stream) {
  1909.         ngx_http_v2_run_request(stream->request);
  1910.     }

  1912.     if (!h2c->state.keep_pool) {
  1913.         ngx_destroy_pool(h2c->state.pool);
  1914.     }

  1916.     h2c->state.pool = NULL;
  1917.     h2c->state.keep_pool = 0;

  1919.     if (h2c->state.padding) {
  1920.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1921.     }

  1923.     return ngx_http_v2_state_complete(h2c, pos, end);
  1924. }


  1927. static u_char *
  1928. ‌ngx_http_v2_handle_continuation(ngx_http_v2_connection_t *h2c, u_char *pos,
  1929.     u_char *end, ngx_http_v2_handler_pt handler)
  1930. {
  1931.     u_char    *p;
  1932.     size_t     len, skip;
  1933.     uint32_t   head;

  1935.     len = h2c->state.length;

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

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

  1942.         p = pos;
  1943.         pos += skip;
  1944.         ngx_memmove(pos, p, len);
  1945.     }

  1947.     if ((size_t) (end - pos) < len + NGX_HTTP_V2_FRAME_HEADER_SIZE) {
  1948.         return ngx_http_v2_state_headers_save(h2c, pos, end, handler);
  1949.     }

  1951.     p = pos + len;

  1953.     head = ngx_http_v2_parse_uint32(p);

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

  1959.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1960.     }

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

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

  1968.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1969.     }

  1971.     p = pos;
  1972.     pos += NGX_HTTP_V2_FRAME_HEADER_SIZE;

  1974.     ngx_memcpy(pos, p, len);

  1976.     len = ngx_http_v2_parse_length(head);

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

  1980.     if (h2c->state.stream) {
  1981.         h2c->state.stream->request->request_length += len;
  1982.     }

  1984.     h2c->state.handler = handler;
  1985.     return pos;
  1986. }


  1989. static u_char *
  1990. ‌ngx_http_v2_state_priority(ngx_http_v2_connection_t *h2c, u_char *pos,
  1991.     u_char *end)
  1992. {
  1993.     ngx_uint_t           depend, dependency, excl, weight;
  1994.     ngx_http_v2_node_t  *node;

  1996.     if (h2c->state.length != NGX_HTTP_V2_PRIORITY_SIZE) {
  1997.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1998.                       "client sent PRIORITY frame with incorrect length %uz",
  1999.                       h2c->state.length);

  2001.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2002.     }

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

  2008.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_ENHANCE_YOUR_CALM);
  2009.     }

  2011.     if (end - pos < NGX_HTTP_V2_PRIORITY_SIZE) {
  2012.         return ngx_http_v2_state_save(h2c, pos, end,
  2013.                                       ngx_http_v2_state_priority);
  2014.     }

  2016.     dependency = ngx_http_v2_parse_uint32(pos);

  2018.     depend = dependency & 0x7fffffff;
  2019.     excl = dependency >> 31;
  2020.     weight = pos[4] + 1;

  2022.     pos += NGX_HTTP_V2_PRIORITY_SIZE;

  2024.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2025.                    "http2 PRIORITY frame sid:%ui "
  2026.                    "depends on %ui excl:%ui weight:%ui",
  2027.                    h2c->state.sid, depend, excl, weight);

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

  2033.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2034.     }

  2036.     if (depend == h2c->state.sid) {
  2037.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2038.                       "client sent PRIORITY frame for stream %ui "
  2039.                       "with incorrect dependency", h2c->state.sid);

  2041.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2042.     }

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

  2046.     if (node == NULL) {
  2047.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2048.     }

  2050.     node->weight = weight;

  2052.     if (node->stream == NULL) {
  2053.         if (node->parent == NULL) {
  2054.             h2c->closed_nodes++;

  2056.         } else {
  2057.             ngx_queue_remove(&node->reuse);
  2058.         }

  2060.         ngx_queue_insert_tail(&h2c->closed, &node->reuse);
  2061.     }

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

  2065.     return ngx_http_v2_state_complete(h2c, pos, end);
  2066. }


  2069. static u_char *
  2070. ‌ngx_http_v2_state_rst_stream(ngx_http_v2_connection_t *h2c, u_char *pos,
  2071.     u_char *end)
  2072. {
  2073.     ngx_uint_t             status;
  2074.     ngx_event_t           *ev;
  2075.     ngx_connection_t      *fc;
  2076.     ngx_http_v2_node_t    *node;
  2077.     ngx_http_v2_stream_t  *stream;

  2079.     if (h2c->state.length != NGX_HTTP_V2_RST_STREAM_SIZE) {
  2080.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2081.                       "client sent RST_STREAM frame with incorrect length %uz",
  2082.                       h2c->state.length);

  2084.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2085.     }

  2087.     if (end - pos < NGX_HTTP_V2_RST_STREAM_SIZE) {
  2088.         return ngx_http_v2_state_save(h2c, pos, end,
  2089.                                       ngx_http_v2_state_rst_stream);
  2090.     }

  2092.     status = ngx_http_v2_parse_uint32(pos);

  2094.     pos += NGX_HTTP_V2_RST_STREAM_SIZE;

  2096.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2097.                    "http2 RST_STREAM frame, sid:%ui status:%ui",
  2098.                    h2c->state.sid, status);

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

  2104.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2105.     }

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

  2109.     if (node == NULL || node->stream == NULL) {
  2110.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2111.                        "unknown http2 stream");

  2113.         return ngx_http_v2_state_complete(h2c, pos, end);
  2114.     }

  2116.     stream = node->stream;

  2118.     stream->in_closed = 1;
  2119.     stream->out_closed = 1;

  2121.     fc = stream->request->connection;
  2122.     fc->error = 1;

  2124.     switch (status) {

  2126.     case NGX_HTTP_V2_CANCEL:
  2127.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2128.                       "client canceled stream %ui", h2c->state.sid);
  2129.         break;

  2131.     case NGX_HTTP_V2_INTERNAL_ERROR:
  2132.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2133.                       "client terminated stream %ui due to internal error",
  2134.                       h2c->state.sid);
  2135.         break;

  2137.     default:
  2138.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2139.                       "client terminated stream %ui with status %ui",
  2140.                       h2c->state.sid, status);
  2141.         break;
  2142.     }

  2144.     ev = fc->read;
  2145.     ev->handler(ev);

  2147.     return ngx_http_v2_state_complete(h2c, pos, end);
  2148. }


  2151. static u_char *
  2152. ‌ngx_http_v2_state_settings(ngx_http_v2_connection_t *h2c, u_char *pos,
  2153.     u_char *end)
  2154. {
  2155.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2156.                    "http2 SETTINGS frame");

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

  2162.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2163.     }

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

  2167.         if (h2c->state.length != 0) {
  2168.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2169.                           "client sent SETTINGS frame with the ACK flag "
  2170.                           "and nonzero length");

  2172.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2173.         }

  2175.         h2c->settings_ack = 1;

  2177.         return ngx_http_v2_state_complete(h2c, pos, end);
  2178.     }

  2180.     if (h2c->state.length % NGX_HTTP_V2_SETTINGS_PARAM_SIZE) {
  2181.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2182.                       "client sent SETTINGS frame with incorrect length %uz",
  2183.                       h2c->state.length);

  2185.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2186.     }

  2188.     h2c->state.window_delta = 0;

  2190.     return ngx_http_v2_state_settings_params(h2c, pos, end);
  2191. }


  2194. static u_char *
  2195. ‌ngx_http_v2_state_settings_params(ngx_http_v2_connection_t *h2c, u_char *pos,
  2196.     u_char *end)
  2197. {
  2198.     ngx_uint_t                id, value;
  2199.     ngx_http_v2_out_frame_t  *frame;

  2201.     while (h2c->state.length) {
  2202.         if (end - pos < NGX_HTTP_V2_SETTINGS_PARAM_SIZE) {
  2203.             return ngx_http_v2_state_save(h2c, pos, end,
  2204.                                           ngx_http_v2_state_settings_params);
  2205.         }

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

  2209.         id = ngx_http_v2_parse_uint16(pos);
  2210.         value = ngx_http_v2_parse_uint32(&pos[2]);

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

  2215.         switch (id) {

  2217.         case NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING:

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

  2224.                 return ngx_http_v2_connection_error(h2c,
  2225.                                                   NGX_HTTP_V2_FLOW_CTRL_ERROR);
  2226.             }

  2228.             h2c->state.window_delta = (ssize_t) value
  2229.                                       - (ssize_t) h2c->init_window;
  2230.             break;

  2232.         case NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING:

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

  2241.                 return ngx_http_v2_connection_error(h2c,
  2242.                                                     NGX_HTTP_V2_PROTOCOL_ERROR);
  2243.             }

  2245.             h2c->frame_size = value;
  2246.             break;

  2248.         case NGX_HTTP_V2_ENABLE_PUSH_SETTING:

  2250.             if (value > 1) {
  2251.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2252.                               "client sent SETTINGS frame with incorrect "
  2253.                               "ENABLE_PUSH value %ui", value);

  2255.                 return ngx_http_v2_connection_error(h2c,
  2256.                                                     NGX_HTTP_V2_PROTOCOL_ERROR);
  2257.             }

  2259.             break;

  2261.         case NGX_HTTP_V2_HEADER_TABLE_SIZE_SETTING:

  2263.             h2c->table_update = 1;
  2264.             break;

  2266.         default:
  2267.             break;
  2268.         }

  2270.         pos += NGX_HTTP_V2_SETTINGS_PARAM_SIZE;
  2271.     }

  2273.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_SETTINGS_ACK_SIZE,
  2274.                                   NGX_HTTP_V2_SETTINGS_FRAME,
  2275.                                   NGX_HTTP_V2_ACK_FLAG, 0);
  2276.     if (frame == NULL) {
  2277.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2278.     }

  2280.     ngx_http_v2_queue_ordered_frame(h2c, frame);

  2282.     if (h2c->state.window_delta) {
  2283.         h2c->init_window += h2c->state.window_delta;

  2285.         if (ngx_http_v2_adjust_windows(h2c, h2c->state.window_delta) != NGX_OK)
  2286.         {
  2287.             return ngx_http_v2_connection_error(h2c,
  2288.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  2289.         }

  2291.         h2c->state.window_delta = 0;
  2292.     }

  2294.     return ngx_http_v2_state_complete(h2c, pos, end);
  2295. }


  2298. static u_char *
  2299. ‌ngx_http_v2_state_push_promise(ngx_http_v2_connection_t *h2c, u_char *pos,
  2300.     u_char *end)
  2301. {
  2302.     ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2303.                   "client sent PUSH_PROMISE frame");

  2305.     return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2306. }


  2309. static u_char *
  2310. ‌ngx_http_v2_state_ping(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  2311. {
  2312.     ngx_buf_t                *buf;
  2313.     ngx_http_v2_out_frame_t  *frame;

  2315.     if (h2c->state.length != NGX_HTTP_V2_PING_SIZE) {
  2316.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2317.                       "client sent PING frame with incorrect length %uz",
  2318.                       h2c->state.length);

  2320.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2321.     }

  2323.     if (end - pos < NGX_HTTP_V2_PING_SIZE) {
  2324.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_ping);
  2325.     }

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

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

  2334.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2335.     }

  2337.     if (h2c->state.flags & NGX_HTTP_V2_ACK_FLAG) {
  2338.         return ngx_http_v2_state_skip(h2c, pos, end);
  2339.     }

  2341.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_PING_SIZE,
  2342.                                   NGX_HTTP_V2_PING_FRAME,
  2343.                                   NGX_HTTP_V2_ACK_FLAG, 0);
  2344.     if (frame == NULL) {
  2345.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2346.     }

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

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

  2352.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2354.     return ngx_http_v2_state_complete(h2c, pos + NGX_HTTP_V2_PING_SIZE, end);
  2355. }


  2358. static u_char *
  2359. ‌ngx_http_v2_state_goaway(ngx_http_v2_connection_t *h2c, u_char *pos,
  2360.     u_char *end)
  2361. {
  2362. #if (NGX_DEBUG)
  2363.     ngx_uint_t  last_sid, error;
  2364. #endif

  2366.     if (h2c->state.length < NGX_HTTP_V2_GOAWAY_SIZE) {
  2367.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2368.                       "client sent GOAWAY frame "
  2369.                       "with incorrect length %uz", h2c->state.length);

  2371.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2372.     }

  2374.     if (end - pos < NGX_HTTP_V2_GOAWAY_SIZE) {
  2375.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_goaway);
  2376.     }

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

  2382.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2383.     }

  2385. #if (NGX_DEBUG)
  2386.     h2c->state.length -= NGX_HTTP_V2_GOAWAY_SIZE;

  2388.     last_sid = ngx_http_v2_parse_sid(pos);
  2389.     error = ngx_http_v2_parse_uint32(&pos[4]);

  2391.     pos += NGX_HTTP_V2_GOAWAY_SIZE;

  2393.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2394.                    "http2 GOAWAY frame: last sid %ui, error %ui",
  2395.                    last_sid, error);
  2396. #endif

  2398.     return ngx_http_v2_state_skip(h2c, pos, end);
  2399. }


  2402. static u_char *
  2403. ‌ngx_http_v2_state_window_update(ngx_http_v2_connection_t *h2c, u_char *pos,
  2404.     u_char *end)
  2405. {
  2406.     size_t                 window;
  2407.     ngx_event_t           *wev;
  2408.     ngx_queue_t           *q;
  2409.     ngx_http_v2_node_t    *node;
  2410.     ngx_http_v2_stream_t  *stream;

  2412.     if (h2c->state.length != NGX_HTTP_V2_WINDOW_UPDATE_SIZE) {
  2413.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2414.                       "client sent WINDOW_UPDATE frame "
  2415.                       "with incorrect length %uz", h2c->state.length);

  2417.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2418.     }

  2420.     if (end - pos < NGX_HTTP_V2_WINDOW_UPDATE_SIZE) {
  2421.         return ngx_http_v2_state_save(h2c, pos, end,
  2422.                                       ngx_http_v2_state_window_update);
  2423.     }

  2425.     window = ngx_http_v2_parse_window(pos);

  2427.     pos += NGX_HTTP_V2_WINDOW_UPDATE_SIZE;

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

  2433.     if (window == 0) {
  2434.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2435.                       "client sent WINDOW_UPDATE frame "
  2436.                       "with incorrect window increment 0");

  2438.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2439.     }

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

  2444.         if (node == NULL || node->stream == NULL) {
  2445.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2446.                            "unknown http2 stream");

  2448.             return ngx_http_v2_state_complete(h2c, pos, end);
  2449.         }

  2451.         stream = node->stream;

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

  2455.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2456.                           "client violated flow control for stream %ui: "
  2457.                           "received WINDOW_UPDATE frame "
  2458.                           "with window increment %uz "
  2459.                           "not allowed for window %z",
  2460.                           h2c->state.sid, window, stream->send_window);

  2462.             if (ngx_http_v2_terminate_stream(h2c, stream,
  2463.                                              NGX_HTTP_V2_FLOW_CTRL_ERROR)
  2464.                 == NGX_ERROR)
  2465.             {
  2466.                 return ngx_http_v2_connection_error(h2c,
  2467.                                                     NGX_HTTP_V2_INTERNAL_ERROR);
  2468.             }

  2470.             return ngx_http_v2_state_complete(h2c, pos, end);
  2471.         }

  2473.         stream->send_window += window;

  2475.         if (stream->exhausted) {
  2476.             stream->exhausted = 0;

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

  2480.             wev->active = 0;
  2481.             wev->ready = 1;

  2483.             if (!wev->delayed) {
  2484.                 wev->handler(wev);
  2485.             }
  2486.         }

  2488.         return ngx_http_v2_state_complete(h2c, pos, end);
  2489.     }

  2491.     if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
  2492.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2493.                       "client violated connection flow control: "
  2494.                       "received WINDOW_UPDATE frame "
  2495.                       "with window increment %uz "
  2496.                       "not allowed for window %uz",
  2497.                       window, h2c->send_window);

  2499.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
  2500.     }

  2502.     h2c->send_window += window;

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

  2507.         ngx_queue_remove(q);

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

  2511.         stream->waiting = 0;

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

  2515.         wev->active = 0;
  2516.         wev->ready = 1;

  2518.         if (!wev->delayed) {
  2519.             wev->handler(wev);

  2521.             if (h2c->send_window == 0) {
  2522.                 break;
  2523.             }
  2524.         }
  2525.     }

  2527.     return ngx_http_v2_state_complete(h2c, pos, end);
  2528. }


  2531. static u_char *
  2532. ‌ngx_http_v2_state_continuation(ngx_http_v2_connection_t *h2c, u_char *pos,
  2533.     u_char *end)
  2534. {
  2535.     ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2536.                   "client sent unexpected CONTINUATION frame");

  2538.     return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2539. }


  2542. static u_char *
  2543. ‌ngx_http_v2_state_complete(ngx_http_v2_connection_t *h2c, u_char *pos,
  2544.     u_char *end)
  2545. {
  2546.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2547.                    "http2 frame complete pos:%p end:%p", pos, end);

  2549.     if (pos > end) {
  2550.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  2551.                       "receive buffer overrun");

  2553.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2554.     }

  2556.     h2c->state.stream = NULL;
  2557.     h2c->state.handler = ngx_http_v2_state_head;

  2559.     return pos;
  2560. }


  2563. static u_char *
  2564. ‌ngx_http_v2_state_skip_padded(ngx_http_v2_connection_t *h2c, u_char *pos,
  2565.     u_char *end)
  2566. {
  2567.     h2c->state.length += h2c->state.padding;
  2568.     h2c->state.padding = 0;

  2570.     return ngx_http_v2_state_skip(h2c, pos, end);
  2571. }


  2574. static u_char *
  2575. ‌ngx_http_v2_state_skip(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  2576. {
  2577.     size_t  size;

  2579.     size = end - pos;

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

  2585.         h2c->state.length -= size;
  2586.         return ngx_http_v2_state_save(h2c, end, end, ngx_http_v2_state_skip);
  2587.     }

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

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


  2596. static u_char *
  2597. ‌ngx_http_v2_state_save(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end,
  2598.     ngx_http_v2_handler_pt handler)
  2599. {
  2600.     size_t  size;

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

  2606.     size = end - pos;

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

  2612.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2613.     }

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

  2617.     h2c->state.buffer_used = size;
  2618.     h2c->state.handler = handler;
  2619.     h2c->state.incomplete = 1;

  2621.     return end;
  2622. }


  2625. static u_char *
  2626. ‌ngx_http_v2_state_headers_save(ngx_http_v2_connection_t *h2c, u_char *pos,
  2627.     u_char *end, ngx_http_v2_handler_pt handler)
  2628. {
  2629.     ngx_event_t               *rev;
  2630.     ngx_http_request_t        *r;
  2631.     ngx_http_core_srv_conf_t  *cscf;

  2633.     if (h2c->state.stream) {
  2634.         r = h2c->state.stream->request;
  2635.         rev = r->connection->read;

  2637.         if (!rev->timer_set) {
  2638.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2639.             ngx_add_timer(rev, cscf->client_header_timeout);
  2640.         }
  2641.     }

  2643.     return ngx_http_v2_state_save(h2c, pos, end, handler);
  2644. }


  2647. static u_char *
  2648. ‌ngx_http_v2_connection_error(ngx_http_v2_connection_t *h2c,
  2649.     ngx_uint_t err)
  2650. {
  2651.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2652.                    "http2 state connection error");

  2654.     ngx_http_v2_finalize_connection(h2c, err);

  2656.     return NULL;
  2657. }


  2660. static ngx_int_t
  2661. ‌ngx_http_v2_parse_int(ngx_http_v2_connection_t *h2c, u_char **pos, u_char *end,
  2662.     ngx_uint_t prefix)
  2663. {
  2664.     u_char      *start, *p;
  2665.     ngx_uint_t   value, octet, shift;

  2667.     start = *pos;
  2668.     p = start;

  2670.     value = *p++ & prefix;

  2672.     if (value != prefix) {
  2673.         if (h2c->state.length == 0) {
  2674.             return NGX_ERROR;
  2675.         }

  2677.         h2c->state.length--;

  2679.         *pos = p;
  2680.         return value;
  2681.     }

  2683.     if (end - start > NGX_HTTP_V2_INT_OCTETS) {
  2684.         end = start + NGX_HTTP_V2_INT_OCTETS;
  2685.     }

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

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

  2692.         if (octet < 128) {
  2693.             if ((size_t) (p - start) > h2c->state.length) {
  2694.                 return NGX_ERROR;
  2695.             }

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

  2699.             *pos = p;
  2700.             return value;
  2701.         }
  2702.     }

  2704.     if ((size_t) (end - start) >= h2c->state.length) {
  2705.         return NGX_ERROR;
  2706.     }

  2708.     if (end == start + NGX_HTTP_V2_INT_OCTETS) {
  2709.         return NGX_DECLINED;
  2710.     }

  2712.     return NGX_AGAIN;
  2713. }


  2716. static ngx_int_t
  2717. ‌ngx_http_v2_send_settings(ngx_http_v2_connection_t *h2c)
  2718. {
  2719.     size_t                    len;
  2720.     ngx_buf_t                *buf;
  2721.     ngx_chain_t              *cl;
  2722.     ngx_http_v2_srv_conf_t   *h2scf;
  2723.     ngx_http_v2_out_frame_t  *frame;

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

  2728.     frame = ngx_palloc(h2c->pool, sizeof(ngx_http_v2_out_frame_t));
  2729.     if (frame == NULL) {
  2730.         return NGX_ERROR;
  2731.     }

  2733.     cl = ngx_alloc_chain_link(h2c->pool);
  2734.     if (cl == NULL) {
  2735.         return NGX_ERROR;
  2736.     }

  2738.     len = NGX_HTTP_V2_SETTINGS_PARAM_SIZE * 3;

  2740.     buf = ngx_create_temp_buf(h2c->pool, NGX_HTTP_V2_FRAME_HEADER_SIZE + len);
  2741.     if (buf == NULL) {
  2742.         return NGX_ERROR;
  2743.     }

  2745.     buf->last_buf = 1;

  2747.     cl->buf = buf;
  2748.     cl->next = NULL;

  2750.     frame->first = cl;
  2751.     frame->last = cl;
  2752.     frame->handler = ngx_http_v2_settings_frame_handler;
  2753.     frame->stream = NULL;
  2754. #if (NGX_DEBUG)
  2755.     frame->length = len;
  2756. #endif
  2757.     frame->blocked = 0;

  2759.     buf->last = ngx_http_v2_write_len_and_type(buf->last, len,
  2760.                                                NGX_HTTP_V2_SETTINGS_FRAME);

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

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

  2766.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  2767.                                          ngx_http_v2_module);

  2769.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2770.                                          NGX_HTTP_V2_MAX_STREAMS_SETTING);
  2771.     buf->last = ngx_http_v2_write_uint32(buf->last,
  2772.                                          h2scf->concurrent_streams);

  2774.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2775.                                          NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING);
  2776.     buf->last = ngx_http_v2_write_uint32(buf->last, h2scf->preread_size);

  2778.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2779.                                          NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING);
  2780.     buf->last = ngx_http_v2_write_uint32(buf->last,
  2781.                                          NGX_HTTP_V2_MAX_FRAME_SIZE);

  2783.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2785.     return NGX_OK;
  2786. }


  2789. static ngx_int_t
  2790. ‌ngx_http_v2_settings_frame_handler(ngx_http_v2_connection_t *h2c,
  2791.     ngx_http_v2_out_frame_t *frame)
  2792. {
  2793.     ngx_buf_t  *buf;

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

  2797.     if (buf->pos != buf->last) {
  2798.         return NGX_AGAIN;
  2799.     }

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

  2803.     return NGX_OK;
  2804. }


  2807. static ngx_int_t
  2808. ‌ngx_http_v2_send_window_update(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  2809.     size_t window)
  2810. {
  2811.     ngx_buf_t                *buf;
  2812.     ngx_http_v2_out_frame_t  *frame;

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

  2818.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_WINDOW_UPDATE_SIZE,
  2819.                                   NGX_HTTP_V2_WINDOW_UPDATE_FRAME,
  2820.                                   NGX_HTTP_V2_NO_FLAG, sid);
  2821.     if (frame == NULL) {
  2822.         return NGX_ERROR;
  2823.     }

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

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

  2829.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2831.     return NGX_OK;
  2832. }


  2835. static ngx_int_t
  2836. ‌ngx_http_v2_send_rst_stream(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  2837.     ngx_uint_t status)
  2838. {
  2839.     ngx_buf_t                *buf;
  2840.     ngx_http_v2_out_frame_t  *frame;

  2842.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2843.                    "http2 send RST_STREAM frame sid:%ui, status:%ui",
  2844.                    sid, status);

  2846.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_RST_STREAM_SIZE,
  2847.                                   NGX_HTTP_V2_RST_STREAM_FRAME,
  2848.                                   NGX_HTTP_V2_NO_FLAG, sid);
  2849.     if (frame == NULL) {
  2850.         return NGX_ERROR;
  2851.     }

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

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

  2857.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2859.     return NGX_OK;
  2860. }


  2863. static ngx_int_t
  2864. ‌ngx_http_v2_send_goaway(ngx_http_v2_connection_t *h2c, ngx_uint_t status)
  2865. {
  2866.     ngx_buf_t                *buf;
  2867.     ngx_http_v2_out_frame_t  *frame;

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

  2873.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_GOAWAY_SIZE,
  2874.                                   NGX_HTTP_V2_GOAWAY_FRAME,
  2875.                                   NGX_HTTP_V2_NO_FLAG, 0);
  2876.     if (frame == NULL) {
  2877.         return NGX_ERROR;
  2878.     }

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

  2882.     buf->last = ngx_http_v2_write_sid(buf->last, h2c->last_sid);
  2883.     buf->last = ngx_http_v2_write_uint32(buf->last, status);

  2885.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2887.     return NGX_OK;
  2888. }


  2891. static ngx_http_v2_out_frame_t *
  2892. ‌ngx_http_v2_get_frame(ngx_http_v2_connection_t *h2c, size_t length,
  2893.     ngx_uint_t type, u_char flags, ngx_uint_t sid)
  2894. {
  2895.     ngx_buf_t                *buf;
  2896.     ngx_pool_t               *pool;
  2897.     ngx_http_v2_out_frame_t  *frame;

  2899.     frame = h2c->free_frames;

  2901.     if (frame) {
  2902.         h2c->free_frames = frame->next;

  2904.         buf = frame->first->buf;
  2905.         buf->pos = buf->start;

  2907.         frame->blocked = 0;

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

  2912.         frame = ngx_pcalloc(pool, sizeof(ngx_http_v2_out_frame_t));
  2913.         if (frame == NULL) {
  2914.             return NULL;
  2915.         }

  2917.         frame->first = ngx_alloc_chain_link(pool);
  2918.         if (frame->first == NULL) {
  2919.             return NULL;
  2920.         }

  2922.         buf = ngx_create_temp_buf(pool, NGX_HTTP_V2_FRAME_BUFFER_SIZE);
  2923.         if (buf == NULL) {
  2924.             return NULL;
  2925.         }

  2927.         buf->last_buf = 1;

  2929.         frame->first->buf = buf;
  2930.         frame->last = frame->first;

  2932.         frame->handler = ngx_http_v2_frame_handler;

  2934.         h2c->frames++;

  2936.     } else {
  2937.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2938.                       "http2 flood detected");

  2940.         h2c->connection->error = 1;
  2941.         return NULL;
  2942.     }

  2944. #if (NGX_DEBUG)
  2945.     if (length > NGX_HTTP_V2_FRAME_BUFFER_SIZE - NGX_HTTP_V2_FRAME_HEADER_SIZE)
  2946.     {
  2947.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  2948.                       "requested control frame is too large: %uz", length);
  2949.         return NULL;
  2950.     }
  2951. #endif

  2953.     frame->length = length;

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

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

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

  2961.     return frame;
  2962. }


  2965. static ngx_int_t
  2966. ‌ngx_http_v2_frame_handler(ngx_http_v2_connection_t *h2c,
  2967.     ngx_http_v2_out_frame_t *frame)
  2968. {
  2969.     ngx_buf_t  *buf;

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

  2973.     if (buf->pos != buf->last) {
  2974.         return NGX_AGAIN;
  2975.     }

  2977.     frame->next = h2c->free_frames;
  2978.     h2c->free_frames = frame;

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

  2982.     return NGX_OK;
  2983. }


  2986. static ngx_http_v2_stream_t *
  2987. ‌ngx_http_v2_create_stream(ngx_http_v2_connection_t *h2c)
  2988. {
  2989.     ngx_log_t                 *log;
  2990.     ngx_event_t               *rev, *wev;
  2991.     ngx_connection_t          *fc;
  2992.     ngx_http_log_ctx_t        *ctx;
  2993.     ngx_http_request_t        *r;
  2994.     ngx_http_v2_stream_t      *stream;
  2995.     ngx_http_v2_srv_conf_t    *h2scf;
  2996.     ngx_http_core_srv_conf_t  *cscf;

  2998.     fc = h2c->free_fake_connections;

  3000.     if (fc) {
  3001.         h2c->free_fake_connections = fc->data;

  3003.         rev = fc->read;
  3004.         wev = fc->write;
  3005.         log = fc->log;
  3006.         ctx = log->data;

  3008.     } else {
  3009.         fc = ngx_palloc(h2c->pool, sizeof(ngx_connection_t));
  3010.         if (fc == NULL) {
  3011.             return NULL;
  3012.         }

  3014.         rev = ngx_palloc(h2c->pool, sizeof(ngx_event_t));
  3015.         if (rev == NULL) {
  3016.             return NULL;
  3017.         }

  3019.         wev = ngx_palloc(h2c->pool, sizeof(ngx_event_t));
  3020.         if (wev == NULL) {
  3021.             return NULL;
  3022.         }

  3024.         log = ngx_palloc(h2c->pool, sizeof(ngx_log_t));
  3025.         if (log == NULL) {
  3026.             return NULL;
  3027.         }

  3029.         ctx = ngx_palloc(h2c->pool, sizeof(ngx_http_log_ctx_t));
  3030.         if (ctx == NULL) {
  3031.             return NULL;
  3032.         }

  3034.         ctx->connection = fc;
  3035.         ctx->request = NULL;
  3036.         ctx->current_request = NULL;
  3037.     }

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

  3041.     log->data = ctx;
  3042.     log->action = "reading client request headers";

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

  3046.     rev->data = fc;
  3047.     rev->ready = 1;
  3048.     rev->handler = ngx_http_v2_close_stream_handler;
  3049.     rev->log = log;

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

  3053.     wev->write = 1;

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

  3057.     fc->data = h2c->http_connection;
  3058.     fc->read = rev;
  3059.     fc->write = wev;
  3060.     fc->sent = 0;
  3061.     fc->log = log;
  3062.     fc->buffered = 0;
  3063.     fc->sndlowat = 1;
  3064.     fc->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;

  3066.     r = ngx_http_create_request(fc);
  3067.     if (r == NULL) {
  3068.         return NULL;
  3069.     }

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

  3073.     r->http_version = NGX_HTTP_VERSION_20;
  3074.     r->valid_location = 1;

  3076.     fc->data = r;
  3077.     h2c->connection->requests++;

  3079.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  3081.     r->header_in = ngx_create_temp_buf(r->pool,
  3082.                                        cscf->client_header_buffer_size);
  3083.     if (r->header_in == NULL) {
  3084.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3085.         return NULL;
  3086.     }

  3088.     if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  3089.                       sizeof(ngx_table_elt_t))
  3090.         != NGX_OK)
  3091.     {
  3092.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3093.         return NULL;
  3094.     }

  3096.     r->headers_in.connection_type = NGX_HTTP_CONNECTION_CLOSE;

  3098.     stream = ngx_pcalloc(r->pool, sizeof(ngx_http_v2_stream_t));
  3099.     if (stream == NULL) {
  3100.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3101.         return NULL;
  3102.     }

  3104.     r->stream = stream;

  3106.     stream->request = r;
  3107.     stream->connection = h2c;

  3109.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

  3111.     stream->send_window = h2c->init_window;
  3112.     stream->recv_window = h2scf->preread_size;

  3114.     h2c->processing++;

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

  3118.     if (h2c->connection->read->timer_set) {
  3119.         ngx_del_timer(h2c->connection->read);
  3120.     }

  3122.     return stream;
  3123. }


  3126. static ngx_http_v2_node_t *
  3127. ‌ngx_http_v2_get_node_by_id(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  3128.     ngx_uint_t alloc)
  3129. {
  3130.     ngx_uint_t               index;
  3131.     ngx_http_v2_node_t      *node;
  3132.     ngx_http_v2_srv_conf_t  *h2scf;

  3134.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  3135.                                          ngx_http_v2_module);

  3137.     index = ngx_http_v2_index(h2scf, sid);

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

  3141.         if (node->id == sid) {
  3142.             return node;
  3143.         }
  3144.     }

  3146.     if (!alloc) {
  3147.         return NULL;
  3148.     }

  3150.     if (h2c->closed_nodes < 32) {
  3151.         node = ngx_pcalloc(h2c->connection->pool, sizeof(ngx_http_v2_node_t));
  3152.         if (node == NULL) {
  3153.             return NULL;
  3154.         }

  3156.     } else {
  3157.         node = ngx_http_v2_get_closed_node(h2c);
  3158.     }

  3160.     node->id = sid;

  3162.     ngx_queue_init(&node->children);

  3164.     node->index = h2c->streams_index[index];
  3165.     h2c->streams_index[index] = node;

  3167.     return node;
  3168. }


  3171. static ngx_http_v2_node_t *
  3172. ‌ngx_http_v2_get_closed_node(ngx_http_v2_connection_t *h2c)
  3173. {
  3174.     ngx_uint_t               weight;
  3175.     ngx_queue_t             *q, *children;
  3176.     ngx_http_v2_node_t      *node, **next, *n, *parent, *child;
  3177.     ngx_http_v2_srv_conf_t  *h2scf;

  3179.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  3180.                                          ngx_http_v2_module);

  3182.     h2c->closed_nodes--;

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

  3186.     ngx_queue_remove(q);

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

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

  3192.     for ( ;; ) {
  3193.         n = *next;

  3195.         if (n == node) {
  3196.             *next = n->index;
  3197.             break;
  3198.         }

  3200.         next = &n->index;
  3201.     }

  3203.     ngx_queue_remove(&node->queue);

  3205.     weight = 0;

  3207.     for (q = ngx_queue_head(&node->children);
  3208.          q != ngx_queue_sentinel(&node->children);
  3209.          q = ngx_queue_next(q))
  3210.     {
  3211.         child = ngx_queue_data(q, ngx_http_v2_node_t, queue);
  3212.         weight += child->weight;
  3213.     }

  3215.     parent = node->parent;

  3217.     for (q = ngx_queue_head(&node->children);
  3218.          q != ngx_queue_sentinel(&node->children);
  3219.          q = ngx_queue_next(q))
  3220.     {
  3221.         child = ngx_queue_data(q, ngx_http_v2_node_t, queue);
  3222.         child->parent = parent;
  3223.         child->weight = node->weight * child->weight / weight;

  3225.         if (child->weight == 0) {
  3226.             child->weight = 1;
  3227.         }
  3228.     }

  3230.     if (parent == NGX_HTTP_V2_ROOT) {
  3231.         node->rank = 0;
  3232.         node->rel_weight = 1.0;

  3234.         children = &h2c->dependencies;

  3236.     } else {
  3237.         node->rank = parent->rank;
  3238.         node->rel_weight = parent->rel_weight;

  3240.         children = &parent->children;
  3241.     }

  3243.     ngx_http_v2_node_children_update(node);
  3244.     ngx_queue_add(children, &node->children);

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

  3248.     return node;
  3249. }


  3252. static ngx_int_t
  3253. ‌ngx_http_v2_validate_header(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3254. {
  3255.     u_char                     ch;
  3256.     ngx_uint_t                 i;
  3257.     ngx_http_core_srv_conf_t  *cscf;

  3259.     r->invalid_header = 0;

  3261.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  3266.         if ((ch >= 'a' && ch <= 'z')
  3267.             || (ch == '-')
  3268.             || (ch >= '0' && ch <= '9')
  3269.             || (ch == '_' && cscf->underscores_in_headers))
  3270.         {
  3271.             continue;
  3272.         }

  3274.         if (ch <= 0x20 || ch == 0x7f || ch == ':'
  3275.             || (ch >= 'A' && ch <= 'Z'))
  3276.         {
  3277.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3278.                           "client sent invalid header name: \"%V\"",
  3279.                           &header->name);

  3281.             return NGX_ERROR;
  3282.         }

  3284.         r->invalid_header = 1;
  3285.     }

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

  3290.         if (ch == '\0' || ch == LF || ch == CR) {
  3291.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3292.                           "client sent header \"%V\" with "
  3293.                           "invalid value: \"%V\"",
  3294.                           &header->name, &header->value);

  3296.             return NGX_ERROR;
  3297.         }
  3298.     }

  3300.     return NGX_OK;
  3301. }


  3304. static ngx_int_t
  3305. ‌ngx_http_v2_pseudo_header(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3306. {
  3307.     header->name.len--;
  3308.     header->name.data++;

  3310.     if (r->request_line.len) {
  3311.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3312.                       "client sent out of order pseudo-headers");

  3314.         return NGX_DECLINED;
  3315.     }

  3317.     switch (header->name.len) {
  3318.     case 4:
  3319.         if (ngx_memcmp(header->name.data, "path", sizeof("path") - 1)
  3320.             == 0)
  3321.         {
  3322.             return ngx_http_v2_parse_path(r, &header->value);
  3323.         }

  3325.         break;

  3327.     case 6:
  3328.         if (ngx_memcmp(header->name.data, "method", sizeof("method") - 1)
  3329.             == 0)
  3330.         {
  3331.             return ngx_http_v2_parse_method(r, &header->value);
  3332.         }

  3334.         if (ngx_memcmp(header->name.data, "scheme", sizeof("scheme") - 1)
  3335.             == 0)
  3336.         {
  3337.             return ngx_http_v2_parse_scheme(r, &header->value);
  3338.         }

  3340.         break;

  3342.     case 9:
  3343.         if (ngx_memcmp(header->name.data, "authority", sizeof("authority") - 1)
  3344.             == 0)
  3345.         {
  3346.             return ngx_http_v2_parse_authority(r, &header->value);
  3347.         }

  3349.         break;
  3350.     }

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

  3356.     return NGX_DECLINED;
  3357. }


  3360. static ngx_int_t
  3361. ‌ngx_http_v2_parse_path(ngx_http_request_t *r, ngx_str_t *value)
  3362. {
  3363.     if (r->unparsed_uri.len) {
  3364.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3365.                       "client sent duplicate :path header");

  3367.         return NGX_DECLINED;
  3368.     }

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

  3374.         return NGX_DECLINED;
  3375.     }

  3377.     r->uri_start = value->data;
  3378.     r->uri_end = value->data + value->len;

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

  3384.         return NGX_DECLINED;
  3385.     }

  3387.     if (ngx_http_process_request_uri(r) != NGX_OK) {
  3388.         /*
  3389.          * request has been finalized already
  3390.          * in ngx_http_process_request_uri()
  3391.          */
  3392.         return NGX_ABORT;
  3393.     }

  3395.     return NGX_OK;
  3396. }


  3399. static ngx_int_t
  3400. ‌ngx_http_v2_parse_method(ngx_http_request_t *r, ngx_str_t *value)
  3401. {
  3402.     size_t         k, len;
  3403.     ngx_uint_t     n;
  3404.     const u_char  *p, *m;

  3406.     /*
  3407.      * This array takes less than 256 sequential bytes,
  3408.      * and if typical CPU cache line size is 64 bytes,
  3409.      * it is prefetched for 4 load operations.
  3410.      */
  3411. ‌    static const struct {
  3412.         u_char            len;
  3413.         const u_char      method[11];
  3414.         uint32_t          value;
  3415.     } tests[] = {
  3416.         { 3, "GET",       NGX_HTTP_GET },
  3417.         { 4, "POST",      NGX_HTTP_POST },
  3418.         { 4, "HEAD",      NGX_HTTP_HEAD },
  3419.         { 7, "OPTIONS",   NGX_HTTP_OPTIONS },
  3420.         { 8, "PROPFIND",  NGX_HTTP_PROPFIND },
  3421.         { 3, "PUT",       NGX_HTTP_PUT },
  3422.         { 5, "MKCOL",     NGX_HTTP_MKCOL },
  3423.         { 6, "DELETE",    NGX_HTTP_DELETE },
  3424.         { 4, "COPY",      NGX_HTTP_COPY },
  3425.         { 4, "MOVE",      NGX_HTTP_MOVE },
  3426.         { 9, "PROPPATCH", NGX_HTTP_PROPPATCH },
  3427.         { 4, "LOCK",      NGX_HTTP_LOCK },
  3428.         { 6, "UNLOCK",    NGX_HTTP_UNLOCK },
  3429.         { 5, "PATCH",     NGX_HTTP_PATCH },
  3430.         { 5, "TRACE",     NGX_HTTP_TRACE },
  3431.         { 7, "CONNECT",   NGX_HTTP_CONNECT }
  3432.     }, *test;

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

  3438.         return NGX_DECLINED;
  3439.     }

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

  3445.         return NGX_DECLINED;
  3446.     }

  3448.     r->method_name.len = value->len;
  3449.     r->method_name.data = value->data;

  3451.     len = r->method_name.len;
  3452.     n = sizeof(tests) / sizeof(tests[0]);
  3453.     test = tests;

  3455.     do {
  3456.         if (len == test->len) {
  3457.             p = r->method_name.data;
  3458.             m = test->method;
  3459.             k = len;

  3461.             do {
  3462.                 if (*p++ != *m++) {
  3463.                     goto next;
  3464.                 }
  3465.             } while (--k);

  3467.             r->method = test->value;
  3468.             return NGX_OK;
  3469.         }

  3471.     next:
  3472.         test++;

  3474.     } while (--n);

  3476.     p = r->method_name.data;

  3478.     do {
  3479.         if ((*p < 'A' || *p > 'Z') && *p != '_' && *p != '-') {
  3480.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3481.                           "client sent invalid method: \"%V\"",
  3482.                           &r->method_name);

  3484.             return NGX_DECLINED;
  3485.         }

  3487.         p++;

  3489.     } while (--len);

  3491.     return NGX_OK;
  3492. }


  3495. static ngx_int_t
  3496. ‌ngx_http_v2_parse_scheme(ngx_http_request_t *r, ngx_str_t *value)
  3497. {
  3498.     u_char      c, ch;
  3499.     ngx_uint_t  i;

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

  3505.         return NGX_DECLINED;
  3506.     }

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

  3512.         return NGX_DECLINED;
  3513.     }

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

  3518.         c = (u_char) (ch | 0x20);
  3519.         if (c >= 'a' && c <= 'z') {
  3520.             continue;
  3521.         }

  3523.         if (((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')
  3524.             && i > 0)
  3525.         {
  3526.             continue;
  3527.         }

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

  3532.         return NGX_DECLINED;
  3533.     }

  3535.     r->schema = *value;

  3537.     return NGX_OK;
  3538. }


  3541. static ngx_int_t
  3542. ‌ngx_http_v2_parse_authority(ngx_http_request_t *r, ngx_str_t *value)
  3543. {
  3544.     ngx_int_t  rc;
  3545.     in_port_t  port;

  3547.     if (r->host_start) {
  3548.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3549.                       "client sent duplicate \":authority\" header");
  3550.         return NGX_DECLINED;
  3551.     }

  3553.     r->host_start = value->data;
  3554.     r->host_end = value->data + value->len;

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

  3558.     if (rc == NGX_DECLINED) {
  3559.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3560.                       "client sent invalid \":authority\" header");
  3561.         return NGX_DECLINED;
  3562.     }

  3564.     if (rc == NGX_ERROR) {
  3565.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3566.         return NGX_ABORT;
  3567.     }

  3569.     if (ngx_http_set_virtual_server(r, value) == NGX_ERROR) {
  3570.         /*
  3571.          * request has been finalized already
  3572.          * in ngx_http_set_virtual_server()
  3573.          */
  3574.         return NGX_ABORT;
  3575.     }

  3577.     r->headers_in.server = *value;
  3578.     r->port = port;

  3580.     return NGX_OK;
  3581. }


  3584. static ngx_int_t
  3585. ‌ngx_http_v2_construct_request_line(ngx_http_request_t *r)
  3586. {
  3587.     u_char  *p;

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

  3591.     if (r->request_line.len) {
  3592.         return NGX_OK;
  3593.     }

  3595.     if (r->method_name.len == 0
  3596.         || r->schema.len == 0
  3597.         || r->unparsed_uri.len == 0)
  3598.     {
  3599.         if (r->method_name.len == 0) {
  3600.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3601.                           "client sent no :method header");

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

  3607.         } else {
  3608.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3609.                           "client sent no :path header");
  3610.         }

  3612.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3613.         return NGX_ERROR;
  3614.     }

  3616.     r->request_line.len = r->method_name.len + 1
  3617.                           + r->unparsed_uri.len
  3618.                           + sizeof(ending) - 1;

  3620.     p = ngx_pnalloc(r->pool, r->request_line.len + 1);
  3621.     if (p == NULL) {
  3622.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3623.         return NGX_ERROR;
  3624.     }

  3626.     r->request_line.data = p;

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

  3630.     *p++ = ' ';

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

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

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

  3639.     return NGX_OK;
  3640. }


  3643. static ngx_int_t
  3644. ‌ngx_http_v2_cookie(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3645. {
  3646.     ngx_str_t    *val;
  3647.     ngx_array_t  *cookies;

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

  3651.     if (cookies == NULL) {
  3652.         cookies = ngx_array_create(r->pool, 2, sizeof(ngx_str_t));
  3653.         if (cookies == NULL) {
  3654.             return NGX_ERROR;
  3655.         }

  3657.         r->stream->cookies = cookies;
  3658.     }

  3660.     val = ngx_array_push(cookies);
  3661.     if (val == NULL) {
  3662.         return NGX_ERROR;
  3663.     }

  3665.     val->len = header->value.len;
  3666.     val->data = header->value.data;

  3668.     return NGX_OK;
  3669. }


  3672. static ngx_int_t
  3673. ‌ngx_http_v2_construct_cookie_header(ngx_http_request_t *r)
  3674. {
  3675.     u_char                     *buf, *p, *end;
  3676.     size_t                      len;
  3677.     ngx_str_t                  *vals;
  3678.     ngx_uint_t                  i;
  3679.     ngx_array_t                *cookies;
  3680.     ngx_table_elt_t            *h;
  3681.     ngx_http_header_t          *hh;
  3682.     ngx_http_core_main_conf_t  *cmcf;

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

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

  3688.     if (cookies == NULL) {
  3689.         return NGX_OK;
  3690.     }

  3692.     vals = cookies->elts;

  3694.     i = 0;
  3695.     len = 0;

  3697.     do {
  3698.         len += vals[i].len + 2;
  3699.     } while (++i != cookies->nelts);

  3701.     len -= 2;

  3703.     buf = ngx_pnalloc(r->pool, len + 1);
  3704.     if (buf == NULL) {
  3705.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3706.         return NGX_ERROR;
  3707.     }

  3709.     p = buf;
  3710.     end = buf + len;

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

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

  3716.         if (p == end) {
  3717.             *p = '\0';
  3718.             break;
  3719.         }

  3721.         *p++ = ';'; *p++ = ' ';
  3722.     }

  3724.     h = ngx_list_push(&r->headers_in.headers);
  3725.     if (h == NULL) {
  3726.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3727.         return NGX_ERROR;
  3728.     }

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

  3733.     h->key.len = cookie.len;
  3734.     h->key.data = cookie.data;

  3736.     h->value.len = len;
  3737.     h->value.data = buf;

  3739.     h->lowcase_key = cookie.data;

  3741.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  3746.     if (hh == NULL) {
  3747.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3748.         return NGX_ERROR;
  3749.     }

  3751.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  3752.         /*
  3753.          * request has been finalized already
  3754.          * in ngx_http_process_header_line()
  3755.          */
  3756.         return NGX_ERROR;
  3757.     }

  3759.     return NGX_OK;
  3760. }


  3763. static ngx_int_t
  3764. ‌ngx_http_v2_construct_host_header(ngx_http_request_t *r)
  3765. {
  3766.     ngx_table_elt_t            *h;
  3767.     ngx_http_header_t          *hh;
  3768.     ngx_http_core_main_conf_t  *cmcf;

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

  3772.     h = ngx_list_push(&r->headers_in.headers);
  3773.     if (h == NULL) {
  3774.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3775.         return NGX_ERROR;
  3776.     }

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

  3780.     h->key.len = host.len;
  3781.     h->key.data = host.data;

  3783.     h->value.len = r->host_end - r->host_start;
  3784.     h->value.data = r->host_start;

  3786.     h->lowcase_key = host.data;

  3788.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  3793.     if (hh == NULL) {
  3794.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3795.         return NGX_ERROR;
  3796.     }

  3798.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  3799.         /*
  3800.          * request has been finalized already
  3801.          * in ngx_http_process_host()
  3802.          */
  3803.         return NGX_ERROR;
  3804.     }

  3806.     return NGX_OK;
  3807. }


  3810. static void
  3811. ‌ngx_http_v2_run_request(ngx_http_request_t *r)
  3812. {
  3813.     ngx_str_t                  host;
  3814.     ngx_connection_t          *fc;
  3815.     ngx_http_v2_srv_conf_t    *h2scf;
  3816.     ngx_http_v2_connection_t  *h2c;

  3818.     fc = r->connection;

  3820.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

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

  3827.         ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  3828.         goto failed;
  3829.     }

  3831.     if (ngx_http_v2_construct_request_line(r) != NGX_OK) {
  3832.         goto failed;
  3833.     }

  3835.     if (ngx_http_v2_construct_cookie_header(r) != NGX_OK) {
  3836.         goto failed;
  3837.     }

  3839.     r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  3841.     if (r->headers_in.connection) {
  3842.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3843.                       "client sent \"Connection\" header");
  3844.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3845.         goto failed;
  3846.     }

  3848.     if (r->headers_in.keep_alive) {
  3849.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3850.                       "client sent \"Keep-Alive\" header");
  3851.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3852.         goto failed;
  3853.     }

  3855.     if (r->headers_in.transfer_encoding) {
  3856.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3857.                       "client sent \"Transfer-Encoding\" header");
  3858.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3859.         goto failed;
  3860.     }

  3862.     if (r->headers_in.upgrade) {
  3863.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3864.                       "client sent \"Upgrade\" header");
  3865.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3866.         goto failed;
  3867.     }

  3869.     if (r->headers_in.te
  3870.         && (r->headers_in.te->next
  3871.             || r->headers_in.te->value.len != 8
  3872.             || ngx_strncasecmp(r->headers_in.te->value.data,
  3873.                                (u_char *) "trailers", 8) != 0))
  3874.     {
  3875.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3876.                       "client sent invalid \"TE\" header");
  3877.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3878.         goto failed;
  3879.     }

  3881.     if (r->headers_in.server.len == 0) {
  3882.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3883.                       "client sent neither \":authority\" nor \"Host\" header");
  3884.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3885.         goto failed;
  3886.     }

  3888.     if (r->host_end) {

  3890.         host.len = r->host_end - r->host_start;
  3891.         host.data = r->host_start;

  3893.         if (r->headers_in.host) {
  3894.             if (r->headers_in.host->value.len != host.len
  3895.                 || ngx_memcmp(r->headers_in.host->value.data, host.data,
  3896.                               host.len)
  3897.                    != 0)
  3898.             {
  3899.                 ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3900.                               "client sent \":authority\" and \"Host\" headers "
  3901.                               "with different values");
  3902.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3903.                 goto failed;
  3904.             }

  3906.         } else {
  3907.             /* compatibility for $http_host */

  3909.             if (ngx_http_v2_construct_host_header(r) != NGX_OK) {
  3910.                 goto failed;
  3911.             }
  3912.         }
  3913.     }

  3915.     if (r->headers_in.content_length) {
  3916.         r->headers_in.content_length_n =
  3917.                             ngx_atoof(r->headers_in.content_length->value.data,
  3918.                                       r->headers_in.content_length->value.len);

  3920.         if (r->headers_in.content_length_n == NGX_ERROR) {
  3921.             ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3922.                           "client sent invalid \"Content-Length\" header");
  3923.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3924.             goto failed;
  3925.         }

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

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

  3933.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3934.             goto failed;
  3935.         }

  3937.     } else if (!r->stream->in_closed) {
  3938.         r->headers_in.chunked = 1;
  3939.     }

  3941.     if (r->method == NGX_HTTP_CONNECT) {
  3942.         ngx_log_error(NGX_LOG_INFO, fc->log, 0, "client sent CONNECT method");
  3943.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  3944.         goto failed;
  3945.     }

  3947.     if (r->method == NGX_HTTP_TRACE) {
  3948.         ngx_log_error(NGX_LOG_INFO, fc->log, 0, "client sent TRACE method");
  3949.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  3950.         goto failed;
  3951.     }

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

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

  3957.     ngx_http_process_request(r);

  3959. failed:

  3961.     ngx_http_run_posted_requests(fc);
  3962. }


  3965. ngx_int_t
  3966. ‌ngx_http_v2_read_request_body(ngx_http_request_t *r)
  3967. {
  3968.     off_t                      len;
  3969.     size_t                     size;
  3970.     ngx_buf_t                 *buf;
  3971.     ngx_int_t                  rc;
  3972.     ngx_http_v2_stream_t      *stream;
  3973.     ngx_http_v2_srv_conf_t    *h2scf;
  3974.     ngx_http_request_body_t   *rb;
  3975.     ngx_http_core_loc_conf_t  *clcf;
  3976.     ngx_http_v2_connection_t  *h2c;

  3978.     stream = r->stream;
  3979.     rb = r->request_body;

  3981.     if (stream->skip_data) {
  3982.         r->request_body_no_buffering = 0;
  3983.         rb->post_handler(r);
  3984.         return NGX_OK;
  3985.     }

  3987.     rb->rest = 1;

  3989.     /* set rb->filter_need_buffering */

  3991.     rc = ngx_http_top_request_body_filter(r, NULL);

  3993.     if (rc != NGX_OK) {
  3994.         stream->skip_data = 1;
  3995.         return rc;
  3996.     }

  3998.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);
  3999.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4001.     len = r->headers_in.content_length_n;

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

  4006.     } else {
  4007.         len++;
  4008.     }

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

  4012.         /*
  4013.          * We need a room to store data up to the stream's initial window size,
  4014.          * at least until this window will be exhausted.
  4015.          */

  4017.         if (len < (off_t) h2scf->preread_size) {
  4018.             len = h2scf->preread_size;
  4019.         }

  4021.         if (len > NGX_HTTP_V2_MAX_WINDOW) {
  4022.             len = NGX_HTTP_V2_MAX_WINDOW;
  4023.         }
  4024.     }

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

  4028.     if (rb->buf == NULL) {
  4029.         stream->skip_data = 1;
  4030.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4031.     }

  4033.     buf = stream->preread;

  4035.     if (stream->in_closed) {
  4036.         if (!rb->filter_need_buffering) {
  4037.             r->request_body_no_buffering = 0;
  4038.         }

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

  4045.         } else {
  4046.             rc = ngx_http_v2_process_request_body(r, NULL, 0, 1, 0);
  4047.         }

  4049.         if (rc != NGX_AGAIN) {
  4050.             return rc;
  4051.         }

  4053.         r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
  4054.         r->write_event_handler = ngx_http_request_empty_handler;

  4056.         return NGX_AGAIN;
  4057.     }

  4059.     if (buf) {
  4060.         rc = ngx_http_v2_process_request_body(r, buf->pos,
  4061.                                               buf->last - buf->pos, 0, 0);

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

  4065.         if (rc != NGX_OK && rc != NGX_AGAIN) {
  4066.             stream->skip_data = 1;
  4067.             return rc;
  4068.         }
  4069.     }

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

  4074.     } else {
  4075.         stream->no_flow_control = 1;
  4076.         size = NGX_HTTP_V2_MAX_WINDOW - stream->recv_window;
  4077.     }

  4079.     if (size) {
  4080.         if (ngx_http_v2_send_window_update(stream->connection,
  4081.                                            stream->node->id, size)
  4082.             == NGX_ERROR)
  4083.         {
  4084.             stream->skip_data = 1;
  4085.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4086.         }

  4088.         h2c = stream->connection;

  4090.         if (!h2c->blocked) {
  4091.             if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4092.                 stream->skip_data = 1;
  4093.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4094.             }
  4095.         }

  4097.         stream->recv_window += size;
  4098.     }

  4100.     if (!buf) {
  4101.         ngx_add_timer(r->connection->read, clcf->client_body_timeout);
  4102.     }

  4104.     r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
  4105.     r->write_event_handler = ngx_http_request_empty_handler;

  4107.     return NGX_AGAIN;
  4108. }


  4111. static ngx_int_t
  4112. ‌ngx_http_v2_process_request_body(ngx_http_request_t *r, u_char *pos,
  4113.     size_t size, ngx_uint_t last, ngx_uint_t flush)
  4114. {
  4115.     size_t                     n;
  4116.     ngx_int_t                  rc;
  4117.     ngx_connection_t          *fc;
  4118.     ngx_http_request_body_t   *rb;
  4119.     ngx_http_core_loc_conf_t  *clcf;

  4121.     fc = r->connection;
  4122.     rb = r->request_body;

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

  4127.     if (size == 0 && !last && !flush) {
  4128.         return NGX_AGAIN;
  4129.     }

  4131.     for ( ;; ) {
  4132.         for ( ;; ) {
  4133.             if (rb->buf->last == rb->buf->end && size) {

  4135.                 if (r->request_body_no_buffering) {

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

  4139.                     ngx_log_error(NGX_LOG_ALERT, fc->log, 0,
  4140.                                   "no space in http2 body buffer");

  4142.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4143.                 }

  4145.                 /* update chains */

  4147.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4148.                                "http2 body update chains");

  4150.                 rc = ngx_http_v2_filter_request_body(r);

  4152.                 if (rc != NGX_OK) {
  4153.                     return rc;
  4154.                 }

  4156.                 if (rb->busy != NULL) {
  4157.                     ngx_log_error(NGX_LOG_ALERT, fc->log, 0,
  4158.                                   "busy buffers after request body flush");
  4159.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4160.                 }

  4162.                 rb->buf->pos = rb->buf->start;
  4163.                 rb->buf->last = rb->buf->start;
  4164.             }

  4166.             /* copy body data to the buffer */

  4168.             n = rb->buf->end - rb->buf->last;

  4170.             if (n > size) {
  4171.                 n = size;
  4172.             }

  4174.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4175.                            "http2 request body recv %uz", n);

  4177.             if (n > 0) {
  4178.                 rb->buf->last = ngx_cpymem(rb->buf->last, pos, n);
  4179.                 pos += n;
  4180.                 size -= n;
  4181.             }

  4183.             if (size == 0 && last) {
  4184.                 rb->rest = 0;
  4185.             }

  4187.             if (size == 0) {
  4188.                 break;
  4189.             }
  4190.         }

  4192.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4193.                        "http2 request body rest %O", rb->rest);

  4195.         if (flush) {
  4196.             rc = ngx_http_v2_filter_request_body(r);

  4198.             if (rc != NGX_OK) {
  4199.                 return rc;
  4200.             }
  4201.         }

  4203.         if (rb->rest == 0 && rb->last_saved) {
  4204.             break;
  4205.         }

  4207.         if (size == 0) {
  4208.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  4209.             ngx_add_timer(fc->read, clcf->client_body_timeout);

  4211.             if (!flush) {
  4212.                 ngx_post_event(fc->read, &ngx_posted_events);
  4213.             }

  4215.             return NGX_AGAIN;
  4216.         }
  4217.     }

  4219.     if (fc->read->timer_set) {
  4220.         ngx_del_timer(fc->read);
  4221.     }

  4223.     if (r->request_body_no_buffering) {
  4224.         if (!flush) {
  4225.             ngx_post_event(fc->read, &ngx_posted_events);
  4226.         }

  4228.         return NGX_OK;
  4229.     }

  4231.     if (r->headers_in.chunked) {
  4232.         r->headers_in.content_length_n = rb->received;
  4233.     }

  4235.     r->read_event_handler = ngx_http_block_reading;
  4236.     rb->post_handler(r);

  4238.     return NGX_OK;
  4239. }


  4242. static ngx_int_t
  4243. ‌ngx_http_v2_filter_request_body(ngx_http_request_t *r)
  4244. {
  4245.     ngx_buf_t                 *b, *buf;
  4246.     ngx_int_t                  rc;
  4247.     ngx_chain_t               *cl;
  4248.     ngx_http_request_body_t   *rb;
  4249.     ngx_http_core_loc_conf_t  *clcf;

  4251.     rb = r->request_body;
  4252.     buf = rb->buf;

  4254.     if (buf->pos == buf->last && (rb->rest || rb->last_sent)) {
  4255.         cl = NULL;
  4256.         goto update;
  4257.     }

  4259.     cl = ngx_chain_get_free_buf(r->pool, &rb->free);
  4260.     if (cl == NULL) {
  4261.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4262.     }

  4264.     b = cl->buf;

  4266.     ngx_memzero(b, sizeof(ngx_buf_t));

  4268.     if (buf->pos != buf->last) {
  4269.         r->request_length += buf->last - buf->pos;
  4270.         rb->received += buf->last - buf->pos;

  4272.         if (r->headers_in.content_length_n != -1) {
  4273.             if (rb->received > r->headers_in.content_length_n) {
  4274.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  4275.                               "client intended to send body data "
  4276.                               "larger than declared");

  4278.                 return NGX_HTTP_BAD_REQUEST;
  4279.             }

  4281.         } else {
  4282.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4284.             if (clcf->client_max_body_size
  4285.                 && rb->received > clcf->client_max_body_size)
  4286.             {
  4287.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4288.                               "client intended to send too large chunked body: "
  4289.                               "%O bytes", rb->received);

  4291.                 return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  4292.             }
  4293.         }

  4295.         b->temporary = 1;
  4296.         b->pos = buf->pos;
  4297.         b->last = buf->last;
  4298.         b->start = b->pos;
  4299.         b->end = b->last;

  4301.         buf->pos = buf->last;
  4302.     }

  4304.     if (!rb->rest) {
  4305.         if (r->headers_in.content_length_n != -1
  4306.             && r->headers_in.content_length_n != rb->received)
  4307.         {
  4308.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  4309.                           "client prematurely closed stream: "
  4310.                           "only %O out of %O bytes of request body received",
  4311.                           rb->received, r->headers_in.content_length_n);

  4313.             return NGX_HTTP_BAD_REQUEST;
  4314.         }

  4316.         b->last_buf = 1;
  4317.         rb->last_sent = 1;
  4318.     }

  4320.     b->tag = (ngx_buf_tag_t) &ngx_http_v2_filter_request_body;
  4321.     b->flush = r->request_body_no_buffering;

  4323. update:

  4325.     rc = ngx_http_top_request_body_filter(r, cl);

  4327.     ngx_chain_update_chains(r->pool, &rb->free, &rb->busy, &cl,
  4328.                             (ngx_buf_tag_t) &ngx_http_v2_filter_request_body);

  4330.     return rc;
  4331. }


  4334. static void
  4335. ‌ngx_http_v2_read_client_request_body_handler(ngx_http_request_t *r)
  4336. {
  4337.     size_t                     window;
  4338.     ngx_buf_t                 *buf;
  4339.     ngx_int_t                  rc;
  4340.     ngx_connection_t          *fc;
  4341.     ngx_http_v2_stream_t      *stream;
  4342.     ngx_http_v2_connection_t  *h2c;

  4344.     fc = r->connection;

  4346.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4347.                    "http2 read client request body handler");

  4349.     if (fc->read->timedout) {
  4350.         ngx_log_error(NGX_LOG_INFO, fc->log, NGX_ETIMEDOUT, "client timed out");

  4352.         fc->timedout = 1;
  4353.         r->stream->skip_data = 1;

  4355.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  4356.         return;
  4357.     }

  4359.     if (fc->error) {
  4360.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4361.                       "client prematurely closed stream");

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

  4365.         ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  4366.         return;
  4367.     }

  4369.     rc = ngx_http_v2_process_request_body(r, NULL, 0, r->stream->in_closed, 1);

  4371.     if (rc != NGX_OK && rc != NGX_AGAIN) {
  4372.         r->stream->skip_data = 1;
  4373.         ngx_http_finalize_request(r, rc);
  4374.         return;
  4375.     }

  4377.     if (rc == NGX_OK) {
  4378.         return;
  4379.     }

  4381.     if (r->stream->no_flow_control) {
  4382.         return;
  4383.     }

  4385.     if (r->request_body->rest == 0) {
  4386.         return;
  4387.     }

  4389.     if (r->request_body->busy != NULL) {
  4390.         return;
  4391.     }

  4393.     stream = r->stream;
  4394.     h2c = stream->connection;

  4396.     buf = r->request_body->buf;

  4398.     buf->pos = buf->start;
  4399.     buf->last = buf->start;

  4401.     window = buf->end - buf->start;

  4403.     if (h2c->state.stream == stream) {
  4404.         window -= h2c->state.length;
  4405.     }

  4407.     if (window <= stream->recv_window) {
  4408.         if (window < stream->recv_window) {
  4409.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  4410.                           "http2 negative window update");

  4412.             stream->skip_data = 1;

  4414.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4415.             return;
  4416.         }

  4418.         return;
  4419.     }

  4421.     if (ngx_http_v2_send_window_update(h2c, stream->node->id,
  4422.                                        window - stream->recv_window)
  4423.         == NGX_ERROR)
  4424.     {
  4425.         stream->skip_data = 1;
  4426.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4427.         return;
  4428.     }

  4430.     stream->recv_window = window;

  4432.     if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4433.         stream->skip_data = 1;
  4434.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4435.         return;
  4436.     }
  4437. }


  4440. ngx_int_t
  4441. ‌ngx_http_v2_read_unbuffered_request_body(ngx_http_request_t *r)
  4442. {
  4443.     size_t                     window;
  4444.     ngx_buf_t                 *buf;
  4445.     ngx_int_t                  rc;
  4446.     ngx_connection_t          *fc;
  4447.     ngx_http_v2_stream_t      *stream;
  4448.     ngx_http_v2_connection_t  *h2c;

  4450.     stream = r->stream;
  4451.     fc = r->connection;

  4453.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4454.                    "http2 read unbuffered request body");

  4456.     if (fc->read->timedout) {
  4457.         if (stream->recv_window) {
  4458.             stream->skip_data = 1;
  4459.             fc->timedout = 1;

  4461.             return NGX_HTTP_REQUEST_TIME_OUT;
  4462.         }

  4464.         fc->read->timedout = 0;
  4465.     }

  4467.     if (fc->error) {
  4468.         stream->skip_data = 1;
  4469.         return NGX_HTTP_BAD_REQUEST;
  4470.     }

  4472.     rc = ngx_http_v2_process_request_body(r, NULL, 0, r->stream->in_closed, 1);

  4474.     if (rc != NGX_OK && rc != NGX_AGAIN) {
  4475.         stream->skip_data = 1;
  4476.         return rc;
  4477.     }

  4479.     if (rc == NGX_OK) {
  4480.         return NGX_OK;
  4481.     }

  4483.     if (r->request_body->rest == 0) {
  4484.         return NGX_AGAIN;
  4485.     }

  4487.     if (r->request_body->busy != NULL) {
  4488.         return NGX_AGAIN;
  4489.     }

  4491.     buf = r->request_body->buf;

  4493.     buf->pos = buf->start;
  4494.     buf->last = buf->start;

  4496.     window = buf->end - buf->start;
  4497.     h2c = stream->connection;

  4499.     if (h2c->state.stream == stream) {
  4500.         window -= h2c->state.length;
  4501.     }

  4503.     if (window <= stream->recv_window) {
  4504.         if (window < stream->recv_window) {
  4505.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  4506.                           "http2 negative window update");
  4507.             stream->skip_data = 1;
  4508.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4509.         }

  4511.         return NGX_AGAIN;
  4512.     }

  4514.     if (ngx_http_v2_send_window_update(h2c, stream->node->id,
  4515.                                        window - stream->recv_window)
  4516.         == NGX_ERROR)
  4517.     {
  4518.         stream->skip_data = 1;
  4519.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4520.     }

  4522.     if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4523.         stream->skip_data = 1;
  4524.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4525.     }

  4527.     stream->recv_window = window;

  4529.     return NGX_AGAIN;
  4530. }


  4533. static ngx_int_t
  4534. ‌ngx_http_v2_terminate_stream(ngx_http_v2_connection_t *h2c,
  4535.     ngx_http_v2_stream_t *stream, ngx_uint_t status)
  4536. {
  4537.     ngx_event_t       *rev;
  4538.     ngx_connection_t  *fc;

  4540.     if (stream->rst_sent) {
  4541.         return NGX_OK;
  4542.     }

  4544.     if (ngx_http_v2_send_rst_stream(h2c, stream->node->id, status)
  4545.         == NGX_ERROR)
  4546.     {
  4547.         return NGX_ERROR;
  4548.     }

  4550.     stream->rst_sent = 1;
  4551.     stream->skip_data = 1;

  4553.     fc = stream->request->connection;
  4554.     fc->error = 1;

  4556.     rev = fc->read;
  4557.     rev->handler(rev);

  4559.     return NGX_OK;
  4560. }


  4563. void
  4564. ‌ngx_http_v2_close_stream(ngx_http_v2_stream_t *stream, ngx_int_t rc)
  4565. {
  4566.     ngx_pool_t                *pool;
  4567.     ngx_event_t               *ev;
  4568.     ngx_connection_t          *fc;
  4569.     ngx_http_v2_node_t        *node;
  4570.     ngx_http_v2_connection_t  *h2c;

  4572.     h2c = stream->connection;
  4573.     node = stream->node;

  4575.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  4576.                    "http2 close stream %ui, queued %ui, processing %ui",
  4577.                    node->id, stream->queued, h2c->processing);

  4579.     fc = stream->request->connection;

  4581.     if (stream->queued) {
  4582.         fc->error = 1;
  4583.         fc->write->handler = ngx_http_v2_retry_close_stream_handler;
  4584.         fc->read->handler = ngx_http_v2_retry_close_stream_handler;
  4585.         return;
  4586.     }

  4588.     if (!stream->rst_sent && !h2c->connection->error) {

  4590.         if (!stream->out_closed) {
  4591.             if (ngx_http_v2_send_rst_stream(h2c, node->id,
  4592.                                       fc->timedout ? NGX_HTTP_V2_PROTOCOL_ERROR
  4593.                                                    : NGX_HTTP_V2_INTERNAL_ERROR)
  4594.                 != NGX_OK)
  4595.             {
  4596.                 h2c->connection->error = 1;
  4597.             }

  4599.         } else if (!stream->in_closed) {
  4600.             if (ngx_http_v2_send_rst_stream(h2c, node->id, NGX_HTTP_V2_NO_ERROR)
  4601.                 != NGX_OK)
  4602.             {
  4603.                 h2c->connection->error = 1;
  4604.             }
  4605.         }
  4606.     }

  4608.     if (h2c->state.stream == stream) {
  4609.         h2c->state.stream = NULL;
  4610.     }

  4612.     node->stream = NULL;

  4614.     ngx_queue_insert_tail(&h2c->closed, &node->reuse);
  4615.     h2c->closed_nodes++;

  4617.     /*
  4618.      * This pool keeps decoded request headers which can be used by log phase
  4619.      * handlers in ngx_http_free_request().
  4620.      *
  4621.      * The pointer is stored into local variable because the stream object
  4622.      * will be destroyed after a call to ngx_http_free_request().
  4623.      */
  4624.     pool = stream->pool;

  4626.     h2c->frames -= stream->frames;

  4628.     ngx_http_free_request(stream->request, rc);

  4630.     if (pool != h2c->state.pool) {
  4631.         ngx_destroy_pool(pool);

  4633.     } else {
  4634.         /* pool will be destroyed when the complete header is parsed */
  4635.         h2c->state.keep_pool = 0;
  4636.     }

  4638.     ev = fc->read;

  4640.     if (ev->timer_set) {
  4641.         ngx_del_timer(ev);
  4642.     }

  4644.     if (ev->posted) {
  4645.         ngx_delete_posted_event(ev);
  4646.     }

  4648.     ev = fc->write;

  4650.     if (ev->timer_set) {
  4651.         ngx_del_timer(ev);
  4652.     }

  4654.     if (ev->posted) {
  4655.         ngx_delete_posted_event(ev);
  4656.     }

  4658.     fc->data = h2c->free_fake_connections;
  4659.     h2c->free_fake_connections = fc;

  4661.     h2c->processing--;

  4663.     if (h2c->processing || h2c->blocked) {
  4664.         return;
  4665.     }

  4667.     ev = h2c->connection->read;

  4669.     ev->handler = ngx_http_v2_handle_connection_handler;
  4670.     ngx_post_event(ev, &ngx_posted_events);
  4671. }


  4674. static void
  4675. ‌ngx_http_v2_close_stream_handler(ngx_event_t *ev)
  4676. {
  4677.     ngx_connection_t    *fc;
  4678.     ngx_http_request_t  *r;

  4680.     fc = ev->data;
  4681.     r = fc->data;

  4683.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4684.                    "http2 close stream handler");

  4686.     if (ev->timedout) {
  4687.         ngx_log_error(NGX_LOG_INFO, fc->log, NGX_ETIMEDOUT, "client timed out");

  4689.         fc->timedout = 1;

  4691.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_REQUEST_TIME_OUT);
  4692.         return;
  4693.     }

  4695.     ngx_http_v2_close_stream(r->stream, 0);
  4696. }


  4699. static void
  4700. ‌ngx_http_v2_retry_close_stream_handler(ngx_event_t *ev)
  4701. {
  4702.     ngx_connection_t    *fc;
  4703.     ngx_http_request_t  *r;

  4705.     fc = ev->data;
  4706.     r = fc->data;

  4708.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, fc->log, 0,
  4709.                    "http2 retry close stream handler");

  4711.     ngx_http_v2_close_stream(r->stream, 0);
  4712. }


  4715. static void
  4716. ‌ngx_http_v2_handle_connection_handler(ngx_event_t *rev)
  4717. {
  4718.     ngx_connection_t          *c;
  4719.     ngx_http_v2_connection_t  *h2c;

  4721.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0,
  4722.                    "http2 handle connection handler");

  4724.     c = rev->data;
  4725.     h2c = c->data;

  4727.     if (c->error) {
  4728.         ngx_http_v2_finalize_connection(h2c, 0);
  4729.         return;
  4730.     }

  4732.     rev->handler = ngx_http_v2_read_handler;

  4734.     if (rev->ready) {
  4735.         ngx_http_v2_read_handler(rev);
  4736.         return;
  4737.     }

  4739.     if (h2c->last_out && ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4740.         ngx_http_v2_finalize_connection(h2c, 0);
  4741.         return;
  4742.     }

  4744.     ngx_http_v2_handle_connection(c->data);
  4745. }


  4748. static void
  4749. ‌ngx_http_v2_idle_handler(ngx_event_t *rev)
  4750. {
  4751.     ngx_connection_t          *c;
  4752.     ngx_http_v2_srv_conf_t    *h2scf;
  4753.     ngx_http_v2_connection_t  *h2c;
  4754.     ngx_http_core_loc_conf_t  *clcf;

  4756.     c = rev->data;
  4757.     h2c = c->data;

  4759.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http2 idle handler");

  4761.     if (rev->timedout || c->close) {
  4762.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  4763.         return;
  4764.     }

  4766. #if (NGX_HAVE_KQUEUE)

  4768.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  4769.         if (rev->pending_eof) {
  4770.             c->log->handler = NULL;
  4771.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  4772.                           "kevent() reported that client %V closed "
  4773.                           "idle connection", &c->addr_text);
  4774. #if (NGX_HTTP_SSL)
  4775.             if (c->ssl) {
  4776.                 c->ssl->no_send_shutdown = 1;
  4777.             }
  4778. #endif
  4779.             ngx_http_close_connection(c);
  4780.             return;
  4781.         }
  4782.     }

  4784. #endif

  4786.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  4787.                                         ngx_http_core_module);

  4789.     if (h2c->idle++ > 10 * clcf->keepalive_requests) {
  4790.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  4791.                       "http2 flood detected");
  4792.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  4793.         return;
  4794.     }

  4796.     c->destroyed = 0;
  4797.     ngx_reusable_connection(c, 0);

  4799.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4800.                                          ngx_http_v2_module);

  4802.     h2c->pool = ngx_create_pool(h2scf->pool_size, h2c->connection->log);
  4803.     if (h2c->pool == NULL) {
  4804.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  4805.         return;
  4806.     }

  4808.     c->write->handler = ngx_http_v2_write_handler;

  4810.     rev->handler = ngx_http_v2_read_handler;
  4811.     ngx_http_v2_read_handler(rev);
  4812. }


  4815. static void
  4816. ‌ngx_http_v2_finalize_connection(ngx_http_v2_connection_t *h2c,
  4817.     ngx_uint_t status)
  4818. {
  4819.     ngx_uint_t               i, size;
  4820.     ngx_event_t             *ev;
  4821.     ngx_connection_t        *c, *fc;
  4822.     ngx_http_request_t      *r;
  4823.     ngx_http_v2_node_t      *node;
  4824.     ngx_http_v2_stream_t    *stream;
  4825.     ngx_http_v2_srv_conf_t  *h2scf;

  4827.     c = h2c->connection;

  4829.     h2c->blocked = 1;

  4831.     if (!c->error && !h2c->goaway) {
  4832.         h2c->goaway = 1;

  4834.         if (ngx_http_v2_send_goaway(h2c, status) != NGX_ERROR) {
  4835.             (void) ngx_http_v2_send_output_queue(h2c);
  4836.         }
  4837.     }

  4839.     if (!h2c->processing) {
  4840.         goto done;
  4841.     }

  4843.     c->read->handler = ngx_http_empty_handler;
  4844.     c->write->handler = ngx_http_empty_handler;

  4846.     h2c->last_out = NULL;

  4848.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4849.                                          ngx_http_v2_module);

  4851.     size = ngx_http_v2_index_size(h2scf);

  4853.     for (i = 0; i < size; i++) {

  4855.         for (node = h2c->streams_index[i]; node; node = node->index) {
  4856.             stream = node->stream;

  4858.             if (stream == NULL) {
  4859.                 continue;
  4860.             }

  4862.             stream->waiting = 0;

  4864.             r = stream->request;
  4865.             fc = r->connection;

  4867.             fc->error = 1;

  4869.             if (stream->queued) {
  4870.                 stream->queued = 0;

  4872.                 ev = fc->write;
  4873.                 ev->active = 0;
  4874.                 ev->ready = 1;

  4876.             } else {
  4877.                 ev = fc->read;
  4878.             }

  4880.             ev->eof = 1;
  4881.             ev->handler(ev);
  4882.         }
  4883.     }

  4885.     h2c->blocked = 0;

  4887.     if (h2c->processing) {
  4888.         c->error = 1;
  4889.         return;
  4890.     }

  4892. done:

  4894.     if (c->error) {
  4895.         ngx_http_close_connection(c);
  4896.         return;
  4897.     }

  4899.     ngx_http_v2_lingering_close(c);
  4900. }


  4903. static ngx_int_t
  4904. ‌ngx_http_v2_adjust_windows(ngx_http_v2_connection_t *h2c, ssize_t delta)
  4905. {
  4906.     ngx_uint_t               i, size;
  4907.     ngx_event_t             *wev;
  4908.     ngx_http_v2_node_t      *node;
  4909.     ngx_http_v2_stream_t    *stream;
  4910.     ngx_http_v2_srv_conf_t  *h2scf;

  4912.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4913.                                          ngx_http_v2_module);

  4915.     size = ngx_http_v2_index_size(h2scf);

  4917.     for (i = 0; i < size; i++) {

  4919.         for (node = h2c->streams_index[i]; node; node = node->index) {
  4920.             stream = node->stream;

  4922.             if (stream == NULL) {
  4923.                 continue;
  4924.             }

  4926.             if (delta > 0
  4927.                 && stream->send_window
  4928.                       > (ssize_t) (NGX_HTTP_V2_MAX_WINDOW - delta))
  4929.             {
  4930.                 if (ngx_http_v2_terminate_stream(h2c, stream,
  4931.                                                  NGX_HTTP_V2_FLOW_CTRL_ERROR)
  4932.                     == NGX_ERROR)
  4933.                 {
  4934.                     return NGX_ERROR;
  4935.                 }

  4937.                 continue;
  4938.             }

  4940.             stream->send_window += delta;

  4942.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  4943.                            "http2:%ui adjusted window: %z",
  4944.                            node->id, stream->send_window);

  4946.             if (stream->send_window > 0 && stream->exhausted) {
  4947.                 stream->exhausted = 0;

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

  4951.                 wev->active = 0;
  4952.                 wev->ready = 1;

  4954.                 if (!wev->delayed) {
  4955.                     wev->handler(wev);
  4956.                 }
  4957.             }
  4958.         }
  4959.     }

  4961.     return NGX_OK;
  4962. }


  4965. static void
  4966. ‌ngx_http_v2_set_dependency(ngx_http_v2_connection_t *h2c,
  4967.     ngx_http_v2_node_t *node, ngx_uint_t depend, ngx_uint_t exclusive)
  4968. {
  4969.     ngx_queue_t         *children, *q;
  4970.     ngx_http_v2_node_t  *parent, *child, *next;

  4972.     parent = depend ? ngx_http_v2_get_node_by_id(h2c, depend, 0) : NULL;

  4974.     if (parent == NULL) {
  4975.         parent = NGX_HTTP_V2_ROOT;

  4977.         if (depend != 0) {
  4978.             exclusive = 0;
  4979.         }

  4981.         node->rank = 1;
  4982.         node->rel_weight = (1.0 / 256) * node->weight;

  4984.         children = &h2c->dependencies;

  4986.     } else {
  4987.         if (node->parent != NULL) {

  4989.             for (next = parent->parent;
  4990.                  next != NGX_HTTP_V2_ROOT && next->rank >= node->rank;
  4991.                  next = next->parent)
  4992.             {
  4993.                 if (next != node) {
  4994.                     continue;
  4995.                 }

  4997.                 ngx_queue_remove(&parent->queue);
  4998.                 ngx_queue_insert_after(&node->queue, &parent->queue);

  5000.                 parent->parent = node->parent;

  5002.                 if (node->parent == NGX_HTTP_V2_ROOT) {
  5003.                     parent->rank = 1;
  5004.                     parent->rel_weight = (1.0 / 256) * parent->weight;

  5006.                 } else {
  5007.                     parent->rank = node->parent->rank + 1;
  5008.                     parent->rel_weight = (node->parent->rel_weight / 256)
  5009.                                          * parent->weight;
  5010.                 }

  5012.                 if (!exclusive) {
  5013.                     ngx_http_v2_node_children_update(parent);
  5014.                 }

  5016.                 break;
  5017.             }
  5018.         }

  5020.         node->rank = parent->rank + 1;
  5021.         node->rel_weight = (parent->rel_weight / 256) * node->weight;

  5023.         if (parent->stream == NULL) {
  5024.             ngx_queue_remove(&parent->reuse);
  5025.             ngx_queue_insert_tail(&h2c->closed, &parent->reuse);
  5026.         }

  5028.         children = &parent->children;
  5029.     }

  5031.     if (exclusive) {
  5032.         for (q = ngx_queue_head(children);
  5033.              q != ngx_queue_sentinel(children);
  5034.              q = ngx_queue_next(q))
  5035.         {
  5036.             child = ngx_queue_data(q, ngx_http_v2_node_t, queue);
  5037.             child->parent = node;
  5038.         }

  5040.         ngx_queue_add(&node->children, children);
  5041.         ngx_queue_init(children);
  5042.     }

  5044.     if (node->parent != NULL) {
  5045.         ngx_queue_remove(&node->queue);
  5046.     }

  5048.     ngx_queue_insert_tail(children, &node->queue);

  5050.     node->parent = parent;

  5052.     ngx_http_v2_node_children_update(node);
  5053. }


  5056. static void
  5057. ‌ngx_http_v2_node_children_update(ngx_http_v2_node_t *node)
  5058. {
  5059.     ngx_queue_t         *q;
  5060.     ngx_http_v2_node_t  *child;

  5062.     for (q = ngx_queue_head(&node->children);
  5063.          q != ngx_queue_sentinel(&node->children);
  5064.          q = ngx_queue_next(q))
  5065.     {
  5066.         child = ngx_queue_data(q, ngx_http_v2_node_t, queue);

  5068.         child->rank = node->rank + 1;
  5069.         child->rel_weight = (node->rel_weight / 256) * child->weight;

  5071.         ngx_http_v2_node_children_update(child);
  5072.     }
  5073. }


  5076. static void
  5077. ‌ngx_http_v2_pool_cleanup(void *data)
  5078. {
  5079.     ngx_http_v2_connection_t  *h2c = data;

  5081.     if (h2c->state.pool) {
  5082.         ngx_destroy_pool(h2c->state.pool);
  5083.     }

  5085.     if (h2c->pool) {
  5086.         ngx_destroy_pool(h2c->pool);
  5087.     }
  5088. }

One Level Up Top Level