One Level Up Top Level

src/http/v2/ngx_http_v2.c - nginx source code

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 void ngx_http_v2_run_request(ngx_http_request_t *r);
  162. static ngx_int_t ngx_http_v2_process_request_body(ngx_http_request_t *r,
  163.     u_char *pos, size_t size, ngx_uint_t last, ngx_uint_t flush);
  164. static ngx_int_t ngx_http_v2_filter_request_body(ngx_http_request_t *r);
  165. static void ngx_http_v2_read_client_request_body_handler(ngx_http_request_t *r);

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

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

  182. static void ngx_http_v2_pool_cleanup(void *data);


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

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


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

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

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

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

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

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

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

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

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

  244.     h2c->init_window = NGX_HTTP_V2_DEFAULT_WINDOW;

  246.     h2c->frame_size = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;

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

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

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

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

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

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

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

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

  287.     h2c->state.handler = ngx_http_v2_state_preface;

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

  293.     c->data = h2c;

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

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

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

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

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

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

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

  323.         } while (p != end);

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

  329.     ngx_http_v2_read_handler(rev);
  330. }


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

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

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

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

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

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

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

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

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

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

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

  386.         h2c->blocked = 0;

  388.         return;
  389.     }

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

  394.     available = h2mcf->recv_buffer_size - NGX_HTTP_V2_STATE_BUFFER_SIZE;

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

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

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

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

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

  417.         end += n;

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

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

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

  429.         } while (p != end);

  431.         h2c->total_bytes += n;

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

  439.     } while (rev->ready);

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

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

  451.     h2c->blocked = 0;

  453.     ngx_http_v2_handle_connection(h2c);
  454. }


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

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

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

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

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

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

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

  488.     h2c->blocked = 1;

  490.     rc = ngx_http_v2_send_output_queue(h2c);

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

  497.     h2c->blocked = 0;

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

  503.     ngx_http_v2_handle_connection(h2c);
  504. }


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

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

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

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

  528.     cl = NULL;
  529.     out = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  589.     frame = NULL;

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

  597.     h2c->last_out = frame;

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

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

  608.     return NGX_OK;

  610. error:

  612.     c->error = 1;

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

  618.     return NGX_ERROR;
  619. }


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

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

  633.     c = h2c->connection;

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

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

  643.         rc = ngx_http_v2_send_output_queue(h2c);

  645.         h2c->blocked = 0;

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

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

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

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

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

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

  671.     ngx_reusable_connection(c, 1);

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

  677.     ngx_destroy_pool(h2c->pool);

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

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

  690.     c->destroyed = 1;

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

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


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

  708.     h2c = c->data;

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

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

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

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

  727.         rc = ngx_ssl_shutdown(c);

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

  818.     } while (rev->ready);

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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


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

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

  893.     head = ngx_http_v2_parse_uint32(pos);

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

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

  900.     pos += NGX_HTTP_V2_FRAME_HEADER_SIZE;

  902.     type = ngx_http_v2_parse_type(head);

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

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

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


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

  925.     size = h2c->state.length;

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

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

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

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

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

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

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

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

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

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

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

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

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

  976.     h2c->recv_window -= size;

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

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

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

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

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

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

  1000.     stream = node->stream;

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

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

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

  1019.     stream->recv_window -= size;

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

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

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

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

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

  1052.     h2c->state.stream = stream;

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


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

  1070.     stream = h2c->state.stream;

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

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

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

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

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

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

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

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

  1100.     size = end - pos;

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

  1107.     h2c->payload_bytes += size;

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

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

  1118.         ngx_http_run_posted_requests(fc);

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

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

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

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

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

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

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

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

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

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


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

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

  1178.     size = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1327.     h2c->state.stream = stream;

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

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

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

  1337.     node->stream = stream;

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

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

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

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

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

  1362. rst_stream:

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

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

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


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

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

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

  1398.     size_update = 0;
  1399.     indexed = 0;

  1401.     ch = *pos;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1472.     h2c->state.parse_value = 1;

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1542.     h2c->state.field_rest = len;

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

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

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

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

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

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


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

  1571.     size = end - pos;

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

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

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

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

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

  1596.     pos += size;

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

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

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

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

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


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

  1626.     size = end - pos;

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

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

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

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

  1641.     pos += size;

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

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

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

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

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


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

  1671.     size = end - pos;

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

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

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

  1684.     pos += size;

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1824.     } else {
  1825.         h = ngx_list_push(&r->headers_in.headers);
  1826.         if (h == NULL) {
  1827.             return ngx_http_v2_connection_error(h2c,
  1828.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1829.         }

  1831.         h->key.len = header->name.len;
  1832.         h->key.data = header->name.data;

  1834.         /*
  1835.          * TODO Optimization: precalculate hash
  1836.          * and handler for indexed headers.
  1837.          */
  1838.         h->hash = ngx_hash_key(h->key.data, h->key.len);

  1840.         h->value.len = header->value.len;
  1841.         h->value.data = header->value.data;

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

  1845.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  1850.         if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1851.             goto error;
  1852.         }
  1853.     }

  1855.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1856.                    "http2 header: \"%V: %V\"",
  1857.                    &header->name, &header->value);

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

  1861. error:

  1863.     h2c->state.stream = NULL;

  1865.     ngx_http_run_posted_requests(fc);

  1867.     return ngx_http_v2_state_header_complete(h2c, pos, end);
  1868. }


  1871. static u_char *
  1872. ‌ngx_http_v2_state_header_complete(ngx_http_v2_connection_t *h2c, u_char *pos,
  1873.     u_char *end)
  1874. {
  1875.     ngx_http_v2_stream_t  *stream;

  1877.     if (h2c->state.length) {
  1878.         if (end - pos > 0) {
  1879.             h2c->state.handler = ngx_http_v2_state_header_block;
  1880.             return pos;
  1881.         }

  1883.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1884.                                               ngx_http_v2_state_header_block);
  1885.     }

  1887.     if (!(h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG)) {
  1888.         return ngx_http_v2_handle_continuation(h2c, pos, end,
  1889.                                              ngx_http_v2_state_header_complete);
  1890.     }

  1892.     stream = h2c->state.stream;

  1894.     if (stream) {
  1895.         ngx_http_v2_run_request(stream->request);
  1896.     }

  1898.     if (!h2c->state.keep_pool) {
  1899.         ngx_destroy_pool(h2c->state.pool);
  1900.     }

  1902.     h2c->state.pool = NULL;
  1903.     h2c->state.keep_pool = 0;

  1905.     if (h2c->state.padding) {
  1906.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1907.     }

  1909.     return ngx_http_v2_state_complete(h2c, pos, end);
  1910. }


  1913. static u_char *
  1914. ‌ngx_http_v2_handle_continuation(ngx_http_v2_connection_t *h2c, u_char *pos,
  1915.     u_char *end, ngx_http_v2_handler_pt handler)
  1916. {
  1917.     u_char    *p;
  1918.     size_t     len, skip;
  1919.     uint32_t   head;

  1921.     len = h2c->state.length;

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

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

  1928.         p = pos;
  1929.         pos += skip;
  1930.         ngx_memmove(pos, p, len);
  1931.     }

  1933.     if ((size_t) (end - pos) < len + NGX_HTTP_V2_FRAME_HEADER_SIZE) {
  1934.         return ngx_http_v2_state_headers_save(h2c, pos, end, handler);
  1935.     }

  1937.     p = pos + len;

  1939.     head = ngx_http_v2_parse_uint32(p);

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

  1945.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1946.     }

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

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

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

  1957.     p = pos;
  1958.     pos += NGX_HTTP_V2_FRAME_HEADER_SIZE;

  1960.     ngx_memcpy(pos, p, len);

  1962.     len = ngx_http_v2_parse_length(head);

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

  1966.     if (h2c->state.stream) {
  1967.         h2c->state.stream->request->request_length += len;
  1968.     }

  1970.     h2c->state.handler = handler;
  1971.     return pos;
  1972. }


  1975. static u_char *
  1976. ‌ngx_http_v2_state_priority(ngx_http_v2_connection_t *h2c, u_char *pos,
  1977.     u_char *end)
  1978. {
  1979.     ngx_uint_t           depend, dependency, excl, weight;
  1980.     ngx_http_v2_node_t  *node;

  1982.     if (h2c->state.length != NGX_HTTP_V2_PRIORITY_SIZE) {
  1983.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1984.                       "client sent PRIORITY frame with incorrect length %uz",
  1985.                       h2c->state.length);

  1987.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1988.     }

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

  1994.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_ENHANCE_YOUR_CALM);
  1995.     }

  1997.     if (end - pos < NGX_HTTP_V2_PRIORITY_SIZE) {
  1998.         return ngx_http_v2_state_save(h2c, pos, end,
  1999.                                       ngx_http_v2_state_priority);
  2000.     }

  2002.     dependency = ngx_http_v2_parse_uint32(pos);

  2004.     depend = dependency & 0x7fffffff;
  2005.     excl = dependency >> 31;
  2006.     weight = pos[4] + 1;

  2008.     pos += NGX_HTTP_V2_PRIORITY_SIZE;

  2010.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2011.                    "http2 PRIORITY frame sid:%ui "
  2012.                    "depends on %ui excl:%ui weight:%ui",
  2013.                    h2c->state.sid, depend, excl, weight);

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

  2019.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2020.     }

  2022.     if (depend == h2c->state.sid) {
  2023.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2024.                       "client sent PRIORITY frame for stream %ui "
  2025.                       "with incorrect dependency", h2c->state.sid);

  2027.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2028.     }

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

  2032.     if (node == NULL) {
  2033.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2034.     }

  2036.     node->weight = weight;

  2038.     if (node->stream == NULL) {
  2039.         if (node->parent == NULL) {
  2040.             h2c->closed_nodes++;

  2042.         } else {
  2043.             ngx_queue_remove(&node->reuse);
  2044.         }

  2046.         ngx_queue_insert_tail(&h2c->closed, &node->reuse);
  2047.     }

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

  2051.     return ngx_http_v2_state_complete(h2c, pos, end);
  2052. }


  2055. static u_char *
  2056. ‌ngx_http_v2_state_rst_stream(ngx_http_v2_connection_t *h2c, u_char *pos,
  2057.     u_char *end)
  2058. {
  2059.     ngx_uint_t             status;
  2060.     ngx_event_t           *ev;
  2061.     ngx_connection_t      *fc;
  2062.     ngx_http_v2_node_t    *node;
  2063.     ngx_http_v2_stream_t  *stream;

  2065.     if (h2c->state.length != NGX_HTTP_V2_RST_STREAM_SIZE) {
  2066.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2067.                       "client sent RST_STREAM frame with incorrect length %uz",
  2068.                       h2c->state.length);

  2070.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2071.     }

  2073.     if (end - pos < NGX_HTTP_V2_RST_STREAM_SIZE) {
  2074.         return ngx_http_v2_state_save(h2c, pos, end,
  2075.                                       ngx_http_v2_state_rst_stream);
  2076.     }

  2078.     status = ngx_http_v2_parse_uint32(pos);

  2080.     pos += NGX_HTTP_V2_RST_STREAM_SIZE;

  2082.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2083.                    "http2 RST_STREAM frame, sid:%ui status:%ui",
  2084.                    h2c->state.sid, status);

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

  2090.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2091.     }

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

  2095.     if (node == NULL || node->stream == NULL) {
  2096.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2097.                        "unknown http2 stream");

  2099.         return ngx_http_v2_state_complete(h2c, pos, end);
  2100.     }

  2102.     stream = node->stream;

  2104.     stream->in_closed = 1;
  2105.     stream->out_closed = 1;

  2107.     fc = stream->request->connection;
  2108.     fc->error = 1;

  2110.     switch (status) {

  2112.     case NGX_HTTP_V2_CANCEL:
  2113.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2114.                       "client canceled stream %ui", h2c->state.sid);
  2115.         break;

  2117.     case NGX_HTTP_V2_INTERNAL_ERROR:
  2118.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2119.                       "client terminated stream %ui due to internal error",
  2120.                       h2c->state.sid);
  2121.         break;

  2123.     default:
  2124.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2125.                       "client terminated stream %ui with status %ui",
  2126.                       h2c->state.sid, status);
  2127.         break;
  2128.     }

  2130.     ev = fc->read;
  2131.     ev->handler(ev);

  2133.     return ngx_http_v2_state_complete(h2c, pos, end);
  2134. }


  2137. static u_char *
  2138. ‌ngx_http_v2_state_settings(ngx_http_v2_connection_t *h2c, u_char *pos,
  2139.     u_char *end)
  2140. {
  2141.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2142.                    "http2 SETTINGS frame");

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

  2148.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2149.     }

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

  2153.         if (h2c->state.length != 0) {
  2154.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2155.                           "client sent SETTINGS frame with the ACK flag "
  2156.                           "and nonzero length");

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

  2161.         h2c->settings_ack = 1;

  2163.         return ngx_http_v2_state_complete(h2c, pos, end);
  2164.     }

  2166.     if (h2c->state.length % NGX_HTTP_V2_SETTINGS_PARAM_SIZE) {
  2167.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2168.                       "client sent SETTINGS frame with incorrect length %uz",
  2169.                       h2c->state.length);

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

  2174.     return ngx_http_v2_state_settings_params(h2c, pos, end);
  2175. }


  2178. static u_char *
  2179. ‌ngx_http_v2_state_settings_params(ngx_http_v2_connection_t *h2c, u_char *pos,
  2180.     u_char *end)
  2181. {
  2182.     ssize_t                   window_delta;
  2183.     ngx_uint_t                id, value;
  2184.     ngx_http_v2_out_frame_t  *frame;

  2186.     window_delta = 0;

  2188.     while (h2c->state.length) {
  2189.         if (end - pos < NGX_HTTP_V2_SETTINGS_PARAM_SIZE) {
  2190.             return ngx_http_v2_state_save(h2c, pos, end,
  2191.                                           ngx_http_v2_state_settings_params);
  2192.         }

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

  2196.         id = ngx_http_v2_parse_uint16(pos);
  2197.         value = ngx_http_v2_parse_uint32(&pos[2]);

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

  2202.         switch (id) {

  2204.         case NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING:

  2206.             if (value > NGX_HTTP_V2_MAX_WINDOW) {
  2207.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2208.                               "client sent SETTINGS frame with incorrect "
  2209.                               "INITIAL_WINDOW_SIZE value %ui", value);

  2211.                 return ngx_http_v2_connection_error(h2c,
  2212.                                                   NGX_HTTP_V2_FLOW_CTRL_ERROR);
  2213.             }

  2215.             window_delta = value - h2c->init_window;
  2216.             break;

  2218.         case NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING:

  2220.             if (value > NGX_HTTP_V2_MAX_FRAME_SIZE
  2221.                 || value < NGX_HTTP_V2_DEFAULT_FRAME_SIZE)
  2222.             {
  2223.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2224.                               "client sent SETTINGS frame with incorrect "
  2225.                               "MAX_FRAME_SIZE value %ui", value);

  2227.                 return ngx_http_v2_connection_error(h2c,
  2228.                                                     NGX_HTTP_V2_PROTOCOL_ERROR);
  2229.             }

  2231.             h2c->frame_size = value;
  2232.             break;

  2234.         case NGX_HTTP_V2_ENABLE_PUSH_SETTING:

  2236.             if (value > 1) {
  2237.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2238.                               "client sent SETTINGS frame with incorrect "
  2239.                               "ENABLE_PUSH value %ui", value);

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

  2245.             break;

  2247.         case NGX_HTTP_V2_HEADER_TABLE_SIZE_SETTING:

  2249.             h2c->table_update = 1;
  2250.             break;

  2252.         default:
  2253.             break;
  2254.         }

  2256.         pos += NGX_HTTP_V2_SETTINGS_PARAM_SIZE;
  2257.     }

  2259.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_SETTINGS_ACK_SIZE,
  2260.                                   NGX_HTTP_V2_SETTINGS_FRAME,
  2261.                                   NGX_HTTP_V2_ACK_FLAG, 0);
  2262.     if (frame == NULL) {
  2263.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2264.     }

  2266.     ngx_http_v2_queue_ordered_frame(h2c, frame);

  2268.     if (window_delta) {
  2269.         h2c->init_window += window_delta;

  2271.         if (ngx_http_v2_adjust_windows(h2c, window_delta) != NGX_OK) {
  2272.             return ngx_http_v2_connection_error(h2c,
  2273.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  2274.         }
  2275.     }

  2277.     return ngx_http_v2_state_complete(h2c, pos, end);
  2278. }


  2281. static u_char *
  2282. ‌ngx_http_v2_state_push_promise(ngx_http_v2_connection_t *h2c, u_char *pos,
  2283.     u_char *end)
  2284. {
  2285.     ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2286.                   "client sent PUSH_PROMISE frame");

  2288.     return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2289. }


  2292. static u_char *
  2293. ‌ngx_http_v2_state_ping(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  2294. {
  2295.     ngx_buf_t                *buf;
  2296.     ngx_http_v2_out_frame_t  *frame;

  2298.     if (h2c->state.length != NGX_HTTP_V2_PING_SIZE) {
  2299.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2300.                       "client sent PING frame with incorrect length %uz",
  2301.                       h2c->state.length);

  2303.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2304.     }

  2306.     if (end - pos < NGX_HTTP_V2_PING_SIZE) {
  2307.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_ping);
  2308.     }

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

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

  2317.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2318.     }

  2320.     if (h2c->state.flags & NGX_HTTP_V2_ACK_FLAG) {
  2321.         return ngx_http_v2_state_skip(h2c, pos, end);
  2322.     }

  2324.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_PING_SIZE,
  2325.                                   NGX_HTTP_V2_PING_FRAME,
  2326.                                   NGX_HTTP_V2_ACK_FLAG, 0);
  2327.     if (frame == NULL) {
  2328.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2329.     }

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

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

  2335.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2337.     return ngx_http_v2_state_complete(h2c, pos + NGX_HTTP_V2_PING_SIZE, end);
  2338. }


  2341. static u_char *
  2342. ‌ngx_http_v2_state_goaway(ngx_http_v2_connection_t *h2c, u_char *pos,
  2343.     u_char *end)
  2344. {
  2345. #if (NGX_DEBUG)
  2346.     ngx_uint_t  last_sid, error;
  2347. #endif

  2349.     if (h2c->state.length < NGX_HTTP_V2_GOAWAY_SIZE) {
  2350.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2351.                       "client sent GOAWAY frame "
  2352.                       "with incorrect length %uz", h2c->state.length);

  2354.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2355.     }

  2357.     if (end - pos < NGX_HTTP_V2_GOAWAY_SIZE) {
  2358.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_goaway);
  2359.     }

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

  2365.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2366.     }

  2368. #if (NGX_DEBUG)
  2369.     h2c->state.length -= NGX_HTTP_V2_GOAWAY_SIZE;

  2371.     last_sid = ngx_http_v2_parse_sid(pos);
  2372.     error = ngx_http_v2_parse_uint32(&pos[4]);

  2374.     pos += NGX_HTTP_V2_GOAWAY_SIZE;

  2376.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2377.                    "http2 GOAWAY frame: last sid %ui, error %ui",
  2378.                    last_sid, error);
  2379. #endif

  2381.     return ngx_http_v2_state_skip(h2c, pos, end);
  2382. }


  2385. static u_char *
  2386. ‌ngx_http_v2_state_window_update(ngx_http_v2_connection_t *h2c, u_char *pos,
  2387.     u_char *end)
  2388. {
  2389.     size_t                 window;
  2390.     ngx_event_t           *wev;
  2391.     ngx_queue_t           *q;
  2392.     ngx_http_v2_node_t    *node;
  2393.     ngx_http_v2_stream_t  *stream;

  2395.     if (h2c->state.length != NGX_HTTP_V2_WINDOW_UPDATE_SIZE) {
  2396.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2397.                       "client sent WINDOW_UPDATE frame "
  2398.                       "with incorrect length %uz", h2c->state.length);

  2400.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2401.     }

  2403.     if (end - pos < NGX_HTTP_V2_WINDOW_UPDATE_SIZE) {
  2404.         return ngx_http_v2_state_save(h2c, pos, end,
  2405.                                       ngx_http_v2_state_window_update);
  2406.     }

  2408.     window = ngx_http_v2_parse_window(pos);

  2410.     pos += NGX_HTTP_V2_WINDOW_UPDATE_SIZE;

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

  2416.     if (window == 0) {
  2417.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2418.                       "client sent WINDOW_UPDATE frame "
  2419.                       "with incorrect window increment 0");

  2421.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2422.     }

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

  2427.         if (node == NULL || node->stream == NULL) {
  2428.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2429.                            "unknown http2 stream");

  2431.             return ngx_http_v2_state_complete(h2c, pos, end);
  2432.         }

  2434.         stream = node->stream;

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

  2438.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2439.                           "client violated flow control for stream %ui: "
  2440.                           "received WINDOW_UPDATE frame "
  2441.                           "with window increment %uz "
  2442.                           "not allowed for window %z",
  2443.                           h2c->state.sid, window, stream->send_window);

  2445.             if (ngx_http_v2_terminate_stream(h2c, stream,
  2446.                                              NGX_HTTP_V2_FLOW_CTRL_ERROR)
  2447.                 == NGX_ERROR)
  2448.             {
  2449.                 return ngx_http_v2_connection_error(h2c,
  2450.                                                     NGX_HTTP_V2_INTERNAL_ERROR);
  2451.             }

  2453.             return ngx_http_v2_state_complete(h2c, pos, end);
  2454.         }

  2456.         stream->send_window += window;

  2458.         if (stream->exhausted) {
  2459.             stream->exhausted = 0;

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

  2463.             wev->active = 0;
  2464.             wev->ready = 1;

  2466.             if (!wev->delayed) {
  2467.                 wev->handler(wev);
  2468.             }
  2469.         }

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

  2474.     if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
  2475.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2476.                       "client violated connection flow control: "
  2477.                       "received WINDOW_UPDATE frame "
  2478.                       "with window increment %uz "
  2479.                       "not allowed for window %uz",
  2480.                       window, h2c->send_window);

  2482.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
  2483.     }

  2485.     h2c->send_window += window;

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

  2490.         ngx_queue_remove(q);

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

  2494.         stream->waiting = 0;

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

  2498.         wev->active = 0;
  2499.         wev->ready = 1;

  2501.         if (!wev->delayed) {
  2502.             wev->handler(wev);

  2504.             if (h2c->send_window == 0) {
  2505.                 break;
  2506.             }
  2507.         }
  2508.     }

  2510.     return ngx_http_v2_state_complete(h2c, pos, end);
  2511. }


  2514. static u_char *
  2515. ‌ngx_http_v2_state_continuation(ngx_http_v2_connection_t *h2c, u_char *pos,
  2516.     u_char *end)
  2517. {
  2518.     ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2519.                   "client sent unexpected CONTINUATION frame");

  2521.     return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2522. }


  2525. static u_char *
  2526. ‌ngx_http_v2_state_complete(ngx_http_v2_connection_t *h2c, u_char *pos,
  2527.     u_char *end)
  2528. {
  2529.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2530.                    "http2 frame complete pos:%p end:%p", pos, end);

  2532.     if (pos > end) {
  2533.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  2534.                       "receive buffer overrun");

  2536.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2537.     }

  2539.     h2c->state.stream = NULL;
  2540.     h2c->state.handler = ngx_http_v2_state_head;

  2542.     return pos;
  2543. }


  2546. static u_char *
  2547. ‌ngx_http_v2_state_skip_padded(ngx_http_v2_connection_t *h2c, u_char *pos,
  2548.     u_char *end)
  2549. {
  2550.     h2c->state.length += h2c->state.padding;
  2551.     h2c->state.padding = 0;

  2553.     return ngx_http_v2_state_skip(h2c, pos, end);
  2554. }


  2557. static u_char *
  2558. ‌ngx_http_v2_state_skip(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  2559. {
  2560.     size_t  size;

  2562.     size = end - pos;

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

  2568.         h2c->state.length -= size;
  2569.         return ngx_http_v2_state_save(h2c, end, end, ngx_http_v2_state_skip);
  2570.     }

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

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


  2579. static u_char *
  2580. ‌ngx_http_v2_state_save(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end,
  2581.     ngx_http_v2_handler_pt handler)
  2582. {
  2583.     size_t  size;

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

  2589.     size = end - pos;

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

  2595.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2596.     }

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

  2600.     h2c->state.buffer_used = size;
  2601.     h2c->state.handler = handler;
  2602.     h2c->state.incomplete = 1;

  2604.     return end;
  2605. }


  2608. static u_char *
  2609. ‌ngx_http_v2_state_headers_save(ngx_http_v2_connection_t *h2c, u_char *pos,
  2610.     u_char *end, ngx_http_v2_handler_pt handler)
  2611. {
  2612.     ngx_event_t               *rev;
  2613.     ngx_http_request_t        *r;
  2614.     ngx_http_core_srv_conf_t  *cscf;

  2616.     if (h2c->state.stream) {
  2617.         r = h2c->state.stream->request;
  2618.         rev = r->connection->read;

  2620.         if (!rev->timer_set) {
  2621.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2622.             ngx_add_timer(rev, cscf->client_header_timeout);
  2623.         }
  2624.     }

  2626.     return ngx_http_v2_state_save(h2c, pos, end, handler);
  2627. }


  2630. static u_char *
  2631. ‌ngx_http_v2_connection_error(ngx_http_v2_connection_t *h2c,
  2632.     ngx_uint_t err)
  2633. {
  2634.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2635.                    "http2 state connection error");

  2637.     ngx_http_v2_finalize_connection(h2c, err);

  2639.     return NULL;
  2640. }


  2643. static ngx_int_t
  2644. ‌ngx_http_v2_parse_int(ngx_http_v2_connection_t *h2c, u_char **pos, u_char *end,
  2645.     ngx_uint_t prefix)
  2646. {
  2647.     u_char      *start, *p;
  2648.     ngx_uint_t   value, octet, shift;

  2650.     start = *pos;
  2651.     p = start;

  2653.     value = *p++ & prefix;

  2655.     if (value != prefix) {
  2656.         if (h2c->state.length == 0) {
  2657.             return NGX_ERROR;
  2658.         }

  2660.         h2c->state.length--;

  2662.         *pos = p;
  2663.         return value;
  2664.     }

  2666.     if (end - start > NGX_HTTP_V2_INT_OCTETS) {
  2667.         end = start + NGX_HTTP_V2_INT_OCTETS;
  2668.     }

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

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

  2675.         if (octet < 128) {
  2676.             if ((size_t) (p - start) > h2c->state.length) {
  2677.                 return NGX_ERROR;
  2678.             }

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

  2682.             *pos = p;
  2683.             return value;
  2684.         }
  2685.     }

  2687.     if ((size_t) (end - start) >= h2c->state.length) {
  2688.         return NGX_ERROR;
  2689.     }

  2691.     if (end == start + NGX_HTTP_V2_INT_OCTETS) {
  2692.         return NGX_DECLINED;
  2693.     }

  2695.     return NGX_AGAIN;
  2696. }


  2699. static ngx_int_t
  2700. ‌ngx_http_v2_send_settings(ngx_http_v2_connection_t *h2c)
  2701. {
  2702.     size_t                    len;
  2703.     ngx_buf_t                *buf;
  2704.     ngx_chain_t              *cl;
  2705.     ngx_http_v2_srv_conf_t   *h2scf;
  2706.     ngx_http_v2_out_frame_t  *frame;

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

  2711.     frame = ngx_palloc(h2c->pool, sizeof(ngx_http_v2_out_frame_t));
  2712.     if (frame == NULL) {
  2713.         return NGX_ERROR;
  2714.     }

  2716.     cl = ngx_alloc_chain_link(h2c->pool);
  2717.     if (cl == NULL) {
  2718.         return NGX_ERROR;
  2719.     }

  2721.     len = NGX_HTTP_V2_SETTINGS_PARAM_SIZE * 3;

  2723.     buf = ngx_create_temp_buf(h2c->pool, NGX_HTTP_V2_FRAME_HEADER_SIZE + len);
  2724.     if (buf == NULL) {
  2725.         return NGX_ERROR;
  2726.     }

  2728.     buf->last_buf = 1;

  2730.     cl->buf = buf;
  2731.     cl->next = NULL;

  2733.     frame->first = cl;
  2734.     frame->last = cl;
  2735.     frame->handler = ngx_http_v2_settings_frame_handler;
  2736.     frame->stream = NULL;
  2737. #if (NGX_DEBUG)
  2738.     frame->length = len;
  2739. #endif
  2740.     frame->blocked = 0;

  2742.     buf->last = ngx_http_v2_write_len_and_type(buf->last, len,
  2743.                                                NGX_HTTP_V2_SETTINGS_FRAME);

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

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

  2749.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  2750.                                          ngx_http_v2_module);

  2752.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2753.                                          NGX_HTTP_V2_MAX_STREAMS_SETTING);
  2754.     buf->last = ngx_http_v2_write_uint32(buf->last,
  2755.                                          h2scf->concurrent_streams);

  2757.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2758.                                          NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING);
  2759.     buf->last = ngx_http_v2_write_uint32(buf->last, h2scf->preread_size);

  2761.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2762.                                          NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING);
  2763.     buf->last = ngx_http_v2_write_uint32(buf->last,
  2764.                                          NGX_HTTP_V2_MAX_FRAME_SIZE);

  2766.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2768.     return NGX_OK;
  2769. }


  2772. static ngx_int_t
  2773. ‌ngx_http_v2_settings_frame_handler(ngx_http_v2_connection_t *h2c,
  2774.     ngx_http_v2_out_frame_t *frame)
  2775. {
  2776.     ngx_buf_t  *buf;

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

  2780.     if (buf->pos != buf->last) {
  2781.         return NGX_AGAIN;
  2782.     }

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

  2786.     return NGX_OK;
  2787. }


  2790. static ngx_int_t
  2791. ‌ngx_http_v2_send_window_update(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  2792.     size_t window)
  2793. {
  2794.     ngx_buf_t                *buf;
  2795.     ngx_http_v2_out_frame_t  *frame;

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

  2801.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_WINDOW_UPDATE_SIZE,
  2802.                                   NGX_HTTP_V2_WINDOW_UPDATE_FRAME,
  2803.                                   NGX_HTTP_V2_NO_FLAG, sid);
  2804.     if (frame == NULL) {
  2805.         return NGX_ERROR;
  2806.     }

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

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

  2812.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2814.     return NGX_OK;
  2815. }


  2818. static ngx_int_t
  2819. ‌ngx_http_v2_send_rst_stream(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  2820.     ngx_uint_t status)
  2821. {
  2822.     ngx_buf_t                *buf;
  2823.     ngx_http_v2_out_frame_t  *frame;

  2825.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2826.                    "http2 send RST_STREAM frame sid:%ui, status:%ui",
  2827.                    sid, status);

  2829.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_RST_STREAM_SIZE,
  2830.                                   NGX_HTTP_V2_RST_STREAM_FRAME,
  2831.                                   NGX_HTTP_V2_NO_FLAG, sid);
  2832.     if (frame == NULL) {
  2833.         return NGX_ERROR;
  2834.     }

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

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

  2840.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2842.     return NGX_OK;
  2843. }


  2846. static ngx_int_t
  2847. ‌ngx_http_v2_send_goaway(ngx_http_v2_connection_t *h2c, ngx_uint_t status)
  2848. {
  2849.     ngx_buf_t                *buf;
  2850.     ngx_http_v2_out_frame_t  *frame;

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

  2856.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_GOAWAY_SIZE,
  2857.                                   NGX_HTTP_V2_GOAWAY_FRAME,
  2858.                                   NGX_HTTP_V2_NO_FLAG, 0);
  2859.     if (frame == NULL) {
  2860.         return NGX_ERROR;
  2861.     }

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

  2865.     buf->last = ngx_http_v2_write_sid(buf->last, h2c->last_sid);
  2866.     buf->last = ngx_http_v2_write_uint32(buf->last, status);

  2868.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2870.     return NGX_OK;
  2871. }


  2874. static ngx_http_v2_out_frame_t *
  2875. ‌ngx_http_v2_get_frame(ngx_http_v2_connection_t *h2c, size_t length,
  2876.     ngx_uint_t type, u_char flags, ngx_uint_t sid)
  2877. {
  2878.     ngx_buf_t                *buf;
  2879.     ngx_pool_t               *pool;
  2880.     ngx_http_v2_out_frame_t  *frame;

  2882.     frame = h2c->free_frames;

  2884.     if (frame) {
  2885.         h2c->free_frames = frame->next;

  2887.         buf = frame->first->buf;
  2888.         buf->pos = buf->start;

  2890.         frame->blocked = 0;

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

  2895.         frame = ngx_pcalloc(pool, sizeof(ngx_http_v2_out_frame_t));
  2896.         if (frame == NULL) {
  2897.             return NULL;
  2898.         }

  2900.         frame->first = ngx_alloc_chain_link(pool);
  2901.         if (frame->first == NULL) {
  2902.             return NULL;
  2903.         }

  2905.         buf = ngx_create_temp_buf(pool, NGX_HTTP_V2_FRAME_BUFFER_SIZE);
  2906.         if (buf == NULL) {
  2907.             return NULL;
  2908.         }

  2910.         buf->last_buf = 1;

  2912.         frame->first->buf = buf;
  2913.         frame->last = frame->first;

  2915.         frame->handler = ngx_http_v2_frame_handler;

  2917.         h2c->frames++;

  2919.     } else {
  2920.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2921.                       "http2 flood detected");

  2923.         h2c->connection->error = 1;
  2924.         return NULL;
  2925.     }

  2927. #if (NGX_DEBUG)
  2928.     if (length > NGX_HTTP_V2_FRAME_BUFFER_SIZE - NGX_HTTP_V2_FRAME_HEADER_SIZE)
  2929.     {
  2930.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  2931.                       "requested control frame is too large: %uz", length);
  2932.         return NULL;
  2933.     }
  2934. #endif

  2936.     frame->length = length;

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

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

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

  2944.     return frame;
  2945. }


  2948. static ngx_int_t
  2949. ‌ngx_http_v2_frame_handler(ngx_http_v2_connection_t *h2c,
  2950.     ngx_http_v2_out_frame_t *frame)
  2951. {
  2952.     ngx_buf_t  *buf;

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

  2956.     if (buf->pos != buf->last) {
  2957.         return NGX_AGAIN;
  2958.     }

  2960.     frame->next = h2c->free_frames;
  2961.     h2c->free_frames = frame;

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

  2965.     return NGX_OK;
  2966. }


  2969. static ngx_http_v2_stream_t *
  2970. ‌ngx_http_v2_create_stream(ngx_http_v2_connection_t *h2c)
  2971. {
  2972.     ngx_log_t                 *log;
  2973.     ngx_event_t               *rev, *wev;
  2974.     ngx_connection_t          *fc;
  2975.     ngx_http_log_ctx_t        *ctx;
  2976.     ngx_http_request_t        *r;
  2977.     ngx_http_v2_stream_t      *stream;
  2978.     ngx_http_v2_srv_conf_t    *h2scf;
  2979.     ngx_http_core_srv_conf_t  *cscf;

  2981.     fc = h2c->free_fake_connections;

  2983.     if (fc) {
  2984.         h2c->free_fake_connections = fc->data;

  2986.         rev = fc->read;
  2987.         wev = fc->write;
  2988.         log = fc->log;
  2989.         ctx = log->data;

  2991.     } else {
  2992.         fc = ngx_palloc(h2c->pool, sizeof(ngx_connection_t));
  2993.         if (fc == NULL) {
  2994.             return NULL;
  2995.         }

  2997.         rev = ngx_palloc(h2c->pool, sizeof(ngx_event_t));
  2998.         if (rev == NULL) {
  2999.             return NULL;
  3000.         }

  3002.         wev = ngx_palloc(h2c->pool, sizeof(ngx_event_t));
  3003.         if (wev == NULL) {
  3004.             return NULL;
  3005.         }

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

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

  3017.         ctx->connection = fc;
  3018.         ctx->request = NULL;
  3019.         ctx->current_request = NULL;
  3020.     }

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

  3024.     log->data = ctx;
  3025.     log->action = "reading client request headers";

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

  3029.     rev->data = fc;
  3030.     rev->ready = 1;
  3031.     rev->handler = ngx_http_v2_close_stream_handler;
  3032.     rev->log = log;

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

  3036.     wev->write = 1;

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

  3040.     fc->data = h2c->http_connection;
  3041.     fc->read = rev;
  3042.     fc->write = wev;
  3043.     fc->sent = 0;
  3044.     fc->log = log;
  3045.     fc->buffered = 0;
  3046.     fc->sndlowat = 1;
  3047.     fc->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;

  3049.     r = ngx_http_create_request(fc);
  3050.     if (r == NULL) {
  3051.         return NULL;
  3052.     }

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

  3056.     r->http_version = NGX_HTTP_VERSION_20;
  3057.     r->valid_location = 1;

  3059.     fc->data = r;
  3060.     h2c->connection->requests++;

  3062.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  3064.     r->header_in = ngx_create_temp_buf(r->pool,
  3065.                                        cscf->client_header_buffer_size);
  3066.     if (r->header_in == NULL) {
  3067.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3068.         return NULL;
  3069.     }

  3071.     if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  3072.                       sizeof(ngx_table_elt_t))
  3073.         != NGX_OK)
  3074.     {
  3075.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3076.         return NULL;
  3077.     }

  3079.     r->headers_in.connection_type = NGX_HTTP_CONNECTION_CLOSE;

  3081.     stream = ngx_pcalloc(r->pool, sizeof(ngx_http_v2_stream_t));
  3082.     if (stream == NULL) {
  3083.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3084.         return NULL;
  3085.     }

  3087.     r->stream = stream;

  3089.     stream->request = r;
  3090.     stream->connection = h2c;

  3092.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

  3094.     stream->send_window = h2c->init_window;
  3095.     stream->recv_window = h2scf->preread_size;

  3097.     h2c->processing++;

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

  3101.     if (h2c->connection->read->timer_set) {
  3102.         ngx_del_timer(h2c->connection->read);
  3103.     }

  3105.     return stream;
  3106. }


  3109. static ngx_http_v2_node_t *
  3110. ‌ngx_http_v2_get_node_by_id(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  3111.     ngx_uint_t alloc)
  3112. {
  3113.     ngx_uint_t               index;
  3114.     ngx_http_v2_node_t      *node;
  3115.     ngx_http_v2_srv_conf_t  *h2scf;

  3117.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  3118.                                          ngx_http_v2_module);

  3120.     index = ngx_http_v2_index(h2scf, sid);

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

  3124.         if (node->id == sid) {
  3125.             return node;
  3126.         }
  3127.     }

  3129.     if (!alloc) {
  3130.         return NULL;
  3131.     }

  3133.     if (h2c->closed_nodes < 32) {
  3134.         node = ngx_pcalloc(h2c->connection->pool, sizeof(ngx_http_v2_node_t));
  3135.         if (node == NULL) {
  3136.             return NULL;
  3137.         }

  3139.     } else {
  3140.         node = ngx_http_v2_get_closed_node(h2c);
  3141.     }

  3143.     node->id = sid;

  3145.     ngx_queue_init(&node->children);

  3147.     node->index = h2c->streams_index[index];
  3148.     h2c->streams_index[index] = node;

  3150.     return node;
  3151. }


  3154. static ngx_http_v2_node_t *
  3155. ‌ngx_http_v2_get_closed_node(ngx_http_v2_connection_t *h2c)
  3156. {
  3157.     ngx_uint_t               weight;
  3158.     ngx_queue_t             *q, *children;
  3159.     ngx_http_v2_node_t      *node, **next, *n, *parent, *child;
  3160.     ngx_http_v2_srv_conf_t  *h2scf;

  3162.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  3163.                                          ngx_http_v2_module);

  3165.     h2c->closed_nodes--;

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

  3169.     ngx_queue_remove(q);

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

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

  3175.     for ( ;; ) {
  3176.         n = *next;

  3178.         if (n == node) {
  3179.             *next = n->index;
  3180.             break;
  3181.         }

  3183.         next = &n->index;
  3184.     }

  3186.     ngx_queue_remove(&node->queue);

  3188.     weight = 0;

  3190.     for (q = ngx_queue_head(&node->children);
  3191.          q != ngx_queue_sentinel(&node->children);
  3192.          q = ngx_queue_next(q))
  3193.     {
  3194.         child = ngx_queue_data(q, ngx_http_v2_node_t, queue);
  3195.         weight += child->weight;
  3196.     }

  3198.     parent = node->parent;

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

  3208.         if (child->weight == 0) {
  3209.             child->weight = 1;
  3210.         }
  3211.     }

  3213.     if (parent == NGX_HTTP_V2_ROOT) {
  3214.         node->rank = 0;
  3215.         node->rel_weight = 1.0;

  3217.         children = &h2c->dependencies;

  3219.     } else {
  3220.         node->rank = parent->rank;
  3221.         node->rel_weight = parent->rel_weight;

  3223.         children = &parent->children;
  3224.     }

  3226.     ngx_http_v2_node_children_update(node);
  3227.     ngx_queue_add(children, &node->children);

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

  3231.     return node;
  3232. }


  3235. static ngx_int_t
  3236. ‌ngx_http_v2_validate_header(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3237. {
  3238.     u_char                     ch;
  3239.     ngx_uint_t                 i;
  3240.     ngx_http_core_srv_conf_t  *cscf;

  3242.     r->invalid_header = 0;

  3244.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  3249.         if ((ch >= 'a' && ch <= 'z')
  3250.             || (ch == '-')
  3251.             || (ch >= '0' && ch <= '9')
  3252.             || (ch == '_' && cscf->underscores_in_headers))
  3253.         {
  3254.             continue;
  3255.         }

  3257.         if (ch <= 0x20 || ch == 0x7f || ch == ':'
  3258.             || (ch >= 'A' && ch <= 'Z'))
  3259.         {
  3260.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3261.                           "client sent invalid header name: \"%V\"",
  3262.                           &header->name);

  3264.             return NGX_ERROR;
  3265.         }

  3267.         r->invalid_header = 1;
  3268.     }

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

  3273.         if (ch == '\0' || ch == LF || ch == CR) {
  3274.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3275.                           "client sent header \"%V\" with "
  3276.                           "invalid value: \"%V\"",
  3277.                           &header->name, &header->value);

  3279.             return NGX_ERROR;
  3280.         }
  3281.     }

  3283.     return NGX_OK;
  3284. }


  3287. static ngx_int_t
  3288. ‌ngx_http_v2_pseudo_header(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3289. {
  3290.     header->name.len--;
  3291.     header->name.data++;

  3293.     switch (header->name.len) {
  3294.     case 4:
  3295.         if (ngx_memcmp(header->name.data, "path", sizeof("path") - 1)
  3296.             == 0)
  3297.         {
  3298.             return ngx_http_v2_parse_path(r, &header->value);
  3299.         }

  3301.         break;

  3303.     case 6:
  3304.         if (ngx_memcmp(header->name.data, "method", sizeof("method") - 1)
  3305.             == 0)
  3306.         {
  3307.             return ngx_http_v2_parse_method(r, &header->value);
  3308.         }

  3310.         if (ngx_memcmp(header->name.data, "scheme", sizeof("scheme") - 1)
  3311.             == 0)
  3312.         {
  3313.             return ngx_http_v2_parse_scheme(r, &header->value);
  3314.         }

  3316.         break;

  3318.     case 9:
  3319.         if (ngx_memcmp(header->name.data, "authority", sizeof("authority") - 1)
  3320.             == 0)
  3321.         {
  3322.             return ngx_http_v2_parse_authority(r, &header->value);
  3323.         }

  3325.         break;
  3326.     }

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

  3332.     return NGX_DECLINED;
  3333. }


  3336. static ngx_int_t
  3337. ‌ngx_http_v2_parse_path(ngx_http_request_t *r, ngx_str_t *value)
  3338. {
  3339.     if (r->unparsed_uri.len) {
  3340.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3341.                       "client sent duplicate :path header");

  3343.         return NGX_DECLINED;
  3344.     }

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

  3350.         return NGX_DECLINED;
  3351.     }

  3353.     r->uri_start = value->data;
  3354.     r->uri_end = value->data + value->len;

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

  3360.         return NGX_DECLINED;
  3361.     }

  3363.     if (ngx_http_process_request_uri(r) != NGX_OK) {
  3364.         /*
  3365.          * request has been finalized already
  3366.          * in ngx_http_process_request_uri()
  3367.          */
  3368.         return NGX_ABORT;
  3369.     }

  3371.     return NGX_OK;
  3372. }


  3375. static ngx_int_t
  3376. ‌ngx_http_v2_parse_method(ngx_http_request_t *r, ngx_str_t *value)
  3377. {
  3378.     size_t         k, len;
  3379.     ngx_uint_t     n;
  3380.     const u_char  *p, *m;

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

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

  3414.         return NGX_DECLINED;
  3415.     }

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

  3421.         return NGX_DECLINED;
  3422.     }

  3424.     r->method_name.len = value->len;
  3425.     r->method_name.data = value->data;

  3427.     len = r->method_name.len;
  3428.     n = sizeof(tests) / sizeof(tests[0]);
  3429.     test = tests;

  3431.     do {
  3432.         if (len == test->len) {
  3433.             p = r->method_name.data;
  3434.             m = test->method;
  3435.             k = len;

  3437.             do {
  3438.                 if (*p++ != *m++) {
  3439.                     goto next;
  3440.                 }
  3441.             } while (--k);

  3443.             r->method = test->value;
  3444.             return NGX_OK;
  3445.         }

  3447.     next:
  3448.         test++;

  3450.     } while (--n);

  3452.     p = r->method_name.data;

  3454.     do {
  3455.         if ((*p < 'A' || *p > 'Z') && *p != '_' && *p != '-') {
  3456.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3457.                           "client sent invalid method: \"%V\"",
  3458.                           &r->method_name);

  3460.             return NGX_DECLINED;
  3461.         }

  3463.         p++;

  3465.     } while (--len);

  3467.     return NGX_OK;
  3468. }


  3471. static ngx_int_t
  3472. ‌ngx_http_v2_parse_scheme(ngx_http_request_t *r, ngx_str_t *value)
  3473. {
  3474.     u_char      c, ch;
  3475.     ngx_uint_t  i;

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

  3481.         return NGX_DECLINED;
  3482.     }

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

  3488.         return NGX_DECLINED;
  3489.     }

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

  3494.         c = (u_char) (ch | 0x20);
  3495.         if (c >= 'a' && c <= 'z') {
  3496.             continue;
  3497.         }

  3499.         if (((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')
  3500.             && i > 0)
  3501.         {
  3502.             continue;
  3503.         }

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

  3508.         return NGX_DECLINED;
  3509.     }

  3511.     r->schema = *value;

  3513.     return NGX_OK;
  3514. }


  3517. static ngx_int_t
  3518. ‌ngx_http_v2_parse_authority(ngx_http_request_t *r, ngx_str_t *value)
  3519. {
  3520.     ngx_table_elt_t            *h;
  3521.     ngx_http_header_t          *hh;
  3522.     ngx_http_core_main_conf_t  *cmcf;

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

  3526.     h = ngx_list_push(&r->headers_in.headers);
  3527.     if (h == NULL) {
  3528.         return NGX_ERROR;
  3529.     }

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

  3533.     h->key.len = host.len;
  3534.     h->key.data = host.data;

  3536.     h->value.len = value->len;
  3537.     h->value.data = value->data;

  3539.     h->lowcase_key = host.data;

  3541.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  3546.     if (hh == NULL) {
  3547.         return NGX_ERROR;
  3548.     }

  3550.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  3551.         /*
  3552.          * request has been finalized already
  3553.          * in ngx_http_process_host()
  3554.          */
  3555.         return NGX_ABORT;
  3556.     }

  3558.     return NGX_OK;
  3559. }


  3562. static ngx_int_t
  3563. ‌ngx_http_v2_construct_request_line(ngx_http_request_t *r)
  3564. {
  3565.     u_char  *p;

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

  3569.     if (r->method_name.len == 0
  3570.         || r->schema.len == 0
  3571.         || r->unparsed_uri.len == 0)
  3572.     {
  3573.         if (r->method_name.len == 0) {
  3574.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3575.                           "client sent no :method header");

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

  3581.         } else {
  3582.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3583.                           "client sent no :path header");
  3584.         }

  3586.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3587.         return NGX_ERROR;
  3588.     }

  3590.     r->request_line.len = r->method_name.len + 1
  3591.                           + r->unparsed_uri.len
  3592.                           + sizeof(ending) - 1;

  3594.     p = ngx_pnalloc(r->pool, r->request_line.len + 1);
  3595.     if (p == NULL) {
  3596.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3597.         return NGX_ERROR;
  3598.     }

  3600.     r->request_line.data = p;

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

  3604.     *p++ = ' ';

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

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

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

  3613.     return NGX_OK;
  3614. }


  3617. static ngx_int_t
  3618. ‌ngx_http_v2_cookie(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3619. {
  3620.     ngx_str_t    *val;
  3621.     ngx_array_t  *cookies;

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

  3625.     if (cookies == NULL) {
  3626.         cookies = ngx_array_create(r->pool, 2, sizeof(ngx_str_t));
  3627.         if (cookies == NULL) {
  3628.             return NGX_ERROR;
  3629.         }

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

  3634.     val = ngx_array_push(cookies);
  3635.     if (val == NULL) {
  3636.         return NGX_ERROR;
  3637.     }

  3639.     val->len = header->value.len;
  3640.     val->data = header->value.data;

  3642.     return NGX_OK;
  3643. }


  3646. static ngx_int_t
  3647. ‌ngx_http_v2_construct_cookie_header(ngx_http_request_t *r)
  3648. {
  3649.     u_char                     *buf, *p, *end;
  3650.     size_t                      len;
  3651.     ngx_str_t                  *vals;
  3652.     ngx_uint_t                  i;
  3653.     ngx_array_t                *cookies;
  3654.     ngx_table_elt_t            *h;
  3655.     ngx_http_header_t          *hh;
  3656.     ngx_http_core_main_conf_t  *cmcf;

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

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

  3662.     if (cookies == NULL) {
  3663.         return NGX_OK;
  3664.     }

  3666.     vals = cookies->elts;

  3668.     i = 0;
  3669.     len = 0;

  3671.     do {
  3672.         len += vals[i].len + 2;
  3673.     } while (++i != cookies->nelts);

  3675.     len -= 2;

  3677.     buf = ngx_pnalloc(r->pool, len + 1);
  3678.     if (buf == NULL) {
  3679.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3680.         return NGX_ERROR;
  3681.     }

  3683.     p = buf;
  3684.     end = buf + len;

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

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

  3690.         if (p == end) {
  3691.             *p = '\0';
  3692.             break;
  3693.         }

  3695.         *p++ = ';'; *p++ = ' ';
  3696.     }

  3698.     h = ngx_list_push(&r->headers_in.headers);
  3699.     if (h == NULL) {
  3700.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3701.         return NGX_ERROR;
  3702.     }

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

  3707.     h->key.len = cookie.len;
  3708.     h->key.data = cookie.data;

  3710.     h->value.len = len;
  3711.     h->value.data = buf;

  3713.     h->lowcase_key = cookie.data;

  3715.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  3720.     if (hh == NULL) {
  3721.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3722.         return NGX_ERROR;
  3723.     }

  3725.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  3726.         /*
  3727.          * request has been finalized already
  3728.          * in ngx_http_process_multi_header_lines()
  3729.          */
  3730.         return NGX_ERROR;
  3731.     }

  3733.     return NGX_OK;
  3734. }


  3737. static void
  3738. ‌ngx_http_v2_run_request(ngx_http_request_t *r)
  3739. {
  3740.     ngx_connection_t          *fc;
  3741.     ngx_http_v2_srv_conf_t    *h2scf;
  3742.     ngx_http_v2_connection_t  *h2c;

  3744.     fc = r->connection;

  3746.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

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

  3753.         ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  3754.         goto failed;
  3755.     }

  3757.     if (ngx_http_v2_construct_request_line(r) != NGX_OK) {
  3758.         goto failed;
  3759.     }

  3761.     if (ngx_http_v2_construct_cookie_header(r) != NGX_OK) {
  3762.         goto failed;
  3763.     }

  3765.     r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  3767.     if (ngx_http_process_request_header(r) != NGX_OK) {
  3768.         goto failed;
  3769.     }

  3771.     if (r->headers_in.content_length_n > 0 && r->stream->in_closed) {
  3772.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3773.                       "client prematurely closed stream");

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

  3777.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3778.         goto failed;
  3779.     }

  3781.     if (r->headers_in.content_length_n == -1 && !r->stream->in_closed) {
  3782.         r->headers_in.chunked = 1;
  3783.     }

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

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

  3789.     ngx_http_process_request(r);

  3791. failed:

  3793.     ngx_http_run_posted_requests(fc);
  3794. }


  3797. ngx_int_t
  3798. ‌ngx_http_v2_read_request_body(ngx_http_request_t *r)
  3799. {
  3800.     off_t                      len;
  3801.     size_t                     size;
  3802.     ngx_buf_t                 *buf;
  3803.     ngx_int_t                  rc;
  3804.     ngx_http_v2_stream_t      *stream;
  3805.     ngx_http_v2_srv_conf_t    *h2scf;
  3806.     ngx_http_request_body_t   *rb;
  3807.     ngx_http_core_loc_conf_t  *clcf;
  3808.     ngx_http_v2_connection_t  *h2c;

  3810.     stream = r->stream;
  3811.     rb = r->request_body;

  3813.     if (stream->skip_data) {
  3814.         r->request_body_no_buffering = 0;
  3815.         rb->post_handler(r);
  3816.         return NGX_OK;
  3817.     }

  3819.     rb->rest = 1;

  3821.     /* set rb->filter_need_buffering */

  3823.     rc = ngx_http_top_request_body_filter(r, NULL);

  3825.     if (rc != NGX_OK) {
  3826.         stream->skip_data = 1;
  3827.         return rc;
  3828.     }

  3830.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);
  3831.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3833.     len = r->headers_in.content_length_n;

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

  3838.     } else {
  3839.         len++;
  3840.     }

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

  3844.         /*
  3845.          * We need a room to store data up to the stream's initial window size,
  3846.          * at least until this window will be exhausted.
  3847.          */

  3849.         if (len < (off_t) h2scf->preread_size) {
  3850.             len = h2scf->preread_size;
  3851.         }

  3853.         if (len > NGX_HTTP_V2_MAX_WINDOW) {
  3854.             len = NGX_HTTP_V2_MAX_WINDOW;
  3855.         }
  3856.     }

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

  3860.     if (rb->buf == NULL) {
  3861.         stream->skip_data = 1;
  3862.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  3863.     }

  3865.     buf = stream->preread;

  3867.     if (stream->in_closed) {
  3868.         if (!rb->filter_need_buffering) {
  3869.             r->request_body_no_buffering = 0;
  3870.         }

  3872.         if (buf) {
  3873.             rc = ngx_http_v2_process_request_body(r, buf->pos,
  3874.                                                   buf->last - buf->pos, 1, 0);
  3875.             ngx_pfree(r->pool, buf->start);

  3877.         } else {
  3878.             rc = ngx_http_v2_process_request_body(r, NULL, 0, 1, 0);
  3879.         }

  3881.         if (rc != NGX_AGAIN) {
  3882.             return rc;
  3883.         }

  3885.         r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
  3886.         r->write_event_handler = ngx_http_request_empty_handler;

  3888.         return NGX_AGAIN;
  3889.     }

  3891.     if (buf) {
  3892.         rc = ngx_http_v2_process_request_body(r, buf->pos,
  3893.                                               buf->last - buf->pos, 0, 0);

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

  3897.         if (rc != NGX_OK && rc != NGX_AGAIN) {
  3898.             stream->skip_data = 1;
  3899.             return rc;
  3900.         }
  3901.     }

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

  3906.     } else {
  3907.         stream->no_flow_control = 1;
  3908.         size = NGX_HTTP_V2_MAX_WINDOW - stream->recv_window;
  3909.     }

  3911.     if (size) {
  3912.         if (ngx_http_v2_send_window_update(stream->connection,
  3913.                                            stream->node->id, size)
  3914.             == NGX_ERROR)
  3915.         {
  3916.             stream->skip_data = 1;
  3917.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  3918.         }

  3920.         h2c = stream->connection;

  3922.         if (!h2c->blocked) {
  3923.             if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  3924.                 stream->skip_data = 1;
  3925.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  3926.             }
  3927.         }

  3929.         stream->recv_window += size;
  3930.     }

  3932.     if (!buf) {
  3933.         ngx_add_timer(r->connection->read, clcf->client_body_timeout);
  3934.     }

  3936.     r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
  3937.     r->write_event_handler = ngx_http_request_empty_handler;

  3939.     return NGX_AGAIN;
  3940. }


  3943. static ngx_int_t
  3944. ‌ngx_http_v2_process_request_body(ngx_http_request_t *r, u_char *pos,
  3945.     size_t size, ngx_uint_t last, ngx_uint_t flush)
  3946. {
  3947.     size_t                     n;
  3948.     ngx_int_t                  rc;
  3949.     ngx_connection_t          *fc;
  3950.     ngx_http_request_body_t   *rb;
  3951.     ngx_http_core_loc_conf_t  *clcf;

  3953.     fc = r->connection;
  3954.     rb = r->request_body;

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

  3959.     if (size == 0 && !last && !flush) {
  3960.         return NGX_AGAIN;
  3961.     }

  3963.     for ( ;; ) {
  3964.         for ( ;; ) {
  3965.             if (rb->buf->last == rb->buf->end && size) {

  3967.                 if (r->request_body_no_buffering) {

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

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

  3974.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  3975.                 }

  3977.                 /* update chains */

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

  3982.                 rc = ngx_http_v2_filter_request_body(r);

  3984.                 if (rc != NGX_OK) {
  3985.                     return rc;
  3986.                 }

  3988.                 if (rb->busy != NULL) {
  3989.                     ngx_log_error(NGX_LOG_ALERT, fc->log, 0,
  3990.                                   "busy buffers after request body flush");
  3991.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  3992.                 }

  3994.                 rb->buf->pos = rb->buf->start;
  3995.                 rb->buf->last = rb->buf->start;
  3996.             }

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

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

  4002.             if (n > size) {
  4003.                 n = size;
  4004.             }

  4006.             if (n > 0) {
  4007.                 rb->buf->last = ngx_cpymem(rb->buf->last, pos, n);
  4008.             }

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

  4013.             pos += n;
  4014.             size -= n;

  4016.             if (size == 0 && last) {
  4017.                 rb->rest = 0;
  4018.             }

  4020.             if (size == 0) {
  4021.                 break;
  4022.             }
  4023.         }

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

  4028.         if (flush) {
  4029.             rc = ngx_http_v2_filter_request_body(r);

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

  4036.         if (rb->rest == 0 && rb->last_saved) {
  4037.             break;
  4038.         }

  4040.         if (size == 0) {
  4041.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  4042.             ngx_add_timer(fc->read, clcf->client_body_timeout);

  4044.             if (!flush) {
  4045.                 ngx_post_event(fc->read, &ngx_posted_events);
  4046.             }

  4048.             return NGX_AGAIN;
  4049.         }
  4050.     }

  4052.     if (fc->read->timer_set) {
  4053.         ngx_del_timer(fc->read);
  4054.     }

  4056.     if (r->request_body_no_buffering) {
  4057.         if (!flush) {
  4058.             ngx_post_event(fc->read, &ngx_posted_events);
  4059.         }

  4061.         return NGX_OK;
  4062.     }

  4064.     if (r->headers_in.chunked) {
  4065.         r->headers_in.content_length_n = rb->received;
  4066.     }

  4068.     r->read_event_handler = ngx_http_block_reading;
  4069.     rb->post_handler(r);

  4071.     return NGX_OK;
  4072. }


  4075. static ngx_int_t
  4076. ‌ngx_http_v2_filter_request_body(ngx_http_request_t *r)
  4077. {
  4078.     ngx_buf_t                 *b, *buf;
  4079.     ngx_int_t                  rc;
  4080.     ngx_chain_t               *cl;
  4081.     ngx_http_request_body_t   *rb;
  4082.     ngx_http_core_loc_conf_t  *clcf;

  4084.     rb = r->request_body;
  4085.     buf = rb->buf;

  4087.     if (buf->pos == buf->last && (rb->rest || rb->last_sent)) {
  4088.         cl = NULL;
  4089.         goto update;
  4090.     }

  4092.     cl = ngx_chain_get_free_buf(r->pool, &rb->free);
  4093.     if (cl == NULL) {
  4094.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4095.     }

  4097.     b = cl->buf;

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

  4101.     if (buf->pos != buf->last) {
  4102.         r->request_length += buf->last - buf->pos;
  4103.         rb->received += buf->last - buf->pos;

  4105.         if (r->headers_in.content_length_n != -1) {
  4106.             if (rb->received > r->headers_in.content_length_n) {
  4107.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  4108.                               "client intended to send body data "
  4109.                               "larger than declared");

  4111.                 return NGX_HTTP_BAD_REQUEST;
  4112.             }

  4114.         } else {
  4115.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4117.             if (clcf->client_max_body_size
  4118.                 && rb->received > clcf->client_max_body_size)
  4119.             {
  4120.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4121.                               "client intended to send too large chunked body: "
  4122.                               "%O bytes", rb->received);

  4124.                 return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  4125.             }
  4126.         }

  4128.         b->temporary = 1;
  4129.         b->pos = buf->pos;
  4130.         b->last = buf->last;
  4131.         b->start = b->pos;
  4132.         b->end = b->last;

  4134.         buf->pos = buf->last;
  4135.     }

  4137.     if (!rb->rest) {
  4138.         if (r->headers_in.content_length_n != -1
  4139.             && r->headers_in.content_length_n != rb->received)
  4140.         {
  4141.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  4142.                           "client prematurely closed stream: "
  4143.                           "only %O out of %O bytes of request body received",
  4144.                           rb->received, r->headers_in.content_length_n);

  4146.             return NGX_HTTP_BAD_REQUEST;
  4147.         }

  4149.         b->last_buf = 1;
  4150.         rb->last_sent = 1;
  4151.     }

  4153.     b->tag = (ngx_buf_tag_t) &ngx_http_v2_filter_request_body;
  4154.     b->flush = r->request_body_no_buffering;

  4156. update:

  4158.     rc = ngx_http_top_request_body_filter(r, cl);

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

  4163.     return rc;
  4164. }


  4167. static void
  4168. ‌ngx_http_v2_read_client_request_body_handler(ngx_http_request_t *r)
  4169. {
  4170.     size_t                     window;
  4171.     ngx_buf_t                 *buf;
  4172.     ngx_int_t                  rc;
  4173.     ngx_connection_t          *fc;
  4174.     ngx_http_v2_stream_t      *stream;
  4175.     ngx_http_v2_connection_t  *h2c;

  4177.     fc = r->connection;

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

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

  4185.         fc->timedout = 1;
  4186.         r->stream->skip_data = 1;

  4188.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  4189.         return;
  4190.     }

  4192.     if (fc->error) {
  4193.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4194.                       "client prematurely closed stream");

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

  4198.         ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  4199.         return;
  4200.     }

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

  4204.     if (rc != NGX_OK && rc != NGX_AGAIN) {
  4205.         r->stream->skip_data = 1;
  4206.         ngx_http_finalize_request(r, rc);
  4207.         return;
  4208.     }

  4210.     if (rc == NGX_OK) {
  4211.         return;
  4212.     }

  4214.     if (r->stream->no_flow_control) {
  4215.         return;
  4216.     }

  4218.     if (r->request_body->rest == 0) {
  4219.         return;
  4220.     }

  4222.     if (r->request_body->busy != NULL) {
  4223.         return;
  4224.     }

  4226.     stream = r->stream;
  4227.     h2c = stream->connection;

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

  4231.     buf->pos = buf->start;
  4232.     buf->last = buf->start;

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

  4236.     if (h2c->state.stream == stream) {
  4237.         window -= h2c->state.length;
  4238.     }

  4240.     if (window <= stream->recv_window) {
  4241.         if (window < stream->recv_window) {
  4242.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  4243.                           "http2 negative window update");

  4245.             stream->skip_data = 1;

  4247.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4248.             return;
  4249.         }

  4251.         return;
  4252.     }

  4254.     if (ngx_http_v2_send_window_update(h2c, stream->node->id,
  4255.                                        window - stream->recv_window)
  4256.         == NGX_ERROR)
  4257.     {
  4258.         stream->skip_data = 1;
  4259.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4260.         return;
  4261.     }

  4263.     stream->recv_window = window;

  4265.     if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4266.         stream->skip_data = 1;
  4267.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4268.         return;
  4269.     }
  4270. }


  4273. ngx_int_t
  4274. ‌ngx_http_v2_read_unbuffered_request_body(ngx_http_request_t *r)
  4275. {
  4276.     size_t                     window;
  4277.     ngx_buf_t                 *buf;
  4278.     ngx_int_t                  rc;
  4279.     ngx_connection_t          *fc;
  4280.     ngx_http_v2_stream_t      *stream;
  4281.     ngx_http_v2_connection_t  *h2c;

  4283.     stream = r->stream;
  4284.     fc = r->connection;

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

  4289.     if (fc->read->timedout) {
  4290.         if (stream->recv_window) {
  4291.             stream->skip_data = 1;
  4292.             fc->timedout = 1;

  4294.             return NGX_HTTP_REQUEST_TIME_OUT;
  4295.         }

  4297.         fc->read->timedout = 0;
  4298.     }

  4300.     if (fc->error) {
  4301.         stream->skip_data = 1;
  4302.         return NGX_HTTP_BAD_REQUEST;
  4303.     }

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

  4307.     if (rc != NGX_OK && rc != NGX_AGAIN) {
  4308.         stream->skip_data = 1;
  4309.         return rc;
  4310.     }

  4312.     if (rc == NGX_OK) {
  4313.         return NGX_OK;
  4314.     }

  4316.     if (r->request_body->rest == 0) {
  4317.         return NGX_AGAIN;
  4318.     }

  4320.     if (r->request_body->busy != NULL) {
  4321.         return NGX_AGAIN;
  4322.     }

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

  4326.     buf->pos = buf->start;
  4327.     buf->last = buf->start;

  4329.     window = buf->end - buf->start;
  4330.     h2c = stream->connection;

  4332.     if (h2c->state.stream == stream) {
  4333.         window -= h2c->state.length;
  4334.     }

  4336.     if (window <= stream->recv_window) {
  4337.         if (window < stream->recv_window) {
  4338.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  4339.                           "http2 negative window update");
  4340.             stream->skip_data = 1;
  4341.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4342.         }

  4344.         return NGX_AGAIN;
  4345.     }

  4347.     if (ngx_http_v2_send_window_update(h2c, stream->node->id,
  4348.                                        window - stream->recv_window)
  4349.         == NGX_ERROR)
  4350.     {
  4351.         stream->skip_data = 1;
  4352.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4353.     }

  4355.     if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4356.         stream->skip_data = 1;
  4357.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4358.     }

  4360.     stream->recv_window = window;

  4362.     return NGX_AGAIN;
  4363. }


  4366. static ngx_int_t
  4367. ‌ngx_http_v2_terminate_stream(ngx_http_v2_connection_t *h2c,
  4368.     ngx_http_v2_stream_t *stream, ngx_uint_t status)
  4369. {
  4370.     ngx_event_t       *rev;
  4371.     ngx_connection_t  *fc;

  4373.     if (stream->rst_sent) {
  4374.         return NGX_OK;
  4375.     }

  4377.     if (ngx_http_v2_send_rst_stream(h2c, stream->node->id, status)
  4378.         == NGX_ERROR)
  4379.     {
  4380.         return NGX_ERROR;
  4381.     }

  4383.     stream->rst_sent = 1;
  4384.     stream->skip_data = 1;

  4386.     fc = stream->request->connection;
  4387.     fc->error = 1;

  4389.     rev = fc->read;
  4390.     rev->handler(rev);

  4392.     return NGX_OK;
  4393. }


  4396. void
  4397. ‌ngx_http_v2_close_stream(ngx_http_v2_stream_t *stream, ngx_int_t rc)
  4398. {
  4399.     ngx_pool_t                *pool;
  4400.     ngx_event_t               *ev;
  4401.     ngx_connection_t          *fc;
  4402.     ngx_http_v2_node_t        *node;
  4403.     ngx_http_v2_connection_t  *h2c;

  4405.     h2c = stream->connection;
  4406.     node = stream->node;

  4408.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  4409.                    "http2 close stream %ui, queued %ui, processing %ui",
  4410.                    node->id, stream->queued, h2c->processing);

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

  4414.     if (stream->queued) {
  4415.         fc->error = 1;
  4416.         fc->write->handler = ngx_http_v2_retry_close_stream_handler;
  4417.         fc->read->handler = ngx_http_v2_retry_close_stream_handler;
  4418.         return;
  4419.     }

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

  4423.         if (!stream->out_closed) {
  4424.             if (ngx_http_v2_send_rst_stream(h2c, node->id,
  4425.                                       fc->timedout ? NGX_HTTP_V2_PROTOCOL_ERROR
  4426.                                                    : NGX_HTTP_V2_INTERNAL_ERROR)
  4427.                 != NGX_OK)
  4428.             {
  4429.                 h2c->connection->error = 1;
  4430.             }

  4432.         } else if (!stream->in_closed) {
  4433.             if (ngx_http_v2_send_rst_stream(h2c, node->id, NGX_HTTP_V2_NO_ERROR)
  4434.                 != NGX_OK)
  4435.             {
  4436.                 h2c->connection->error = 1;
  4437.             }
  4438.         }
  4439.     }

  4441.     if (h2c->state.stream == stream) {
  4442.         h2c->state.stream = NULL;
  4443.     }

  4445.     node->stream = NULL;

  4447.     ngx_queue_insert_tail(&h2c->closed, &node->reuse);
  4448.     h2c->closed_nodes++;

  4450.     /*
  4451.      * This pool keeps decoded request headers which can be used by log phase
  4452.      * handlers in ngx_http_free_request().
  4453.      *
  4454.      * The pointer is stored into local variable because the stream object
  4455.      * will be destroyed after a call to ngx_http_free_request().
  4456.      */
  4457.     pool = stream->pool;

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

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

  4463.     if (pool != h2c->state.pool) {
  4464.         ngx_destroy_pool(pool);

  4466.     } else {
  4467.         /* pool will be destroyed when the complete header is parsed */
  4468.         h2c->state.keep_pool = 0;
  4469.     }

  4471.     ev = fc->read;

  4473.     if (ev->timer_set) {
  4474.         ngx_del_timer(ev);
  4475.     }

  4477.     if (ev->posted) {
  4478.         ngx_delete_posted_event(ev);
  4479.     }

  4481.     ev = fc->write;

  4483.     if (ev->timer_set) {
  4484.         ngx_del_timer(ev);
  4485.     }

  4487.     if (ev->posted) {
  4488.         ngx_delete_posted_event(ev);
  4489.     }

  4491.     fc->data = h2c->free_fake_connections;
  4492.     h2c->free_fake_connections = fc;

  4494.     h2c->processing--;

  4496.     if (h2c->processing || h2c->blocked) {
  4497.         return;
  4498.     }

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

  4502.     ev->handler = ngx_http_v2_handle_connection_handler;
  4503.     ngx_post_event(ev, &ngx_posted_events);
  4504. }


  4507. static void
  4508. ‌ngx_http_v2_close_stream_handler(ngx_event_t *ev)
  4509. {
  4510.     ngx_connection_t    *fc;
  4511.     ngx_http_request_t  *r;

  4513.     fc = ev->data;
  4514.     r = fc->data;

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

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

  4522.         fc->timedout = 1;

  4524.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_REQUEST_TIME_OUT);
  4525.         return;
  4526.     }

  4528.     ngx_http_v2_close_stream(r->stream, 0);
  4529. }


  4532. static void
  4533. ‌ngx_http_v2_retry_close_stream_handler(ngx_event_t *ev)
  4534. {
  4535.     ngx_connection_t    *fc;
  4536.     ngx_http_request_t  *r;

  4538.     fc = ev->data;
  4539.     r = fc->data;

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

  4544.     ngx_http_v2_close_stream(r->stream, 0);
  4545. }


  4548. static void
  4549. ‌ngx_http_v2_handle_connection_handler(ngx_event_t *rev)
  4550. {
  4551.     ngx_connection_t          *c;
  4552.     ngx_http_v2_connection_t  *h2c;

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

  4557.     c = rev->data;
  4558.     h2c = c->data;

  4560.     if (c->error) {
  4561.         ngx_http_v2_finalize_connection(h2c, 0);
  4562.         return;
  4563.     }

  4565.     rev->handler = ngx_http_v2_read_handler;

  4567.     if (rev->ready) {
  4568.         ngx_http_v2_read_handler(rev);
  4569.         return;
  4570.     }

  4572.     if (h2c->last_out && ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4573.         ngx_http_v2_finalize_connection(h2c, 0);
  4574.         return;
  4575.     }

  4577.     ngx_http_v2_handle_connection(c->data);
  4578. }


  4581. static void
  4582. ‌ngx_http_v2_idle_handler(ngx_event_t *rev)
  4583. {
  4584.     ngx_connection_t          *c;
  4585.     ngx_http_v2_srv_conf_t    *h2scf;
  4586.     ngx_http_v2_connection_t  *h2c;
  4587.     ngx_http_core_loc_conf_t  *clcf;

  4589.     c = rev->data;
  4590.     h2c = c->data;

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

  4594.     if (rev->timedout || c->close) {
  4595.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  4596.         return;
  4597.     }

  4599. #if (NGX_HAVE_KQUEUE)

  4601.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  4602.         if (rev->pending_eof) {
  4603.             c->log->handler = NULL;
  4604.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  4605.                           "kevent() reported that client %V closed "
  4606.                           "idle connection", &c->addr_text);
  4607. #if (NGX_HTTP_SSL)
  4608.             if (c->ssl) {
  4609.                 c->ssl->no_send_shutdown = 1;
  4610.             }
  4611. #endif
  4612.             ngx_http_close_connection(c);
  4613.             return;
  4614.         }
  4615.     }

  4617. #endif

  4619.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  4620.                                         ngx_http_core_module);

  4622.     if (h2c->idle++ > 10 * clcf->keepalive_requests) {
  4623.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  4624.                       "http2 flood detected");
  4625.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  4626.         return;
  4627.     }

  4629.     c->destroyed = 0;
  4630.     ngx_reusable_connection(c, 0);

  4632.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4633.                                          ngx_http_v2_module);

  4635.     h2c->pool = ngx_create_pool(h2scf->pool_size, h2c->connection->log);
  4636.     if (h2c->pool == NULL) {
  4637.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  4638.         return;
  4639.     }

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

  4643.     rev->handler = ngx_http_v2_read_handler;
  4644.     ngx_http_v2_read_handler(rev);
  4645. }


  4648. static void
  4649. ‌ngx_http_v2_finalize_connection(ngx_http_v2_connection_t *h2c,
  4650.     ngx_uint_t status)
  4651. {
  4652.     ngx_uint_t               i, size;
  4653.     ngx_event_t             *ev;
  4654.     ngx_connection_t        *c, *fc;
  4655.     ngx_http_request_t      *r;
  4656.     ngx_http_v2_node_t      *node;
  4657.     ngx_http_v2_stream_t    *stream;
  4658.     ngx_http_v2_srv_conf_t  *h2scf;

  4660.     c = h2c->connection;

  4662.     h2c->blocked = 1;

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

  4667.         if (ngx_http_v2_send_goaway(h2c, status) != NGX_ERROR) {
  4668.             (void) ngx_http_v2_send_output_queue(h2c);
  4669.         }
  4670.     }

  4672.     if (!h2c->processing) {
  4673.         goto done;
  4674.     }

  4676.     c->read->handler = ngx_http_empty_handler;
  4677.     c->write->handler = ngx_http_empty_handler;

  4679.     h2c->last_out = NULL;

  4681.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4682.                                          ngx_http_v2_module);

  4684.     size = ngx_http_v2_index_size(h2scf);

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

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

  4691.             if (stream == NULL) {
  4692.                 continue;
  4693.             }

  4695.             stream->waiting = 0;

  4697.             r = stream->request;
  4698.             fc = r->connection;

  4700.             fc->error = 1;

  4702.             if (stream->queued) {
  4703.                 stream->queued = 0;

  4705.                 ev = fc->write;
  4706.                 ev->active = 0;
  4707.                 ev->ready = 1;

  4709.             } else {
  4710.                 ev = fc->read;
  4711.             }

  4713.             ev->eof = 1;
  4714.             ev->handler(ev);
  4715.         }
  4716.     }

  4718.     h2c->blocked = 0;

  4720.     if (h2c->processing) {
  4721.         c->error = 1;
  4722.         return;
  4723.     }

  4725. done:

  4727.     if (c->error) {
  4728.         ngx_http_close_connection(c);
  4729.         return;
  4730.     }

  4732.     ngx_http_v2_lingering_close(c);
  4733. }


  4736. static ngx_int_t
  4737. ‌ngx_http_v2_adjust_windows(ngx_http_v2_connection_t *h2c, ssize_t delta)
  4738. {
  4739.     ngx_uint_t               i, size;
  4740.     ngx_event_t             *wev;
  4741.     ngx_http_v2_node_t      *node;
  4742.     ngx_http_v2_stream_t    *stream;
  4743.     ngx_http_v2_srv_conf_t  *h2scf;

  4745.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4746.                                          ngx_http_v2_module);

  4748.     size = ngx_http_v2_index_size(h2scf);

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

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

  4755.             if (stream == NULL) {
  4756.                 continue;
  4757.             }

  4759.             if (delta > 0
  4760.                 && stream->send_window
  4761.                       > (ssize_t) (NGX_HTTP_V2_MAX_WINDOW - delta))
  4762.             {
  4763.                 if (ngx_http_v2_terminate_stream(h2c, stream,
  4764.                                                  NGX_HTTP_V2_FLOW_CTRL_ERROR)
  4765.                     == NGX_ERROR)
  4766.                 {
  4767.                     return NGX_ERROR;
  4768.                 }

  4770.                 continue;
  4771.             }

  4773.             stream->send_window += delta;

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

  4779.             if (stream->send_window > 0 && stream->exhausted) {
  4780.                 stream->exhausted = 0;

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

  4784.                 wev->active = 0;
  4785.                 wev->ready = 1;

  4787.                 if (!wev->delayed) {
  4788.                     wev->handler(wev);
  4789.                 }
  4790.             }
  4791.         }
  4792.     }

  4794.     return NGX_OK;
  4795. }


  4798. static void
  4799. ‌ngx_http_v2_set_dependency(ngx_http_v2_connection_t *h2c,
  4800.     ngx_http_v2_node_t *node, ngx_uint_t depend, ngx_uint_t exclusive)
  4801. {
  4802.     ngx_queue_t         *children, *q;
  4803.     ngx_http_v2_node_t  *parent, *child, *next;

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

  4807.     if (parent == NULL) {
  4808.         parent = NGX_HTTP_V2_ROOT;

  4810.         if (depend != 0) {
  4811.             exclusive = 0;
  4812.         }

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

  4817.         children = &h2c->dependencies;

  4819.     } else {
  4820.         if (node->parent != NULL) {

  4822.             for (next = parent->parent;
  4823.                  next != NGX_HTTP_V2_ROOT && next->rank >= node->rank;
  4824.                  next = next->parent)
  4825.             {
  4826.                 if (next != node) {
  4827.                     continue;
  4828.                 }

  4830.                 ngx_queue_remove(&parent->queue);
  4831.                 ngx_queue_insert_after(&node->queue, &parent->queue);

  4833.                 parent->parent = node->parent;

  4835.                 if (node->parent == NGX_HTTP_V2_ROOT) {
  4836.                     parent->rank = 1;
  4837.                     parent->rel_weight = (1.0 / 256) * parent->weight;

  4839.                 } else {
  4840.                     parent->rank = node->parent->rank + 1;
  4841.                     parent->rel_weight = (node->parent->rel_weight / 256)
  4842.                                          * parent->weight;
  4843.                 }

  4845.                 if (!exclusive) {
  4846.                     ngx_http_v2_node_children_update(parent);
  4847.                 }

  4849.                 break;
  4850.             }
  4851.         }

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

  4856.         if (parent->stream == NULL) {
  4857.             ngx_queue_remove(&parent->reuse);
  4858.             ngx_queue_insert_tail(&h2c->closed, &parent->reuse);
  4859.         }

  4861.         children = &parent->children;
  4862.     }

  4864.     if (exclusive) {
  4865.         for (q = ngx_queue_head(children);
  4866.              q != ngx_queue_sentinel(children);
  4867.              q = ngx_queue_next(q))
  4868.         {
  4869.             child = ngx_queue_data(q, ngx_http_v2_node_t, queue);
  4870.             child->parent = node;
  4871.         }

  4873.         ngx_queue_add(&node->children, children);
  4874.         ngx_queue_init(children);
  4875.     }

  4877.     if (node->parent != NULL) {
  4878.         ngx_queue_remove(&node->queue);
  4879.     }

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

  4883.     node->parent = parent;

  4885.     ngx_http_v2_node_children_update(node);
  4886. }


  4889. static void
  4890. ‌ngx_http_v2_node_children_update(ngx_http_v2_node_t *node)
  4891. {
  4892.     ngx_queue_t         *q;
  4893.     ngx_http_v2_node_t  *child;

  4895.     for (q = ngx_queue_head(&node->children);
  4896.          q != ngx_queue_sentinel(&node->children);
  4897.          q = ngx_queue_next(q))
  4898.     {
  4899.         child = ngx_queue_data(q, ngx_http_v2_node_t, queue);

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

  4904.         ngx_http_v2_node_children_update(child);
  4905.     }
  4906. }


  4909. static void
  4910. ‌ngx_http_v2_pool_cleanup(void *data)
  4911. {
  4912.     ngx_http_v2_connection_t  *h2c = data;

  4914.     if (h2c->state.pool) {
  4915.         ngx_destroy_pool(h2c->state.pool);
  4916.     }

  4918.     if (h2c->pool) {
  4919.         ngx_destroy_pool(h2c->pool);
  4920.     }
  4921. }

One Level Up Top Level