One Level Up Top Level

src/http/v2/ngx_http_v2.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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
  46. ‌#define NGX_HTTP_V2_NO_PRIORITIES_SETTING        0x9

  48. ‌#define NGX_HTTP_V2_FRAME_BUFFER_SIZE            24


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

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

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

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

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

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

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

  172. static ngx_int_t ngx_http_v2_terminate_stream(ngx_http_v2_connection_t *h2c,
  173.     ngx_http_v2_stream_t *stream, ngx_uint_t status);
  174. static void ngx_http_v2_close_stream_handler(ngx_event_t *ev);
  175. static void ngx_http_v2_retry_close_stream_handler(ngx_event_t *ev);
  176. static void ngx_http_v2_handle_connection_handler(ngx_event_t *rev);
  177. static void ngx_http_v2_idle_handler(ngx_event_t *rev);
  178. static void ngx_http_v2_finalize_connection(ngx_http_v2_connection_t *h2c,
  179.     ngx_uint_t status);

  181. static ngx_int_t ngx_http_v2_adjust_windows(ngx_http_v2_connection_t *h2c,
  182.     ssize_t delta);

  184. static void ngx_http_v2_pool_cleanup(void *data);


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

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


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

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

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

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

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

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

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

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

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

  246.     h2c->init_window = NGX_HTTP_V2_DEFAULT_WINDOW;

  248.     h2c->frame_size = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;

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

  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->closed);

  292.     c->data = h2c;

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

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

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

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

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

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

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

  322.         } while (p != end);

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

  328.     ngx_http_v2_read_handler(rev);
  329. }


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

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

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

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

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

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

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

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

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

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

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

  385.         h2c->blocked = 0;

  387.         return;
  388.     }

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

  393.     available = h2mcf->recv_buffer_size - NGX_HTTP_V2_STATE_BUFFER_SIZE;

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

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

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

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

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

  416.         end += n;

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

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

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

  428.         } while (p != end);

  430.         h2c->total_bytes += n;

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

  438.     } while (rev->ready);

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

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

  450.     h2c->blocked = 0;

  452.     ngx_http_v2_handle_connection(h2c);
  453. }


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

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

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

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

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

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

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

  487.     h2c->blocked = 1;

  489.     rc = ngx_http_v2_send_output_queue(h2c);

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

  496.     h2c->blocked = 0;

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

  502.     ngx_http_v2_handle_connection(h2c);
  503. }


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

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

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

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

  527.     cl = NULL;
  528.     out = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  588.     frame = NULL;

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

  596.     h2c->last_out = frame;

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

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

  607.     return NGX_OK;

  609. error:

  611.     c->error = 1;

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

  617.     return NGX_ERROR;
  618. }


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

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

  632.     c = h2c->connection;

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

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

  642.         rc = ngx_http_v2_send_output_queue(h2c);

  644.         h2c->blocked = 0;

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

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

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

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

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

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

  670.     ngx_reusable_connection(c, 1);

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

  676.     ngx_destroy_pool(h2c->pool);

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

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

  689.     c->destroyed = 1;

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

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


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

  707.     h2c = c->data;

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

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

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

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

  726.         rc = ngx_ssl_shutdown(c);

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

  817.     } while (rev->ready);

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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


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

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

  892.     head = ngx_http_v2_parse_uint32(pos);

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

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

  899.     pos += NGX_HTTP_V2_FRAME_HEADER_SIZE;

  901.     type = ngx_http_v2_parse_type(head);

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

  907.     if (type >= NGX_HTTP_V2_FRAME_STATES) {

  909.         if (type == NGX_HTTP_V2_PRIORITY_UPDATE_FRAME) {
  910.             return ngx_http_v2_state_priority_update(h2c, pos, end);
  911.         }

  913.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  914.                       "client sent frame with unknown type %ui", type);
  915.         return ngx_http_v2_state_skip(h2c, pos, end);
  916.     }

  918.     return ngx_http_v2_frame_states[type](h2c, pos, end);
  919. }


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

  929.     size = h2c->state.length;

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

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

  938.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  939.         }

  941.         if (end - pos == 0) {
  942.             return ngx_http_v2_state_save(h2c, pos, end,
  943.                                           ngx_http_v2_state_data);
  944.         }

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

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

  954.             return ngx_http_v2_connection_error(h2c,
  955.                                                 NGX_HTTP_V2_PROTOCOL_ERROR);
  956.         }

  958.         h2c->state.length -= 1 + h2c->state.padding;
  959.     }

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

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

  968.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  969.     }

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

  977.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
  978.     }

  980.     h2c->recv_window -= size;

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

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

  992.         h2c->recv_window = NGX_HTTP_V2_MAX_WINDOW;
  993.     }

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

  997.     if (node == NULL || node->stream == NULL) {
  998.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  999.                        "unknown http2 stream");

  1001.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1002.     }

  1004.     stream = node->stream;

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

  1012.         if (ngx_http_v2_terminate_stream(h2c, stream,
  1013.                                          NGX_HTTP_V2_FLOW_CTRL_ERROR)
  1014.             == NGX_ERROR)
  1015.         {
  1016.             return ngx_http_v2_connection_error(h2c,
  1017.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1018.         }

  1020.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1021.     }

  1023.     stream->recv_window -= size;

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

  1037.         stream->recv_window = NGX_HTTP_V2_MAX_WINDOW;
  1038.     }

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

  1045.         if (ngx_http_v2_terminate_stream(h2c, stream,
  1046.                                          NGX_HTTP_V2_STREAM_CLOSED)
  1047.             == NGX_ERROR)
  1048.         {
  1049.             return ngx_http_v2_connection_error(h2c,
  1050.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1051.         }

  1053.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1054.     }

  1056.     h2c->state.stream = stream;

  1058.     return ngx_http_v2_state_read_data(h2c, pos, end);
  1059. }


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

  1074.     stream = h2c->state.stream;

  1076.     if (stream == NULL) {
  1077.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1078.     }

  1080.     if (stream->skip_data) {
  1081.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1082.                        "skipping http2 DATA frame");

  1084.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1085.     }

  1087.     r = stream->request;
  1088.     fc = r->connection;

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

  1094.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1095.     }

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

  1101.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1102.     }

  1104.     size = end - pos;

  1106.     if (size >= h2c->state.length) {
  1107.         size = h2c->state.length;
  1108.         stream->in_closed = h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG;
  1109.     }

  1111.     h2c->payload_bytes += size;

  1113.     if (r->request_body) {
  1114.         rc = ngx_http_v2_process_request_body(r, pos, size,
  1115.                                               stream->in_closed, 0);

  1117.         if (rc != NGX_OK && rc != NGX_AGAIN) {
  1118.             stream->skip_data = 1;
  1119.             ngx_http_finalize_request(r, rc);
  1120.         }

  1122.         ngx_http_run_posted_requests(fc);

  1124.     } else if (size) {
  1125.         buf = stream->preread;

  1127.         if (buf == NULL) {
  1128.             h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

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

  1136.             stream->preread = buf;
  1137.         }

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

  1146.         buf->last = ngx_cpymem(buf->last, pos, size);
  1147.     }

  1149.     pos += size;
  1150.     h2c->state.length -= size;

  1152.     if (h2c->state.length) {
  1153.         return ngx_http_v2_state_save(h2c, pos, end,
  1154.                                       ngx_http_v2_state_read_data);
  1155.     }

  1157.     if (h2c->state.padding) {
  1158.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1159.     }

  1161.     return ngx_http_v2_state_complete(h2c, pos, end);
  1162. }


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

  1178.     padded = h2c->state.flags & NGX_HTTP_V2_PADDED_FLAG;
  1179.     priority = h2c->state.flags & NGX_HTTP_V2_PRIORITY_FLAG;

  1181.     size = 0;

  1183.     if (padded) {
  1184.         size++;
  1185.     }

  1187.     if (priority) {
  1188.         size += sizeof(uint32_t) + 1;
  1189.     }

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

  1196.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1197.     }

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

  1203.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1204.     }

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

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

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

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

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

  1228.             return ngx_http_v2_connection_error(h2c,
  1229.                                                 NGX_HTTP_V2_PROTOCOL_ERROR);
  1230.         }

  1232.         h2c->state.length -= h2c->state.padding;
  1233.     }

  1235.     if (priority) {
  1236.         /* skip the ignored RFC 7540 priority data */
  1237.         pos += sizeof(uint32_t) + 1;
  1238.     }

  1240.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1241.                    "http2 HEADERS frame sid:%ui", h2c->state.sid);

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

  1248.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1249.     }

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

  1253.     h2c->state.pool = ngx_create_pool(1024, h2c->connection->log);
  1254.     if (h2c->state.pool == NULL) {
  1255.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1256.     }

  1258.     cscf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  1259.                                         ngx_http_core_module);

  1261.     h2c->state.header_limit = cscf->large_client_header_buffers.size
  1262.                               * cscf->large_client_header_buffers.num;

  1264.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  1265.                                          ngx_http_v2_module);

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

  1271.         status = NGX_HTTP_V2_REFUSED_STREAM;
  1272.         goto rst_stream;
  1273.     }

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

  1279.         status = NGX_HTTP_V2_REFUSED_STREAM;
  1280.         goto rst_stream;
  1281.     }

  1283.     if (!h2c->settings_ack
  1284.         && !(h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG)
  1285.         && h2scf->preread_size < NGX_HTTP_V2_DEFAULT_WINDOW)
  1286.     {
  1287.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1288.                       "client sent stream with data "
  1289.                       "before settings were acknowledged");

  1291.         status = NGX_HTTP_V2_REFUSED_STREAM;
  1292.         goto rst_stream;
  1293.     }

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

  1297.     if (node == NULL) {
  1298.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1299.     }

  1301.     if (node->priority_set) {
  1302.         ngx_queue_remove(&node->reuse);
  1303.         h2c->closed_nodes--;
  1304.     }

  1306.     stream = ngx_http_v2_create_stream(h2c);
  1307.     if (stream == NULL) {
  1308.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1309.     }

  1311.     h2c->state.stream = stream;

  1313.     stream->pool = h2c->state.pool;
  1314.     h2c->state.keep_pool = 1;

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

  1318.     stream->in_closed = h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG;
  1319.     stream->node = node;

  1321.     node->stream = stream;

  1323.     /* a PRIORITY_UPDATE may have arrived before HEADERS */

  1325.     if (node->priority_set) {
  1326.         stream->priority.client = node->priority;
  1327.         node->priority_set = 0;
  1328.         stream->priority_update = 1;

  1330.         ngx_http_priority_state_update(&stream->priority);

  1332.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  1333.                        "http2 buffered priority: u=%ud i=%ud",
  1334.                        stream->priority.effective.urgency,
  1335.                        stream->priority.effective.incremental);
  1336.     }

  1338.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  1339.                                         ngx_http_core_module);

  1341.     if (clcf->keepalive_timeout == 0
  1342.         || h2c->connection->requests >= clcf->keepalive_requests
  1343.         || ngx_current_msec - h2c->connection->start_time
  1344.            > clcf->keepalive_time)
  1345.     {
  1346.         h2c->goaway = 1;

  1348.         if (ngx_http_v2_send_goaway(h2c, NGX_HTTP_V2_NO_ERROR) == NGX_ERROR) {
  1349.             return ngx_http_v2_connection_error(h2c,
  1350.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1351.         }
  1352.     }

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

  1356. rst_stream:

  1358.     if (h2c->refused_streams++ > ngx_max(h2scf->concurrent_streams, 100)) {
  1359.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1360.                       "client sent too many refused streams");
  1361.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_NO_ERROR);
  1362.     }

  1364.     if (ngx_http_v2_send_rst_stream(h2c, h2c->state.sid, status) != NGX_OK) {
  1365.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1366.     }

  1368.     return ngx_http_v2_state_header_block(h2c, pos, end);
  1369. }


  1372. static u_char *
  1373. ‌ngx_http_v2_state_header_block(ngx_http_v2_connection_t *h2c, u_char *pos,
  1374.     u_char *end)
  1375. {
  1376.     u_char      ch;
  1377.     ngx_int_t   value;
  1378.     ngx_uint_t  indexed, size_update, prefix;

  1380.     if (end - pos < 1) {
  1381.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1382.                                               ngx_http_v2_state_header_block);
  1383.     }

  1385.     if (!(h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG)
  1386.         && h2c->state.length < NGX_HTTP_V2_INT_OCTETS)
  1387.     {
  1388.         return ngx_http_v2_handle_continuation(h2c, pos, end,
  1389.                                                ngx_http_v2_state_header_block);
  1390.     }

  1392.     size_update = 0;
  1393.     indexed = 0;

  1395.     ch = *pos;

  1397.     if (ch >= (1 << 7)) {
  1398.         /* indexed header field */
  1399.         indexed = 1;
  1400.         prefix = ngx_http_v2_prefix(7);

  1402.     } else if (ch >= (1 << 6)) {
  1403.         /* literal header field with incremental indexing */
  1404.         h2c->state.index = 1;
  1405.         prefix = ngx_http_v2_prefix(6);

  1407.     } else if (ch >= (1 << 5)) {
  1408.         /* dynamic table size update */
  1409.         size_update = 1;
  1410.         prefix = ngx_http_v2_prefix(5);

  1412.     } else if (ch >= (1 << 4)) {
  1413.         /* literal header field never indexed */
  1414.         prefix = ngx_http_v2_prefix(4);

  1416.     } else {
  1417.         /* literal header field without indexing */
  1418.         prefix = ngx_http_v2_prefix(4);
  1419.     }

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

  1423.     if (value < 0) {
  1424.         if (value == NGX_AGAIN) {
  1425.             return ngx_http_v2_state_headers_save(h2c, pos, end,
  1426.                                                ngx_http_v2_state_header_block);
  1427.         }

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

  1434.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1435.         }

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

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

  1443.     if (indexed) {
  1444.         if (ngx_http_v2_get_indexed_header(h2c, value, 0) != NGX_OK) {
  1445.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1446.         }

  1448.         return ngx_http_v2_state_process_header(h2c, pos, end);
  1449.     }

  1451.     if (size_update) {
  1452.         if (ngx_http_v2_table_size(h2c, value) != NGX_OK) {
  1453.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1454.         }

  1456.         return ngx_http_v2_state_header_complete(h2c, pos, end);
  1457.     }

  1459.     if (value == 0) {
  1460.         h2c->state.parse_name = 1;

  1462.     } else if (ngx_http_v2_get_indexed_header(h2c, value, 1) != NGX_OK) {
  1463.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1464.     }

  1466.     h2c->state.parse_value = 1;

  1468.     return ngx_http_v2_state_field_len(h2c, pos, end);
  1469. }


  1472. static u_char *
  1473. ‌ngx_http_v2_state_field_len(ngx_http_v2_connection_t *h2c, u_char *pos,
  1474.     u_char *end)
  1475. {
  1476.     size_t                     alloc;
  1477.     ngx_int_t                  len;
  1478.     ngx_uint_t                 huff;
  1479.     ngx_http_core_srv_conf_t  *cscf;

  1481.     if (!(h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG)
  1482.         && h2c->state.length < NGX_HTTP_V2_INT_OCTETS)
  1483.     {
  1484.         return ngx_http_v2_handle_continuation(h2c, pos, end,
  1485.                                                ngx_http_v2_state_field_len);
  1486.     }

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

  1492.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1493.     }

  1495.     if (end - pos < 1) {
  1496.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1497.                                               ngx_http_v2_state_field_len);
  1498.     }

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

  1503.     if (len < 0) {
  1504.         if (len == NGX_AGAIN) {
  1505.             return ngx_http_v2_state_headers_save(h2c, pos, end,
  1506.                                                   ngx_http_v2_state_field_len);
  1507.         }

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

  1513.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1514.         }

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

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

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

  1526.     cscf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  1527.                                         ngx_http_core_module);

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

  1533.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_ENHANCE_YOUR_CALM);
  1534.     }

  1536.     h2c->state.field_rest = len;

  1538.     if (h2c->state.stream == NULL && !h2c->state.index) {
  1539.         return ngx_http_v2_state_field_skip(h2c, pos, end);
  1540.     }

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

  1544.     h2c->state.field_start = ngx_pnalloc(h2c->state.pool, alloc);
  1545.     if (h2c->state.field_start == NULL) {
  1546.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1547.     }

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

  1551.     if (huff) {
  1552.         return ngx_http_v2_state_field_huff(h2c, pos, end);
  1553.     }

  1555.     return ngx_http_v2_state_field_raw(h2c, pos, end);
  1556. }


  1559. static u_char *
  1560. ‌ngx_http_v2_state_field_huff(ngx_http_v2_connection_t *h2c, u_char *pos,
  1561.     u_char *end)
  1562. {
  1563.     size_t  size;

  1565.     size = end - pos;

  1567.     if (size > h2c->state.field_rest) {
  1568.         size = h2c->state.field_rest;
  1569.     }

  1571.     if (size > h2c->state.length) {
  1572.         size = h2c->state.length;
  1573.     }

  1575.     h2c->state.length -= size;
  1576.     h2c->state.field_rest -= size;

  1578.     if (ngx_http_huff_decode(&h2c->state.field_state, pos, size,
  1579.                              &h2c->state.field_end,
  1580.                              h2c->state.field_rest == 0,
  1581.                              h2c->connection->log)
  1582.         != NGX_OK)
  1583.     {
  1584.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1585.                       "client sent invalid encoded header field");

  1587.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_COMP_ERROR);
  1588.     }

  1590.     pos += size;

  1592.     if (h2c->state.field_rest == 0) {
  1593.         *h2c->state.field_end = '\0';
  1594.         return ngx_http_v2_state_process_header(h2c, pos, end);
  1595.     }

  1597.     if (h2c->state.length) {
  1598.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1599.                                               ngx_http_v2_state_field_huff);
  1600.     }

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

  1606.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1607.     }

  1609.     return ngx_http_v2_handle_continuation(h2c, pos, end,
  1610.                                            ngx_http_v2_state_field_huff);
  1611. }


  1614. static u_char *
  1615. ‌ngx_http_v2_state_field_raw(ngx_http_v2_connection_t *h2c, u_char *pos,
  1616.     u_char *end)
  1617. {
  1618.     size_t  size;

  1620.     size = end - pos;

  1622.     if (size > h2c->state.field_rest) {
  1623.         size = h2c->state.field_rest;
  1624.     }

  1626.     if (size > h2c->state.length) {
  1627.         size = h2c->state.length;
  1628.     }

  1630.     h2c->state.length -= size;
  1631.     h2c->state.field_rest -= size;

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

  1635.     pos += size;

  1637.     if (h2c->state.field_rest == 0) {
  1638.         *h2c->state.field_end = '\0';
  1639.         return ngx_http_v2_state_process_header(h2c, pos, end);
  1640.     }

  1642.     if (h2c->state.length) {
  1643.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1644.                                               ngx_http_v2_state_field_raw);
  1645.     }

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

  1651.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1652.     }

  1654.     return ngx_http_v2_handle_continuation(h2c, pos, end,
  1655.                                            ngx_http_v2_state_field_raw);
  1656. }


  1659. static u_char *
  1660. ‌ngx_http_v2_state_field_skip(ngx_http_v2_connection_t *h2c, u_char *pos,
  1661.     u_char *end)
  1662. {
  1663.     size_t  size;

  1665.     size = end - pos;

  1667.     if (size > h2c->state.field_rest) {
  1668.         size = h2c->state.field_rest;
  1669.     }

  1671.     if (size > h2c->state.length) {
  1672.         size = h2c->state.length;
  1673.     }

  1675.     h2c->state.length -= size;
  1676.     h2c->state.field_rest -= size;

  1678.     pos += size;

  1680.     if (h2c->state.field_rest == 0) {
  1681.         return ngx_http_v2_state_process_header(h2c, pos, end);
  1682.     }

  1684.     if (h2c->state.length) {
  1685.         return ngx_http_v2_state_save(h2c, pos, end,
  1686.                                       ngx_http_v2_state_field_skip);
  1687.     }

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

  1693.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  1694.     }

  1696.     return ngx_http_v2_handle_continuation(h2c, pos, end,
  1697.                                            ngx_http_v2_state_field_skip);
  1698. }


  1701. static u_char *
  1702. ‌ngx_http_v2_state_process_header(ngx_http_v2_connection_t *h2c, u_char *pos,
  1703.     u_char *end)
  1704. {
  1705.     size_t                      len;
  1706.     ngx_int_t                   rc;
  1707.     ngx_table_elt_t            *h;
  1708.     ngx_connection_t           *fc;
  1709.     ngx_http_header_t          *hh;
  1710.     ngx_http_request_t         *r;
  1711.     ngx_http_v2_header_t       *header;
  1712.     ngx_http_core_srv_conf_t   *cscf;
  1713.     ngx_http_core_main_conf_t  *cmcf;

  1715.     static ngx_str_t cookie = ngx_string("cookie");
  1716.     static ngx_str_t priority = ngx_string("priority");

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

  1720.     if (h2c->state.parse_name) {
  1721.         h2c->state.parse_name = 0;

  1723.         header->name.len = h2c->state.field_end - h2c->state.field_start;
  1724.         header->name.data = h2c->state.field_start;

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

  1730.             return ngx_http_v2_connection_error(h2c,
  1731.                                                 NGX_HTTP_V2_PROTOCOL_ERROR);
  1732.         }

  1734.         return ngx_http_v2_state_field_len(h2c, pos, end);
  1735.     }

  1737.     if (h2c->state.parse_value) {
  1738.         h2c->state.parse_value = 0;

  1740.         header->value.len = h2c->state.field_end - h2c->state.field_start;
  1741.         header->value.data = h2c->state.field_start;
  1742.     }

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

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

  1750.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_ENHANCE_YOUR_CALM);
  1751.     }

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

  1755.     if (h2c->state.index) {
  1756.         if (ngx_http_v2_add_header(h2c, header) != NGX_OK) {
  1757.             return ngx_http_v2_connection_error(h2c,
  1758.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  1759.         }

  1761.         h2c->state.index = 0;
  1762.     }

  1764.     if (h2c->state.stream == NULL) {
  1765.         return ngx_http_v2_state_header_complete(h2c, pos, end);
  1766.     }

  1768.     r = h2c->state.stream->request;
  1769.     fc = r->connection;

  1771.     /* TODO Optimization: validate headers while parsing. */
  1772.     if (ngx_http_v2_validate_header(r, header) != NGX_OK) {
  1773.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1774.         goto error;
  1775.     }

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

  1780.         if (rc == NGX_OK) {
  1781.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1782.                            "http2 header: \":%V: %V\"",
  1783.                            &header->name, &header->value);

  1785.             return ngx_http_v2_state_header_complete(h2c, pos, end);
  1786.         }

  1788.         if (rc == NGX_ABORT) {
  1789.             goto error;
  1790.         }

  1792.         if (rc == NGX_DECLINED) {
  1793.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1794.             goto error;
  1795.         }

  1797.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  1798.     }

  1800.     if (ngx_http_v2_construct_request_line(r) != NGX_OK) {
  1801.         goto error;
  1802.     }

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

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

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

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

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

  1832.     } else {
  1833.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

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

  1848.         h->key.len = header->name.len;
  1849.         h->key.data = header->name.data;

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

  1857.         h->value.len = header->value.len;
  1858.         h->value.data = header->value.data;

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

  1862.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  1867.         if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1868.             goto error;
  1869.         }
  1870.     }

  1872.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1873.                    "http2 header: \"%V: %V\"",
  1874.                    &header->name, &header->value);

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

  1878. error:

  1880.     h2c->state.stream = NULL;

  1882.     ngx_http_run_posted_requests(fc);

  1884.     return ngx_http_v2_state_header_complete(h2c, pos, end);
  1885. }


  1888. static u_char *
  1889. ‌ngx_http_v2_state_header_complete(ngx_http_v2_connection_t *h2c, u_char *pos,
  1890.     u_char *end)
  1891. {
  1892.     ngx_http_v2_stream_t  *stream;

  1894.     if (h2c->state.length) {
  1895.         if (end - pos > 0) {
  1896.             h2c->state.handler = ngx_http_v2_state_header_block;
  1897.             return pos;
  1898.         }

  1900.         return ngx_http_v2_state_headers_save(h2c, pos, end,
  1901.                                               ngx_http_v2_state_header_block);
  1902.     }

  1904.     if (!(h2c->state.flags & NGX_HTTP_V2_END_HEADERS_FLAG)) {
  1905.         return ngx_http_v2_handle_continuation(h2c, pos, end,
  1906.                                              ngx_http_v2_state_header_complete);
  1907.     }

  1909.     stream = h2c->state.stream;

  1911.     if (stream) {
  1912.         ngx_http_v2_run_request(stream->request);
  1913.     }

  1915.     if (!h2c->state.keep_pool) {
  1916.         ngx_destroy_pool(h2c->state.pool);
  1917.     }

  1919.     h2c->state.pool = NULL;
  1920.     h2c->state.keep_pool = 0;

  1922.     if (h2c->state.padding) {
  1923.         return ngx_http_v2_state_skip_padded(h2c, pos, end);
  1924.     }

  1926.     return ngx_http_v2_state_complete(h2c, pos, end);
  1927. }


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

  1938.     len = h2c->state.length;

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

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

  1945.         p = pos;
  1946.         pos += skip;
  1947.         ngx_memmove(pos, p, len);
  1948.     }

  1950.     if ((size_t) (end - pos) < len + NGX_HTTP_V2_FRAME_HEADER_SIZE) {
  1951.         return ngx_http_v2_state_headers_save(h2c, pos, end, handler);
  1952.     }

  1954.     p = pos + len;

  1956.     head = ngx_http_v2_parse_uint32(p);

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

  1962.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1963.     }

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

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

  1971.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  1972.     }

  1974.     p = pos;
  1975.     pos += NGX_HTTP_V2_FRAME_HEADER_SIZE;

  1977.     ngx_memcpy(pos, p, len);

  1979.     len = ngx_http_v2_parse_length(head);

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

  1983.     if (h2c->state.stream) {
  1984.         h2c->state.stream->request->request_length += len;
  1985.     }

  1987.     h2c->state.handler = handler;
  1988.     return pos;
  1989. }


  1992. static u_char *
  1993. ‌ngx_http_v2_state_priority(ngx_http_v2_connection_t *h2c, u_char *pos,
  1994.     u_char *end)
  1995. {
  1996.     if (h2c->state.length != NGX_HTTP_V2_PRIORITY_SIZE) {
  1997.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  1998.                       "client sent PRIORITY frame with incorrect length %uz",
  1999.                       h2c->state.length);

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

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

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

  2011.     return ngx_http_v2_state_skip(h2c, pos, end);
  2012. }


  2015. static u_char *
  2016. ‌ngx_http_v2_state_priority_update(ngx_http_v2_connection_t *h2c, u_char *pos,
  2017.     u_char *end)
  2018. {
  2019.     size_t                 len;
  2020.     ngx_str_t              value;
  2021.     ngx_uint_t             sid;
  2022.     ngx_http_v2_node_t    *node;
  2023.     ngx_http_priority_t    priority;
  2024.     ngx_http_v2_stream_t  *stream;

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

  2031.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2032.     }

  2034.     if (h2c->state.length < 4) {
  2035.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2036.                       "client sent PRIORITY_UPDATE frame with incorrect "
  2037.                       "length %uz", h2c->state.length);

  2039.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2040.     }

  2042.     len = h2c->state.length;

  2044.     if ((size_t) (end - pos) < len) {

  2046.         if (len > NGX_HTTP_V2_STATE_BUFFER_SIZE) {
  2047.             return ngx_http_v2_state_skip(h2c, pos, end);
  2048.         }

  2050.         return ngx_http_v2_state_save(h2c, pos, end,
  2051.                                       ngx_http_v2_state_priority_update);
  2052.     }

  2054.     sid = ngx_http_v2_parse_sid(pos);

  2056.     if (sid % 2 == 0) {
  2057.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2058.                       "client sent PRIORITY_UPDATE frame with incorrect "
  2059.                       "prioritized stream %ui", sid);

  2061.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2062.     }

  2064.     value.data = pos + 4;
  2065.     value.len = len - 4;

  2067.     pos += len;

  2069.     if (ngx_http_priority_parse(&value, &priority) != NGX_OK) {
  2070.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2071.                       "client sent PRIORITY_UPDATE frame with malformed value "
  2072.                       "for stream %ui", sid);

  2074.         return ngx_http_v2_state_complete(h2c, pos, end);
  2075.     }

  2077.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2078.                    "http2 PRIORITY_UPDATE frame sid:%ui u=%ud i=%ud",
  2079.                    sid, priority.urgency, priority.incremental);

  2081.     /*
  2082.      * A PRIORITY_UPDATE conveys a complete set of parameters (RFC 9218,
  2083.      * Section 7): omitted parameters reset to their defaults, so the result
  2084.      * replaces any earlier signal rather than merging with it.
  2085.      */

  2087.     node = ngx_http_v2_get_node_by_id(h2c, sid, sid > h2c->last_sid);

  2089.     if (sid > h2c->last_sid) {
  2090.         /*
  2091.          * The stream is not created yet; park the node in h2c->closed holding
  2092.          * the buffered priority, bounded by the closed-node budget with the
  2093.          * oldest evicted first.  A node already buffered is moved to the tail.
  2094.          *
  2095.          * RFC 9218, Section 7.1, bounds idle prioritized streams together with
  2096.          * active ones and requires a connection error on overflow; here idle
  2097.          * signals are bounded on their own and the oldest is dropped instead,
  2098.          * which is deliberately more lenient.
  2099.          */

  2101.         if (node == NULL) {
  2102.             return ngx_http_v2_connection_error(h2c,
  2103.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  2104.         }

  2106.         if (node->priority_set) {
  2107.             ngx_queue_remove(&node->reuse);

  2109.         } else {
  2110.             h2c->closed_nodes++;
  2111.         }

  2113.         ngx_queue_insert_tail(&h2c->closed, &node->reuse);

  2115.         node->priority = priority;
  2116.         node->priority_set = 1;

  2118.     } else if (node && node->stream) {
  2119.         stream = node->stream;
  2120.         stream->priority.client = priority;
  2121.         stream->priority_update = 1;
  2122.         ngx_http_priority_state_update(&stream->priority);
  2123.     }

  2125.     return ngx_http_v2_state_complete(h2c, pos, end);
  2126. }


  2129. static u_char *
  2130. ‌ngx_http_v2_state_rst_stream(ngx_http_v2_connection_t *h2c, u_char *pos,
  2131.     u_char *end)
  2132. {
  2133.     ngx_uint_t             status;
  2134.     ngx_event_t           *ev;
  2135.     ngx_connection_t      *fc;
  2136.     ngx_http_v2_node_t    *node;
  2137.     ngx_http_v2_stream_t  *stream;

  2139.     if (h2c->state.length != NGX_HTTP_V2_RST_STREAM_SIZE) {
  2140.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2141.                       "client sent RST_STREAM frame with incorrect length %uz",
  2142.                       h2c->state.length);

  2144.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2145.     }

  2147.     if (end - pos < NGX_HTTP_V2_RST_STREAM_SIZE) {
  2148.         return ngx_http_v2_state_save(h2c, pos, end,
  2149.                                       ngx_http_v2_state_rst_stream);
  2150.     }

  2152.     status = ngx_http_v2_parse_uint32(pos);

  2154.     pos += NGX_HTTP_V2_RST_STREAM_SIZE;

  2156.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2157.                    "http2 RST_STREAM frame, sid:%ui status:%ui",
  2158.                    h2c->state.sid, status);

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

  2164.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2165.     }

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

  2169.     if (node == NULL || node->stream == NULL) {
  2170.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2171.                        "unknown http2 stream");

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

  2176.     stream = node->stream;

  2178.     stream->in_closed = 1;
  2179.     stream->out_closed = 1;

  2181.     fc = stream->request->connection;
  2182.     fc->error = 1;

  2184.     switch (status) {

  2186.     case NGX_HTTP_V2_CANCEL:
  2187.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2188.                       "client canceled stream %ui", h2c->state.sid);
  2189.         break;

  2191.     case NGX_HTTP_V2_INTERNAL_ERROR:
  2192.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2193.                       "client terminated stream %ui due to internal error",
  2194.                       h2c->state.sid);
  2195.         break;

  2197.     default:
  2198.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  2199.                       "client terminated stream %ui with status %ui",
  2200.                       h2c->state.sid, status);
  2201.         break;
  2202.     }

  2204.     ev = fc->read;
  2205.     ev->handler(ev);

  2207.     return ngx_http_v2_state_complete(h2c, pos, end);
  2208. }


  2211. static u_char *
  2212. ‌ngx_http_v2_state_settings(ngx_http_v2_connection_t *h2c, u_char *pos,
  2213.     u_char *end)
  2214. {
  2215.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2216.                    "http2 SETTINGS frame");

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

  2222.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2223.     }

  2225.     if (h2c->state.flags & NGX_HTTP_V2_ACK_FLAG) {

  2227.         if (h2c->state.length != 0) {
  2228.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2229.                           "client sent SETTINGS frame with the ACK flag "
  2230.                           "and nonzero length");

  2232.             return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2233.         }

  2235.         h2c->settings_ack = 1;

  2237.         return ngx_http_v2_state_complete(h2c, pos, end);
  2238.     }

  2240.     if (h2c->state.length % NGX_HTTP_V2_SETTINGS_PARAM_SIZE) {
  2241.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2242.                       "client sent SETTINGS frame with incorrect length %uz",
  2243.                       h2c->state.length);

  2245.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2246.     }

  2248.     h2c->state.window_delta = 0;

  2250.     return ngx_http_v2_state_settings_params(h2c, pos, end);
  2251. }


  2254. static u_char *
  2255. ‌ngx_http_v2_state_settings_params(ngx_http_v2_connection_t *h2c, u_char *pos,
  2256.     u_char *end)
  2257. {
  2258.     ngx_uint_t                id, value;
  2259.     ngx_http_v2_out_frame_t  *frame;

  2261.     while (h2c->state.length) {
  2262.         if (end - pos < NGX_HTTP_V2_SETTINGS_PARAM_SIZE) {
  2263.             return ngx_http_v2_state_save(h2c, pos, end,
  2264.                                           ngx_http_v2_state_settings_params);
  2265.         }

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

  2269.         id = ngx_http_v2_parse_uint16(pos);
  2270.         value = ngx_http_v2_parse_uint32(&pos[2]);

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

  2275.         switch (id) {

  2277.         case NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING:

  2279.             if (value > NGX_HTTP_V2_MAX_WINDOW) {
  2280.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2281.                               "client sent SETTINGS frame with incorrect "
  2282.                               "INITIAL_WINDOW_SIZE value %ui", value);

  2284.                 return ngx_http_v2_connection_error(h2c,
  2285.                                                   NGX_HTTP_V2_FLOW_CTRL_ERROR);
  2286.             }

  2288.             h2c->state.window_delta = (ssize_t) value
  2289.                                       - (ssize_t) h2c->init_window;
  2290.             break;

  2292.         case NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING:

  2294.             if (value > NGX_HTTP_V2_MAX_FRAME_SIZE
  2295.                 || value < NGX_HTTP_V2_DEFAULT_FRAME_SIZE)
  2296.             {
  2297.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2298.                               "client sent SETTINGS frame with incorrect "
  2299.                               "MAX_FRAME_SIZE value %ui", value);

  2301.                 return ngx_http_v2_connection_error(h2c,
  2302.                                                     NGX_HTTP_V2_PROTOCOL_ERROR);
  2303.             }

  2305.             h2c->frame_size = value;
  2306.             break;

  2308.         case NGX_HTTP_V2_ENABLE_PUSH_SETTING:

  2310.             if (value > 1) {
  2311.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2312.                               "client sent SETTINGS frame with incorrect "
  2313.                               "ENABLE_PUSH value %ui", value);

  2315.                 return ngx_http_v2_connection_error(h2c,
  2316.                                                     NGX_HTTP_V2_PROTOCOL_ERROR);
  2317.             }

  2319.             break;

  2321.         case NGX_HTTP_V2_HEADER_TABLE_SIZE_SETTING:

  2323.             h2c->table_update = 1;
  2324.             break;

  2326.         case NGX_HTTP_V2_NO_PRIORITIES_SETTING:

  2328.             if (value > 1) {
  2329.                 ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2330.                               "client sent SETTINGS frame with incorrect "
  2331.                               "NO_RFC7540_PRIORITIES value %ui", value);

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

  2337.             break;

  2339.         default:
  2340.             break;
  2341.         }

  2343.         pos += NGX_HTTP_V2_SETTINGS_PARAM_SIZE;
  2344.     }

  2346.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_SETTINGS_ACK_SIZE,
  2347.                                   NGX_HTTP_V2_SETTINGS_FRAME,
  2348.                                   NGX_HTTP_V2_ACK_FLAG, 0);
  2349.     if (frame == NULL) {
  2350.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2351.     }

  2353.     ngx_http_v2_queue_ordered_frame(h2c, frame);

  2355.     if (h2c->state.window_delta) {
  2356.         h2c->init_window += h2c->state.window_delta;

  2358.         if (ngx_http_v2_adjust_windows(h2c, h2c->state.window_delta) != NGX_OK)
  2359.         {
  2360.             return ngx_http_v2_connection_error(h2c,
  2361.                                                 NGX_HTTP_V2_INTERNAL_ERROR);
  2362.         }

  2364.         h2c->state.window_delta = 0;
  2365.     }

  2367.     return ngx_http_v2_state_complete(h2c, pos, end);
  2368. }


  2371. static u_char *
  2372. ‌ngx_http_v2_state_push_promise(ngx_http_v2_connection_t *h2c, u_char *pos,
  2373.     u_char *end)
  2374. {
  2375.     ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2376.                   "client sent PUSH_PROMISE frame");

  2378.     return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2379. }


  2382. static u_char *
  2383. ‌ngx_http_v2_state_ping(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  2384. {
  2385.     ngx_buf_t                *buf;
  2386.     ngx_http_v2_out_frame_t  *frame;

  2388.     if (h2c->state.length != NGX_HTTP_V2_PING_SIZE) {
  2389.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2390.                       "client sent PING frame with incorrect length %uz",
  2391.                       h2c->state.length);

  2393.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2394.     }

  2396.     if (end - pos < NGX_HTTP_V2_PING_SIZE) {
  2397.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_ping);
  2398.     }

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

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

  2407.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2408.     }

  2410.     if (h2c->state.flags & NGX_HTTP_V2_ACK_FLAG) {
  2411.         return ngx_http_v2_state_skip(h2c, pos, end);
  2412.     }

  2414.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_PING_SIZE,
  2415.                                   NGX_HTTP_V2_PING_FRAME,
  2416.                                   NGX_HTTP_V2_ACK_FLAG, 0);
  2417.     if (frame == NULL) {
  2418.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2419.     }

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

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

  2425.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2427.     return ngx_http_v2_state_complete(h2c, pos + NGX_HTTP_V2_PING_SIZE, end);
  2428. }


  2431. static u_char *
  2432. ‌ngx_http_v2_state_goaway(ngx_http_v2_connection_t *h2c, u_char *pos,
  2433.     u_char *end)
  2434. {
  2435. #if (NGX_DEBUG)
  2436.     ngx_uint_t  last_sid, error;
  2437. #endif

  2439.     if (h2c->state.length < NGX_HTTP_V2_GOAWAY_SIZE) {
  2440.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2441.                       "client sent GOAWAY frame "
  2442.                       "with incorrect length %uz", h2c->state.length);

  2444.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2445.     }

  2447.     if (end - pos < NGX_HTTP_V2_GOAWAY_SIZE) {
  2448.         return ngx_http_v2_state_save(h2c, pos, end, ngx_http_v2_state_goaway);
  2449.     }

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

  2455.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2456.     }

  2458. #if (NGX_DEBUG)
  2459.     h2c->state.length -= NGX_HTTP_V2_GOAWAY_SIZE;

  2461.     last_sid = ngx_http_v2_parse_sid(pos);
  2462.     error = ngx_http_v2_parse_uint32(&pos[4]);

  2464.     pos += NGX_HTTP_V2_GOAWAY_SIZE;

  2466.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2467.                    "http2 GOAWAY frame: last sid %ui, error %ui",
  2468.                    last_sid, error);
  2469. #endif

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


  2475. static u_char *
  2476. ‌ngx_http_v2_state_window_update(ngx_http_v2_connection_t *h2c, u_char *pos,
  2477.     u_char *end)
  2478. {
  2479.     size_t                 window;
  2480.     ngx_event_t           *wev;
  2481.     ngx_queue_t           *q;
  2482.     ngx_http_v2_node_t    *node;
  2483.     ngx_http_v2_stream_t  *stream;

  2485.     if (h2c->state.length != NGX_HTTP_V2_WINDOW_UPDATE_SIZE) {
  2486.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2487.                       "client sent WINDOW_UPDATE frame "
  2488.                       "with incorrect length %uz", h2c->state.length);

  2490.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
  2491.     }

  2493.     if (end - pos < NGX_HTTP_V2_WINDOW_UPDATE_SIZE) {
  2494.         return ngx_http_v2_state_save(h2c, pos, end,
  2495.                                       ngx_http_v2_state_window_update);
  2496.     }

  2498.     window = ngx_http_v2_parse_window(pos);

  2500.     pos += NGX_HTTP_V2_WINDOW_UPDATE_SIZE;

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

  2506.     if (window == 0) {
  2507.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2508.                       "client sent WINDOW_UPDATE frame "
  2509.                       "with incorrect window increment 0");

  2511.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2512.     }

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

  2517.         if (node == NULL || node->stream == NULL) {
  2518.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2519.                            "unknown http2 stream");

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

  2524.         stream = node->stream;

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

  2528.             ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2529.                           "client violated flow control for stream %ui: "
  2530.                           "received WINDOW_UPDATE frame "
  2531.                           "with window increment %uz "
  2532.                           "not allowed for window %z",
  2533.                           h2c->state.sid, window, stream->send_window);

  2535.             if (ngx_http_v2_terminate_stream(h2c, stream,
  2536.                                              NGX_HTTP_V2_FLOW_CTRL_ERROR)
  2537.                 == NGX_ERROR)
  2538.             {
  2539.                 return ngx_http_v2_connection_error(h2c,
  2540.                                                     NGX_HTTP_V2_INTERNAL_ERROR);
  2541.             }

  2543.             return ngx_http_v2_state_complete(h2c, pos, end);
  2544.         }

  2546.         stream->send_window += window;

  2548.         if (stream->exhausted) {
  2549.             stream->exhausted = 0;

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

  2553.             wev->active = 0;
  2554.             wev->ready = 1;

  2556.             if (!wev->delayed) {
  2557.                 wev->handler(wev);
  2558.             }
  2559.         }

  2561.         return ngx_http_v2_state_complete(h2c, pos, end);
  2562.     }

  2564.     if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
  2565.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2566.                       "client violated connection flow control: "
  2567.                       "received WINDOW_UPDATE frame "
  2568.                       "with window increment %uz "
  2569.                       "not allowed for window %uz",
  2570.                       window, h2c->send_window);

  2572.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
  2573.     }

  2575.     h2c->send_window += window;

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

  2580.         ngx_queue_remove(q);

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

  2584.         stream->waiting = 0;

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

  2588.         wev->active = 0;
  2589.         wev->ready = 1;

  2591.         if (!wev->delayed) {
  2592.             wev->handler(wev);

  2594.             if (h2c->send_window == 0) {
  2595.                 break;
  2596.             }
  2597.         }
  2598.     }

  2600.     return ngx_http_v2_state_complete(h2c, pos, end);
  2601. }


  2604. static u_char *
  2605. ‌ngx_http_v2_state_continuation(ngx_http_v2_connection_t *h2c, u_char *pos,
  2606.     u_char *end)
  2607. {
  2608.     ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  2609.                   "client sent unexpected CONTINUATION frame");

  2611.     return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_PROTOCOL_ERROR);
  2612. }


  2615. static u_char *
  2616. ‌ngx_http_v2_state_complete(ngx_http_v2_connection_t *h2c, u_char *pos,
  2617.     u_char *end)
  2618. {
  2619.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2620.                    "http2 frame complete pos:%p end:%p", pos, end);

  2622.     if (pos > end) {
  2623.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  2624.                       "receive buffer overrun");

  2626.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2627.     }

  2629.     h2c->state.stream = NULL;
  2630.     h2c->state.handler = ngx_http_v2_state_head;

  2632.     return pos;
  2633. }


  2636. static u_char *
  2637. ‌ngx_http_v2_state_skip_padded(ngx_http_v2_connection_t *h2c, u_char *pos,
  2638.     u_char *end)
  2639. {
  2640.     h2c->state.length += h2c->state.padding;
  2641.     h2c->state.padding = 0;

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


  2647. static u_char *
  2648. ‌ngx_http_v2_state_skip(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end)
  2649. {
  2650.     size_t  size;

  2652.     size = end - pos;

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

  2658.         h2c->state.length -= size;
  2659.         return ngx_http_v2_state_save(h2c, end, end, ngx_http_v2_state_skip);
  2660.     }

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

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


  2669. static u_char *
  2670. ‌ngx_http_v2_state_save(ngx_http_v2_connection_t *h2c, u_char *pos, u_char *end,
  2671.     ngx_http_v2_handler_pt handler)
  2672. {
  2673.     size_t  size;

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

  2679.     size = end - pos;

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

  2685.         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  2686.     }

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

  2690.     h2c->state.buffer_used = size;
  2691.     h2c->state.handler = handler;
  2692.     h2c->state.incomplete = 1;

  2694.     return end;
  2695. }


  2698. static u_char *
  2699. ‌ngx_http_v2_state_headers_save(ngx_http_v2_connection_t *h2c, u_char *pos,
  2700.     u_char *end, ngx_http_v2_handler_pt handler)
  2701. {
  2702.     ngx_event_t               *rev;
  2703.     ngx_http_request_t        *r;
  2704.     ngx_http_core_srv_conf_t  *cscf;

  2706.     if (h2c->state.stream) {
  2707.         r = h2c->state.stream->request;
  2708.         rev = r->connection->read;

  2710.         if (!rev->timer_set) {
  2711.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  2712.             ngx_add_timer(rev, cscf->client_header_timeout);
  2713.         }
  2714.     }

  2716.     return ngx_http_v2_state_save(h2c, pos, end, handler);
  2717. }


  2720. static u_char *
  2721. ‌ngx_http_v2_connection_error(ngx_http_v2_connection_t *h2c,
  2722.     ngx_uint_t err)
  2723. {
  2724.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2725.                    "http2 state connection error");

  2727.     ngx_http_v2_finalize_connection(h2c, err);

  2729.     return NULL;
  2730. }


  2733. static ngx_int_t
  2734. ‌ngx_http_v2_parse_int(ngx_http_v2_connection_t *h2c, u_char **pos, u_char *end,
  2735.     ngx_uint_t prefix)
  2736. {
  2737.     u_char      *start, *p;
  2738.     ngx_uint_t   value, octet, shift;

  2740.     start = *pos;
  2741.     p = start;

  2743.     value = *p++ & prefix;

  2745.     if (value != prefix) {
  2746.         if (h2c->state.length == 0) {
  2747.             return NGX_ERROR;
  2748.         }

  2750.         h2c->state.length--;

  2752.         *pos = p;
  2753.         return value;
  2754.     }

  2756.     if (end - start > NGX_HTTP_V2_INT_OCTETS) {
  2757.         end = start + NGX_HTTP_V2_INT_OCTETS;
  2758.     }

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

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

  2765.         if (octet < 128) {
  2766.             if ((size_t) (p - start) > h2c->state.length) {
  2767.                 return NGX_ERROR;
  2768.             }

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

  2772.             *pos = p;
  2773.             return value;
  2774.         }
  2775.     }

  2777.     if ((size_t) (end - start) >= h2c->state.length) {
  2778.         return NGX_ERROR;
  2779.     }

  2781.     if (end == start + NGX_HTTP_V2_INT_OCTETS) {
  2782.         return NGX_DECLINED;
  2783.     }

  2785.     return NGX_AGAIN;
  2786. }


  2789. static ngx_int_t
  2790. ‌ngx_http_v2_send_settings(ngx_http_v2_connection_t *h2c)
  2791. {
  2792.     size_t                    len;
  2793.     ngx_buf_t                *buf;
  2794.     ngx_chain_t              *cl;
  2795.     ngx_http_v2_srv_conf_t   *h2scf;
  2796.     ngx_http_v2_out_frame_t  *frame;

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

  2801.     frame = ngx_palloc(h2c->pool, sizeof(ngx_http_v2_out_frame_t));
  2802.     if (frame == NULL) {
  2803.         return NGX_ERROR;
  2804.     }

  2806.     cl = ngx_alloc_chain_link(h2c->pool);
  2807.     if (cl == NULL) {
  2808.         return NGX_ERROR;
  2809.     }

  2811.     len = NGX_HTTP_V2_SETTINGS_PARAM_SIZE * 4;

  2813.     buf = ngx_create_temp_buf(h2c->pool, NGX_HTTP_V2_FRAME_HEADER_SIZE + len);
  2814.     if (buf == NULL) {
  2815.         return NGX_ERROR;
  2816.     }

  2818.     buf->last_buf = 1;

  2820.     cl->buf = buf;
  2821.     cl->next = NULL;

  2823.     frame->first = cl;
  2824.     frame->last = cl;
  2825.     frame->handler = ngx_http_v2_settings_frame_handler;
  2826.     frame->stream = NULL;
  2827. #if (NGX_DEBUG)
  2828.     frame->length = len;
  2829. #endif
  2830.     frame->blocked = 0;

  2832.     buf->last = ngx_http_v2_write_len_and_type(buf->last, len,
  2833.                                                NGX_HTTP_V2_SETTINGS_FRAME);

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

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

  2839.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  2840.                                          ngx_http_v2_module);

  2842.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2843.                                          NGX_HTTP_V2_MAX_STREAMS_SETTING);
  2844.     buf->last = ngx_http_v2_write_uint32(buf->last,
  2845.                                          h2scf->concurrent_streams);

  2847.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2848.                                          NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING);
  2849.     buf->last = ngx_http_v2_write_uint32(buf->last, h2scf->preread_size);

  2851.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2852.                                          NGX_HTTP_V2_MAX_FRAME_SIZE_SETTING);
  2853.     buf->last = ngx_http_v2_write_uint32(buf->last,
  2854.                                          NGX_HTTP_V2_MAX_FRAME_SIZE);

  2856.     buf->last = ngx_http_v2_write_uint16(buf->last,
  2857.                                          NGX_HTTP_V2_NO_PRIORITIES_SETTING);
  2858.     buf->last = ngx_http_v2_write_uint32(buf->last, 1);

  2860.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2862.     return NGX_OK;
  2863. }


  2866. static ngx_int_t
  2867. ‌ngx_http_v2_settings_frame_handler(ngx_http_v2_connection_t *h2c,
  2868.     ngx_http_v2_out_frame_t *frame)
  2869. {
  2870.     ngx_buf_t  *buf;

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

  2874.     if (buf->pos != buf->last) {
  2875.         return NGX_AGAIN;
  2876.     }

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

  2880.     return NGX_OK;
  2881. }


  2884. static ngx_int_t
  2885. ‌ngx_http_v2_send_window_update(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  2886.     size_t window)
  2887. {
  2888.     ngx_buf_t                *buf;
  2889.     ngx_http_v2_out_frame_t  *frame;

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

  2895.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_WINDOW_UPDATE_SIZE,
  2896.                                   NGX_HTTP_V2_WINDOW_UPDATE_FRAME,
  2897.                                   NGX_HTTP_V2_NO_FLAG, sid);
  2898.     if (frame == NULL) {
  2899.         return NGX_ERROR;
  2900.     }

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

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

  2906.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2908.     return NGX_OK;
  2909. }


  2912. static ngx_int_t
  2913. ‌ngx_http_v2_send_rst_stream(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  2914.     ngx_uint_t status)
  2915. {
  2916.     ngx_buf_t                *buf;
  2917.     ngx_http_v2_out_frame_t  *frame;

  2919.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  2920.                    "http2 send RST_STREAM frame sid:%ui, status:%ui",
  2921.                    sid, status);

  2923.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_RST_STREAM_SIZE,
  2924.                                   NGX_HTTP_V2_RST_STREAM_FRAME,
  2925.                                   NGX_HTTP_V2_NO_FLAG, sid);
  2926.     if (frame == NULL) {
  2927.         return NGX_ERROR;
  2928.     }

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

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

  2934.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2936.     return NGX_OK;
  2937. }


  2940. static ngx_int_t
  2941. ‌ngx_http_v2_send_goaway(ngx_http_v2_connection_t *h2c, ngx_uint_t status)
  2942. {
  2943.     ngx_buf_t                *buf;
  2944.     ngx_http_v2_out_frame_t  *frame;

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

  2950.     frame = ngx_http_v2_get_frame(h2c, NGX_HTTP_V2_GOAWAY_SIZE,
  2951.                                   NGX_HTTP_V2_GOAWAY_FRAME,
  2952.                                   NGX_HTTP_V2_NO_FLAG, 0);
  2953.     if (frame == NULL) {
  2954.         return NGX_ERROR;
  2955.     }

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

  2959.     buf->last = ngx_http_v2_write_sid(buf->last, h2c->last_sid);
  2960.     buf->last = ngx_http_v2_write_uint32(buf->last, status);

  2962.     ngx_http_v2_queue_blocked_frame(h2c, frame);

  2964.     return NGX_OK;
  2965. }


  2968. static ngx_http_v2_out_frame_t *
  2969. ‌ngx_http_v2_get_frame(ngx_http_v2_connection_t *h2c, size_t length,
  2970.     ngx_uint_t type, u_char flags, ngx_uint_t sid)
  2971. {
  2972.     ngx_buf_t                *buf;
  2973.     ngx_pool_t               *pool;
  2974.     ngx_http_v2_out_frame_t  *frame;

  2976.     frame = h2c->free_frames;

  2978.     if (frame) {
  2979.         h2c->free_frames = frame->next;

  2981.         buf = frame->first->buf;
  2982.         buf->pos = buf->start;

  2984.         frame->blocked = 0;

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

  2989.         frame = ngx_pcalloc(pool, sizeof(ngx_http_v2_out_frame_t));
  2990.         if (frame == NULL) {
  2991.             return NULL;
  2992.         }

  2994.         frame->first = ngx_alloc_chain_link(pool);
  2995.         if (frame->first == NULL) {
  2996.             return NULL;
  2997.         }

  2999.         buf = ngx_create_temp_buf(pool, NGX_HTTP_V2_FRAME_BUFFER_SIZE);
  3000.         if (buf == NULL) {
  3001.             return NULL;
  3002.         }

  3004.         buf->last_buf = 1;

  3006.         frame->first->buf = buf;
  3007.         frame->last = frame->first;

  3009.         frame->handler = ngx_http_v2_frame_handler;

  3011.         h2c->frames++;

  3013.     } else {
  3014.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  3015.                       "http2 flood detected");

  3017.         h2c->connection->error = 1;
  3018.         return NULL;
  3019.     }

  3021. #if (NGX_DEBUG)
  3022.     if (length > NGX_HTTP_V2_FRAME_BUFFER_SIZE - NGX_HTTP_V2_FRAME_HEADER_SIZE)
  3023.     {
  3024.         ngx_log_error(NGX_LOG_ALERT, h2c->connection->log, 0,
  3025.                       "requested control frame is too large: %uz", length);
  3026.         return NULL;
  3027.     }
  3028. #endif

  3030.     frame->length = length;

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

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

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

  3038.     return frame;
  3039. }


  3042. static ngx_int_t
  3043. ‌ngx_http_v2_frame_handler(ngx_http_v2_connection_t *h2c,
  3044.     ngx_http_v2_out_frame_t *frame)
  3045. {
  3046.     ngx_buf_t  *buf;

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

  3050.     if (buf->pos != buf->last) {
  3051.         return NGX_AGAIN;
  3052.     }

  3054.     frame->next = h2c->free_frames;
  3055.     h2c->free_frames = frame;

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

  3059.     return NGX_OK;
  3060. }


  3063. static ngx_http_v2_stream_t *
  3064. ‌ngx_http_v2_create_stream(ngx_http_v2_connection_t *h2c)
  3065. {
  3066.     ngx_log_t                 *log;
  3067.     ngx_event_t               *rev, *wev;
  3068.     ngx_connection_t          *fc;
  3069.     ngx_http_log_ctx_t        *ctx;
  3070.     ngx_http_request_t        *r;
  3071.     ngx_http_v2_stream_t      *stream;
  3072.     ngx_http_v2_srv_conf_t    *h2scf;
  3073.     ngx_http_core_srv_conf_t  *cscf;

  3075.     fc = h2c->free_fake_connections;

  3077.     if (fc) {
  3078.         h2c->free_fake_connections = fc->data;

  3080.         rev = fc->read;
  3081.         wev = fc->write;
  3082.         log = fc->log;
  3083.         ctx = log->data;

  3085.     } else {
  3086.         fc = ngx_palloc(h2c->pool, sizeof(ngx_connection_t));
  3087.         if (fc == NULL) {
  3088.             return NULL;
  3089.         }

  3091.         rev = ngx_palloc(h2c->pool, sizeof(ngx_event_t));
  3092.         if (rev == NULL) {
  3093.             return NULL;
  3094.         }

  3096.         wev = ngx_palloc(h2c->pool, sizeof(ngx_event_t));
  3097.         if (wev == NULL) {
  3098.             return NULL;
  3099.         }

  3101.         log = ngx_palloc(h2c->pool, sizeof(ngx_log_t));
  3102.         if (log == NULL) {
  3103.             return NULL;
  3104.         }

  3106.         ctx = ngx_palloc(h2c->pool, sizeof(ngx_http_log_ctx_t));
  3107.         if (ctx == NULL) {
  3108.             return NULL;
  3109.         }

  3111.         ctx->connection = fc;
  3112.         ctx->request = NULL;
  3113.         ctx->current_request = NULL;
  3114.     }

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

  3118.     log->data = ctx;
  3119.     log->action = "reading client request headers";

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

  3123.     rev->data = fc;
  3124.     rev->ready = 1;
  3125.     rev->handler = ngx_http_v2_close_stream_handler;
  3126.     rev->log = log;

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

  3130.     wev->write = 1;

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

  3134.     fc->data = h2c->http_connection;
  3135.     fc->read = rev;
  3136.     fc->write = wev;
  3137.     fc->sent = 0;
  3138.     fc->log = log;
  3139.     fc->buffered = 0;
  3140.     fc->sndlowat = 1;
  3141.     fc->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;

  3143.     r = ngx_http_create_request(fc);
  3144.     if (r == NULL) {
  3145.         return NULL;
  3146.     }

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

  3150.     r->http_version = NGX_HTTP_VERSION_20;
  3151.     r->valid_location = 1;

  3153.     fc->data = r;
  3154.     h2c->connection->requests++;

  3156.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  3158.     r->header_in = ngx_create_temp_buf(r->pool,
  3159.                                        cscf->client_header_buffer_size);
  3160.     if (r->header_in == NULL) {
  3161.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3162.         return NULL;
  3163.     }

  3165.     if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  3166.                       sizeof(ngx_table_elt_t))
  3167.         != NGX_OK)
  3168.     {
  3169.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3170.         return NULL;
  3171.     }

  3173.     r->headers_in.connection_type = NGX_HTTP_CONNECTION_CLOSE;

  3175.     stream = ngx_pcalloc(r->pool, sizeof(ngx_http_v2_stream_t));
  3176.     if (stream == NULL) {
  3177.         ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3178.         return NULL;
  3179.     }

  3181.     r->stream = stream;

  3183.     stream->request = r;
  3184.     stream->connection = h2c;

  3186.     ngx_http_priority_state_init(&stream->priority);

  3188.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

  3190.     stream->send_window = h2c->init_window;
  3191.     stream->recv_window = h2scf->preread_size;

  3193.     h2c->processing++;

  3195.     if (h2c->connection->read->timer_set) {
  3196.         ngx_del_timer(h2c->connection->read);
  3197.     }

  3199.     return stream;
  3200. }


  3203. static ngx_http_v2_node_t *
  3204. ‌ngx_http_v2_get_node_by_id(ngx_http_v2_connection_t *h2c, ngx_uint_t sid,
  3205.     ngx_uint_t alloc)
  3206. {
  3207.     ngx_uint_t               index;
  3208.     ngx_http_v2_node_t      *node;
  3209.     ngx_http_v2_srv_conf_t  *h2scf;

  3211.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  3212.                                          ngx_http_v2_module);

  3214.     index = ngx_http_v2_index(h2scf, sid);

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

  3218.         if (node->id == sid) {
  3219.             return node;
  3220.         }
  3221.     }

  3223.     if (!alloc) {
  3224.         return NULL;
  3225.     }

  3227.     if (h2c->closed_nodes < 32) {
  3228.         node = ngx_pcalloc(h2c->connection->pool, sizeof(ngx_http_v2_node_t));
  3229.         if (node == NULL) {
  3230.             return NULL;
  3231.         }

  3233.     } else {
  3234.         node = ngx_http_v2_get_closed_node(h2c);
  3235.     }

  3237.     node->id = sid;

  3239.     node->index = h2c->streams_index[index];
  3240.     h2c->streams_index[index] = node;

  3242.     return node;
  3243. }


  3246. static ngx_http_v2_node_t *
  3247. ‌ngx_http_v2_get_closed_node(ngx_http_v2_connection_t *h2c)
  3248. {
  3249.     ngx_queue_t             *q;
  3250.     ngx_http_v2_node_t      *node, **next, *n;
  3251.     ngx_http_v2_srv_conf_t  *h2scf;

  3253.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  3254.                                          ngx_http_v2_module);

  3256.     h2c->closed_nodes--;

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

  3260.     ngx_queue_remove(q);

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

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

  3266.     for ( ;; ) {
  3267.         n = *next;

  3269.         if (n == node) {
  3270.             *next = n->index;
  3271.             break;
  3272.         }

  3274.         next = &n->index;
  3275.     }

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

  3279.     return node;
  3280. }


  3283. static ngx_int_t
  3284. ‌ngx_http_v2_validate_header(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3285. {
  3286.     u_char                     ch;
  3287.     ngx_uint_t                 i;
  3288.     ngx_http_core_srv_conf_t  *cscf;

  3290.     r->invalid_header = 0;

  3292.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  3297.         if ((ch >= 'a' && ch <= 'z')
  3298.             || (ch == '-')
  3299.             || (ch >= '0' && ch <= '9')
  3300.             || (ch == '_' && cscf->underscores_in_headers))
  3301.         {
  3302.             continue;
  3303.         }

  3305.         if (ch <= 0x20 || ch == 0x7f || ch == ':'
  3306.             || (ch >= 'A' && ch <= 'Z'))
  3307.         {
  3308.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3309.                           "client sent invalid header name: \"%V\"",
  3310.                           &header->name);

  3312.             return NGX_ERROR;
  3313.         }

  3315.         r->invalid_header = 1;
  3316.     }

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

  3321.         if (ch == '\0' || ch == LF || ch == CR) {
  3322.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3323.                           "client sent header \"%V\" with "
  3324.                           "invalid value: \"%V\"",
  3325.                           &header->name, &header->value);

  3327.             return NGX_ERROR;
  3328.         }
  3329.     }

  3331.     return NGX_OK;
  3332. }


  3335. static ngx_int_t
  3336. ‌ngx_http_v2_pseudo_header(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3337. {
  3338.     header->name.len--;
  3339.     header->name.data++;

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

  3345.         return NGX_DECLINED;
  3346.     }

  3348.     switch (header->name.len) {
  3349.     case 4:
  3350.         if (ngx_memcmp(header->name.data, "path", sizeof("path") - 1)
  3351.             == 0)
  3352.         {
  3353.             return ngx_http_v2_parse_path(r, &header->value);
  3354.         }

  3356.         break;

  3358.     case 6:
  3359.         if (ngx_memcmp(header->name.data, "method", sizeof("method") - 1)
  3360.             == 0)
  3361.         {
  3362.             return ngx_http_v2_parse_method(r, &header->value);
  3363.         }

  3365.         if (ngx_memcmp(header->name.data, "scheme", sizeof("scheme") - 1)
  3366.             == 0)
  3367.         {
  3368.             return ngx_http_v2_parse_scheme(r, &header->value);
  3369.         }

  3371.         break;

  3373.     case 9:
  3374.         if (ngx_memcmp(header->name.data, "authority", sizeof("authority") - 1)
  3375.             == 0)
  3376.         {
  3377.             return ngx_http_v2_parse_authority(r, &header->value);
  3378.         }

  3380.         break;
  3381.     }

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

  3387.     return NGX_DECLINED;
  3388. }


  3391. static ngx_int_t
  3392. ‌ngx_http_v2_parse_path(ngx_http_request_t *r, ngx_str_t *value)
  3393. {
  3394.     if (r->unparsed_uri.len) {
  3395.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3396.                       "client sent duplicate :path header");

  3398.         return NGX_DECLINED;
  3399.     }

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

  3405.         return NGX_DECLINED;
  3406.     }

  3408.     r->uri_start = value->data;
  3409.     r->uri_end = value->data + value->len;

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

  3415.         return NGX_DECLINED;
  3416.     }

  3418.     if (ngx_http_process_request_uri(r) != NGX_OK) {
  3419.         /*
  3420.          * request has been finalized already
  3421.          * in ngx_http_process_request_uri()
  3422.          */
  3423.         return NGX_ABORT;
  3424.     }

  3426.     return NGX_OK;
  3427. }


  3430. static ngx_int_t
  3431. ‌ngx_http_v2_parse_method(ngx_http_request_t *r, ngx_str_t *value)
  3432. {
  3433.     size_t         k, len;
  3434.     ngx_uint_t     n;
  3435.     const u_char  *p, *m;

  3437.     /*
  3438.      * This array takes less than 256 sequential bytes,
  3439.      * and if typical CPU cache line size is 64 bytes,
  3440.      * it is prefetched for 4 load operations.
  3441.      */
  3442. ‌    static const struct {
  3443.         u_char            len;
  3444.         const u_char      method[11];
  3445.         uint32_t          value;
  3446.     } tests[] = {
  3447.         { 3, "GET",       NGX_HTTP_GET },
  3448.         { 4, "POST",      NGX_HTTP_POST },
  3449.         { 4, "HEAD",      NGX_HTTP_HEAD },
  3450.         { 7, "OPTIONS",   NGX_HTTP_OPTIONS },
  3451.         { 8, "PROPFIND",  NGX_HTTP_PROPFIND },
  3452.         { 3, "PUT",       NGX_HTTP_PUT },
  3453.         { 5, "MKCOL",     NGX_HTTP_MKCOL },
  3454.         { 6, "DELETE",    NGX_HTTP_DELETE },
  3455.         { 4, "COPY",      NGX_HTTP_COPY },
  3456.         { 4, "MOVE",      NGX_HTTP_MOVE },
  3457.         { 9, "PROPPATCH", NGX_HTTP_PROPPATCH },
  3458.         { 4, "LOCK",      NGX_HTTP_LOCK },
  3459.         { 6, "UNLOCK",    NGX_HTTP_UNLOCK },
  3460.         { 5, "PATCH",     NGX_HTTP_PATCH },
  3461.         { 5, "TRACE",     NGX_HTTP_TRACE },
  3462.         { 7, "CONNECT",   NGX_HTTP_CONNECT }
  3463.     }, *test;

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

  3469.         return NGX_DECLINED;
  3470.     }

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

  3476.         return NGX_DECLINED;
  3477.     }

  3479.     r->method_name.len = value->len;
  3480.     r->method_name.data = value->data;

  3482.     len = r->method_name.len;
  3483.     n = sizeof(tests) / sizeof(tests[0]);
  3484.     test = tests;

  3486.     do {
  3487.         if (len == test->len) {
  3488.             p = r->method_name.data;
  3489.             m = test->method;
  3490.             k = len;

  3492.             do {
  3493.                 if (*p++ != *m++) {
  3494.                     goto next;
  3495.                 }
  3496.             } while (--k);

  3498.             r->method = test->value;
  3499.             return NGX_OK;
  3500.         }

  3502.     next:
  3503.         test++;

  3505.     } while (--n);

  3507.     p = r->method_name.data;

  3509.     do {
  3510.         if ((*p < 'A' || *p > 'Z') && *p != '_' && *p != '-') {
  3511.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3512.                           "client sent invalid method: \"%V\"",
  3513.                           &r->method_name);

  3515.             return NGX_DECLINED;
  3516.         }

  3518.         p++;

  3520.     } while (--len);

  3522.     return NGX_OK;
  3523. }


  3526. static ngx_int_t
  3527. ‌ngx_http_v2_parse_scheme(ngx_http_request_t *r, ngx_str_t *value)
  3528. {
  3529.     u_char      c, ch;
  3530.     ngx_uint_t  i;

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

  3536.         return NGX_DECLINED;
  3537.     }

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

  3543.         return NGX_DECLINED;
  3544.     }

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

  3549.         c = (u_char) (ch | 0x20);
  3550.         if (c >= 'a' && c <= 'z') {
  3551.             continue;
  3552.         }

  3554.         if (((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')
  3555.             && i > 0)
  3556.         {
  3557.             continue;
  3558.         }

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

  3563.         return NGX_DECLINED;
  3564.     }

  3566.     r->schema = *value;

  3568.     return NGX_OK;
  3569. }


  3572. static ngx_int_t
  3573. ‌ngx_http_v2_parse_authority(ngx_http_request_t *r, ngx_str_t *value)
  3574. {
  3575.     ngx_int_t  rc;
  3576.     in_port_t  port;

  3578.     if (r->host_start) {
  3579.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3580.                       "client sent duplicate \":authority\" header");
  3581.         return NGX_DECLINED;
  3582.     }

  3584.     r->host_start = value->data;
  3585.     r->host_end = value->data + value->len;

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

  3589.     if (rc == NGX_DECLINED) {
  3590.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3591.                       "client sent invalid \":authority\" header");
  3592.         return NGX_DECLINED;
  3593.     }

  3595.     if (rc == NGX_ERROR) {
  3596.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3597.         return NGX_ABORT;
  3598.     }

  3600.     if (ngx_http_set_virtual_server(r, value) == NGX_ERROR) {
  3601.         /*
  3602.          * request has been finalized already
  3603.          * in ngx_http_set_virtual_server()
  3604.          */
  3605.         return NGX_ABORT;
  3606.     }

  3608.     r->headers_in.server = *value;
  3609.     r->port = port;

  3611.     return NGX_OK;
  3612. }


  3615. static ngx_int_t
  3616. ‌ngx_http_v2_construct_request_line(ngx_http_request_t *r)
  3617. {
  3618.     u_char  *p;

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

  3622.     if (r->request_line.len) {
  3623.         return NGX_OK;
  3624.     }

  3626.     if (r->method_name.len == 0
  3627.         || r->schema.len == 0
  3628.         || r->unparsed_uri.len == 0)
  3629.     {
  3630.         if (r->method_name.len == 0) {
  3631.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3632.                           "client sent no :method header");

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

  3638.         } else {
  3639.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  3640.                           "client sent no :path header");
  3641.         }

  3643.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3644.         return NGX_ERROR;
  3645.     }

  3647.     r->request_line.len = r->method_name.len + 1
  3648.                           + r->unparsed_uri.len
  3649.                           + sizeof(ending) - 1;

  3651.     p = ngx_pnalloc(r->pool, r->request_line.len + 1);
  3652.     if (p == NULL) {
  3653.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3654.         return NGX_ERROR;
  3655.     }

  3657.     r->request_line.data = p;

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

  3661.     *p++ = ' ';

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

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

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

  3670.     return NGX_OK;
  3671. }


  3674. static ngx_int_t
  3675. ‌ngx_http_v2_cookie(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3676. {
  3677.     ngx_str_t    *val;
  3678.     ngx_array_t  *cookies;

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

  3682.     if (cookies == NULL) {
  3683.         cookies = ngx_array_create(r->pool, 2, sizeof(ngx_str_t));
  3684.         if (cookies == NULL) {
  3685.             return NGX_ERROR;
  3686.         }

  3688.         r->stream->cookies = cookies;
  3689.     }

  3691.     val = ngx_array_push(cookies);
  3692.     if (val == NULL) {
  3693.         return NGX_ERROR;
  3694.     }

  3696.     val->len = header->value.len;
  3697.     val->data = header->value.data;

  3699.     return NGX_OK;
  3700. }


  3703. static ngx_int_t
  3704. ‌ngx_http_v2_construct_cookie_header(ngx_http_request_t *r)
  3705. {
  3706.     u_char                     *buf, *p, *end;
  3707.     size_t                      len;
  3708.     ngx_str_t                  *vals;
  3709.     ngx_uint_t                  i;
  3710.     ngx_array_t                *cookies;
  3711.     ngx_table_elt_t            *h;
  3712.     ngx_http_header_t          *hh;
  3713.     ngx_http_core_main_conf_t  *cmcf;

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

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

  3719.     if (cookies == NULL) {
  3720.         return NGX_OK;
  3721.     }

  3723.     vals = cookies->elts;

  3725.     i = 0;
  3726.     len = 0;

  3728.     do {
  3729.         len += vals[i].len + 2;
  3730.     } while (++i != cookies->nelts);

  3732.     len -= 2;

  3734.     buf = ngx_pnalloc(r->pool, len + 1);
  3735.     if (buf == NULL) {
  3736.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3737.         return NGX_ERROR;
  3738.     }

  3740.     p = buf;
  3741.     end = buf + len;

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

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

  3747.         if (p == end) {
  3748.             *p = '\0';
  3749.             break;
  3750.         }

  3752.         *p++ = ';'; *p++ = ' ';
  3753.     }

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

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

  3764.     h->key.len = cookie.len;
  3765.     h->key.data = cookie.data;

  3767.     h->value.len = len;
  3768.     h->value.data = buf;

  3770.     h->lowcase_key = cookie.data;

  3772.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

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

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

  3790.     return NGX_OK;
  3791. }


  3794. static ngx_int_t
  3795. ‌ngx_http_v2_priority(ngx_http_request_t *r, ngx_http_v2_header_t *header)
  3796. {
  3797.     ngx_str_t    *val;
  3798.     ngx_array_t  *priorities;

  3800.     priorities = r->stream->priorities;

  3802.     if (priorities == NULL) {
  3803.         priorities = ngx_array_create(r->pool, 1, sizeof(ngx_str_t));
  3804.         if (priorities == NULL) {
  3805.             return NGX_ERROR;
  3806.         }

  3808.         r->stream->priorities = priorities;
  3809.     }

  3811.     val = ngx_array_push(priorities);
  3812.     if (val == NULL) {
  3813.         return NGX_ERROR;
  3814.     }

  3816.     val->len = header->value.len;
  3817.     val->data = header->value.data;

  3819.     return NGX_OK;
  3820. }


  3823. static ngx_int_t
  3824. ‌ngx_http_v2_process_priority(ngx_http_request_t *r)
  3825. {
  3826.     u_char               *p;
  3827.     size_t                len;
  3828.     ngx_str_t             value, *vals;
  3829.     ngx_uint_t            i;
  3830.     ngx_array_t          *priorities;
  3831.     ngx_http_priority_t   priority;

  3833.     priorities = r->stream->priorities;

  3835.     if (priorities == NULL) {
  3836.         return NGX_OK;
  3837.     }

  3839.     /*
  3840.      * RFC 9218, Section 7: a PRIORITY_UPDATE frame overrides the Priority
  3841.      * header field, so ignore the header once a frame has been applied.
  3842.      */

  3844.     if (r->stream->priority_update) {
  3845.         return NGX_OK;
  3846.     }

  3848.     vals = priorities->elts;

  3850.     if (priorities->nelts == 1) {
  3851.         value = vals[0];

  3853.     } else {

  3855.         /* combine the field lines into a single value, "v1, v2, ..." */

  3857.         len = 0;

  3859.         for (i = 0; i < priorities->nelts; i++) {
  3860.             len += vals[i].len + 2;
  3861.         }

  3863.         len -= 2;

  3865.         p = ngx_pnalloc(r->pool, len);
  3866.         if (p == NULL) {
  3867.             ngx_http_v2_close_stream(r->stream,
  3868.                                      NGX_HTTP_INTERNAL_SERVER_ERROR);
  3869.             return NGX_ERROR;
  3870.         }

  3872.         value.data = p;
  3873.         value.len = len;

  3875.         for (i = 0; /* void */ ; i++) {
  3876.             p = ngx_cpymem(p, vals[i].data, vals[i].len);

  3878.             if (i == priorities->nelts - 1) {
  3879.                 break;
  3880.             }

  3882.             *p++ = ','; *p++ = ' ';
  3883.         }
  3884.     }

  3886.     if (ngx_http_priority_parse(&value, &priority) != NGX_OK) {
  3887.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3888.                        "http2 ignoring malformed priority header");
  3889.         return NGX_OK;
  3890.     }

  3892.     r->stream->priority.client = priority;
  3893.     ngx_http_priority_state_update(&r->stream->priority);

  3895.     return NGX_OK;
  3896. }


  3899. static ngx_int_t
  3900. ‌ngx_http_v2_construct_host_header(ngx_http_request_t *r)
  3901. {
  3902.     ngx_table_elt_t            *h;
  3903.     ngx_http_header_t          *hh;
  3904.     ngx_http_core_main_conf_t  *cmcf;

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

  3908.     h = ngx_list_push(&r->headers_in.headers);
  3909.     if (h == NULL) {
  3910.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3911.         return NGX_ERROR;
  3912.     }

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

  3916.     h->key.len = host.len;
  3917.     h->key.data = host.data;

  3919.     h->value.len = r->host_end - r->host_start;
  3920.     h->value.data = r->host_start;

  3922.     h->lowcase_key = host.data;

  3924.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  3929.     if (hh == NULL) {
  3930.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
  3931.         return NGX_ERROR;
  3932.     }

  3934.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  3935.         /*
  3936.          * request has been finalized already
  3937.          * in ngx_http_process_host()
  3938.          */
  3939.         return NGX_ERROR;
  3940.     }

  3942.     return NGX_OK;
  3943. }


  3946. static void
  3947. ‌ngx_http_v2_run_request(ngx_http_request_t *r)
  3948. {
  3949.     ngx_str_t                  host;
  3950.     ngx_connection_t          *fc;
  3951.     ngx_http_v2_srv_conf_t    *h2scf;
  3952.     ngx_http_v2_connection_t  *h2c;

  3954.     fc = r->connection;

  3956.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);

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

  3963.         ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  3964.         goto failed;
  3965.     }

  3967.     if (ngx_http_v2_construct_request_line(r) != NGX_OK) {
  3968.         goto failed;
  3969.     }

  3971.     if (ngx_http_v2_construct_cookie_header(r) != NGX_OK) {
  3972.         goto failed;
  3973.     }

  3975.     if (ngx_http_v2_process_priority(r) != NGX_OK) {
  3976.         goto failed;
  3977.     }

  3979.     r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

  3981.     if (r->headers_in.connection) {
  3982.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3983.                       "client sent \"Connection\" header");
  3984.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3985.         goto failed;
  3986.     }

  3988.     if (r->headers_in.keep_alive) {
  3989.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3990.                       "client sent \"Keep-Alive\" header");
  3991.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3992.         goto failed;
  3993.     }

  3995.     if (r->headers_in.transfer_encoding) {
  3996.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  3997.                       "client sent \"Transfer-Encoding\" header");
  3998.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  3999.         goto failed;
  4000.     }

  4002.     if (r->headers_in.upgrade) {
  4003.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4004.                       "client sent \"Upgrade\" header");
  4005.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  4006.         goto failed;
  4007.     }

  4009.     if (r->headers_in.te
  4010.         && (r->headers_in.te->next
  4011.             || r->headers_in.te->value.len != 8
  4012.             || ngx_strncasecmp(r->headers_in.te->value.data,
  4013.                                (u_char *) "trailers", 8) != 0))
  4014.     {
  4015.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4016.                       "client sent invalid \"TE\" header");
  4017.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  4018.         goto failed;
  4019.     }

  4021.     if (r->headers_in.server.len == 0) {
  4022.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4023.                       "client sent neither \":authority\" nor \"Host\" header");
  4024.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  4025.         goto failed;
  4026.     }

  4028.     if (r->host_end) {

  4030.         host.len = r->host_end - r->host_start;
  4031.         host.data = r->host_start;

  4033.         if (r->headers_in.host) {
  4034.             if (r->headers_in.host->value.len != host.len
  4035.                 || ngx_memcmp(r->headers_in.host->value.data, host.data,
  4036.                               host.len)
  4037.                    != 0)
  4038.             {
  4039.                 ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4040.                               "client sent \":authority\" and \"Host\" headers "
  4041.                               "with different values");
  4042.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  4043.                 goto failed;
  4044.             }

  4046.         } else {
  4047.             /* compatibility for $http_host */

  4049.             if (ngx_http_v2_construct_host_header(r) != NGX_OK) {
  4050.                 goto failed;
  4051.             }
  4052.         }
  4053.     }

  4055.     if (r->headers_in.content_length) {
  4056.         r->headers_in.content_length_n =
  4057.                             ngx_atoof(r->headers_in.content_length->value.data,
  4058.                                       r->headers_in.content_length->value.len);

  4060.         if (r->headers_in.content_length_n == NGX_ERROR) {
  4061.             ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4062.                           "client sent invalid \"Content-Length\" header");
  4063.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  4064.             goto failed;
  4065.         }

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

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

  4073.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  4074.             goto failed;
  4075.         }

  4077.     } else if (!r->stream->in_closed) {
  4078.         r->headers_in.chunked = 1;
  4079.     }

  4081.     if (r->method == NGX_HTTP_CONNECT) {
  4082.         ngx_log_error(NGX_LOG_INFO, fc->log, 0, "client sent CONNECT method");
  4083.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  4084.         goto failed;
  4085.     }

  4087.     if (r->method == NGX_HTTP_TRACE) {
  4088.         ngx_log_error(NGX_LOG_INFO, fc->log, 0, "client sent TRACE method");
  4089.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  4090.         goto failed;
  4091.     }

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

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

  4097.     ngx_http_process_request(r);

  4099. failed:

  4101.     ngx_http_run_posted_requests(fc);
  4102. }


  4105. ngx_int_t
  4106. ‌ngx_http_v2_read_request_body(ngx_http_request_t *r)
  4107. {
  4108.     off_t                      len;
  4109.     size_t                     size;
  4110.     ngx_buf_t                 *buf;
  4111.     ngx_int_t                  rc;
  4112.     ngx_http_v2_stream_t      *stream;
  4113.     ngx_http_v2_srv_conf_t    *h2scf;
  4114.     ngx_http_request_body_t   *rb;
  4115.     ngx_http_core_loc_conf_t  *clcf;
  4116.     ngx_http_v2_connection_t  *h2c;

  4118.     stream = r->stream;
  4119.     rb = r->request_body;

  4121.     if (stream->skip_data) {
  4122.         r->request_body_no_buffering = 0;
  4123.         rb->post_handler(r);
  4124.         return NGX_OK;
  4125.     }

  4127.     rb->rest = 1;

  4129.     /* set rb->filter_need_buffering */

  4131.     rc = ngx_http_top_request_body_filter(r, NULL);

  4133.     if (rc != NGX_OK) {
  4134.         stream->skip_data = 1;
  4135.         return rc;
  4136.     }

  4138.     h2scf = ngx_http_get_module_srv_conf(r, ngx_http_v2_module);
  4139.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4141.     len = r->headers_in.content_length_n;

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

  4146.     } else {
  4147.         len++;
  4148.     }

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

  4152.         /*
  4153.          * We need a room to store data up to the stream's initial window size,
  4154.          * at least until this window will be exhausted.
  4155.          */

  4157.         if (len < (off_t) h2scf->preread_size) {
  4158.             len = h2scf->preread_size;
  4159.         }

  4161.         if (len > NGX_HTTP_V2_MAX_WINDOW) {
  4162.             len = NGX_HTTP_V2_MAX_WINDOW;
  4163.         }
  4164.     }

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

  4168.     if (rb->buf == NULL) {
  4169.         stream->skip_data = 1;
  4170.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4171.     }

  4173.     buf = stream->preread;

  4175.     if (stream->in_closed) {
  4176.         if (!rb->filter_need_buffering) {
  4177.             r->request_body_no_buffering = 0;
  4178.         }

  4180.         if (buf) {
  4181.             rc = ngx_http_v2_process_request_body(r, buf->pos,
  4182.                                                   buf->last - buf->pos, 1, 0);
  4183.             ngx_pfree(r->pool, buf->start);

  4185.         } else {
  4186.             rc = ngx_http_v2_process_request_body(r, NULL, 0, 1, 0);
  4187.         }

  4189.         if (rc != NGX_AGAIN) {
  4190.             return rc;
  4191.         }

  4193.         r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
  4194.         r->write_event_handler = ngx_http_request_empty_handler;

  4196.         return NGX_AGAIN;
  4197.     }

  4199.     if (buf) {
  4200.         rc = ngx_http_v2_process_request_body(r, buf->pos,
  4201.                                               buf->last - buf->pos, 0, 0);

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

  4205.         if (rc != NGX_OK && rc != NGX_AGAIN) {
  4206.             stream->skip_data = 1;
  4207.             return rc;
  4208.         }
  4209.     }

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

  4214.     } else {
  4215.         stream->no_flow_control = 1;
  4216.         size = NGX_HTTP_V2_MAX_WINDOW - stream->recv_window;
  4217.     }

  4219.     if (size) {
  4220.         if (ngx_http_v2_send_window_update(stream->connection,
  4221.                                            stream->node->id, size)
  4222.             == NGX_ERROR)
  4223.         {
  4224.             stream->skip_data = 1;
  4225.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4226.         }

  4228.         h2c = stream->connection;

  4230.         if (!h2c->blocked) {
  4231.             if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4232.                 stream->skip_data = 1;
  4233.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4234.             }
  4235.         }

  4237.         stream->recv_window += size;
  4238.     }

  4240.     if (!buf) {
  4241.         ngx_add_timer(r->connection->read, clcf->client_body_timeout);
  4242.     }

  4244.     r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
  4245.     r->write_event_handler = ngx_http_request_empty_handler;

  4247.     return NGX_AGAIN;
  4248. }


  4251. static ngx_int_t
  4252. ‌ngx_http_v2_process_request_body(ngx_http_request_t *r, u_char *pos,
  4253.     size_t size, ngx_uint_t last, ngx_uint_t flush)
  4254. {
  4255.     size_t                     n;
  4256.     ngx_int_t                  rc;
  4257.     ngx_connection_t          *fc;
  4258.     ngx_http_request_body_t   *rb;
  4259.     ngx_http_core_loc_conf_t  *clcf;

  4261.     fc = r->connection;
  4262.     rb = r->request_body;

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

  4267.     if (size == 0 && !last && !flush) {
  4268.         return NGX_AGAIN;
  4269.     }

  4271.     for ( ;; ) {
  4272.         for ( ;; ) {
  4273.             if (rb->buf->last == rb->buf->end && size) {

  4275.                 if (r->request_body_no_buffering) {

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

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

  4282.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4283.                 }

  4285.                 /* update chains */

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

  4290.                 rc = ngx_http_v2_filter_request_body(r);

  4292.                 if (rc != NGX_OK) {
  4293.                     return rc;
  4294.                 }

  4296.                 if (rb->busy != NULL) {
  4297.                     ngx_log_error(NGX_LOG_ALERT, fc->log, 0,
  4298.                                   "busy buffers after request body flush");
  4299.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4300.                 }

  4302.                 rb->buf->pos = rb->buf->start;
  4303.                 rb->buf->last = rb->buf->start;
  4304.             }

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

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

  4310.             if (n > size) {
  4311.                 n = size;
  4312.             }

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

  4317.             if (n > 0) {
  4318.                 rb->buf->last = ngx_cpymem(rb->buf->last, pos, n);
  4319.                 pos += n;
  4320.                 size -= n;
  4321.             }

  4323.             if (size == 0 && last) {
  4324.                 rb->rest = 0;
  4325.             }

  4327.             if (size == 0) {
  4328.                 break;
  4329.             }
  4330.         }

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

  4335.         if (flush) {
  4336.             rc = ngx_http_v2_filter_request_body(r);

  4338.             if (rc != NGX_OK) {
  4339.                 return rc;
  4340.             }
  4341.         }

  4343.         if (rb->rest == 0 && rb->last_saved) {
  4344.             break;
  4345.         }

  4347.         if (size == 0) {
  4348.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  4349.             ngx_add_timer(fc->read, clcf->client_body_timeout);

  4351.             if (!flush) {
  4352.                 ngx_post_event(fc->read, &ngx_posted_events);
  4353.             }

  4355.             return NGX_AGAIN;
  4356.         }
  4357.     }

  4359.     if (fc->read->timer_set) {
  4360.         ngx_del_timer(fc->read);
  4361.     }

  4363.     if (r->request_body_no_buffering) {
  4364.         if (!flush) {
  4365.             ngx_post_event(fc->read, &ngx_posted_events);
  4366.         }

  4368.         return NGX_OK;
  4369.     }

  4371.     if (r->headers_in.chunked) {
  4372.         r->headers_in.content_length_n = rb->received;
  4373.     }

  4375.     r->read_event_handler = ngx_http_block_reading;
  4376.     rb->post_handler(r);

  4378.     return NGX_OK;
  4379. }


  4382. static ngx_int_t
  4383. ‌ngx_http_v2_filter_request_body(ngx_http_request_t *r)
  4384. {
  4385.     ngx_buf_t                 *b, *buf;
  4386.     ngx_int_t                  rc;
  4387.     ngx_chain_t               *cl;
  4388.     ngx_http_request_body_t   *rb;
  4389.     ngx_http_core_loc_conf_t  *clcf;

  4391.     rb = r->request_body;
  4392.     buf = rb->buf;

  4394.     if (buf->pos == buf->last && (rb->rest || rb->last_sent)) {
  4395.         cl = NULL;
  4396.         goto update;
  4397.     }

  4399.     cl = ngx_chain_get_free_buf(r->pool, &rb->free);
  4400.     if (cl == NULL) {
  4401.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4402.     }

  4404.     b = cl->buf;

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

  4408.     if (buf->pos != buf->last) {
  4409.         r->request_length += buf->last - buf->pos;
  4410.         rb->received += buf->last - buf->pos;

  4412.         if (r->headers_in.content_length_n != -1) {
  4413.             if (rb->received > r->headers_in.content_length_n) {
  4414.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  4415.                               "client intended to send body data "
  4416.                               "larger than declared");

  4418.                 return NGX_HTTP_BAD_REQUEST;
  4419.             }

  4421.         } else {
  4422.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4424.             if (clcf->client_max_body_size
  4425.                 && rb->received > clcf->client_max_body_size)
  4426.             {
  4427.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4428.                               "client intended to send too large chunked body: "
  4429.                               "%O bytes", rb->received);

  4431.                 return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  4432.             }
  4433.         }

  4435.         b->temporary = 1;
  4436.         b->pos = buf->pos;
  4437.         b->last = buf->last;
  4438.         b->start = b->pos;
  4439.         b->end = b->last;

  4441.         buf->pos = buf->last;
  4442.     }

  4444.     if (!rb->rest) {
  4445.         if (r->headers_in.content_length_n != -1
  4446.             && r->headers_in.content_length_n != rb->received)
  4447.         {
  4448.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  4449.                           "client prematurely closed stream: "
  4450.                           "only %O out of %O bytes of request body received",
  4451.                           rb->received, r->headers_in.content_length_n);

  4453.             return NGX_HTTP_BAD_REQUEST;
  4454.         }

  4456.         b->last_buf = 1;
  4457.         rb->last_sent = 1;
  4458.     }

  4460.     b->tag = (ngx_buf_tag_t) &ngx_http_v2_filter_request_body;
  4461.     b->flush = r->request_body_no_buffering;

  4463. update:

  4465.     rc = ngx_http_top_request_body_filter(r, cl);

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

  4470.     return rc;
  4471. }


  4474. static void
  4475. ‌ngx_http_v2_read_client_request_body_handler(ngx_http_request_t *r)
  4476. {
  4477.     size_t                     window;
  4478.     ngx_buf_t                 *buf;
  4479.     ngx_int_t                  rc;
  4480.     ngx_connection_t          *fc;
  4481.     ngx_http_v2_stream_t      *stream;
  4482.     ngx_http_v2_connection_t  *h2c;

  4484.     fc = r->connection;

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

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

  4492.         fc->timedout = 1;
  4493.         r->stream->skip_data = 1;

  4495.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  4496.         return;
  4497.     }

  4499.     if (fc->error) {
  4500.         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
  4501.                       "client prematurely closed stream");

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

  4505.         ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  4506.         return;
  4507.     }

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

  4511.     if (rc != NGX_OK && rc != NGX_AGAIN) {
  4512.         r->stream->skip_data = 1;
  4513.         ngx_http_finalize_request(r, rc);
  4514.         return;
  4515.     }

  4517.     if (rc == NGX_OK) {
  4518.         return;
  4519.     }

  4521.     if (r->stream->no_flow_control) {
  4522.         return;
  4523.     }

  4525.     if (r->request_body->rest == 0) {
  4526.         return;
  4527.     }

  4529.     if (r->request_body->busy != NULL) {
  4530.         return;
  4531.     }

  4533.     stream = r->stream;
  4534.     h2c = stream->connection;

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

  4538.     buf->pos = buf->start;
  4539.     buf->last = buf->start;

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

  4543.     if (h2c->state.stream == stream) {
  4544.         window -= h2c->state.length;
  4545.     }

  4547.     if (window <= stream->recv_window) {
  4548.         if (window < stream->recv_window) {
  4549.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  4550.                           "http2 negative window update");

  4552.             stream->skip_data = 1;

  4554.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4555.             return;
  4556.         }

  4558.         return;
  4559.     }

  4561.     if (ngx_http_v2_send_window_update(h2c, stream->node->id,
  4562.                                        window - stream->recv_window)
  4563.         == NGX_ERROR)
  4564.     {
  4565.         stream->skip_data = 1;
  4566.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4567.         return;
  4568.     }

  4570.     stream->recv_window = window;

  4572.     if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4573.         stream->skip_data = 1;
  4574.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  4575.         return;
  4576.     }
  4577. }


  4580. ngx_int_t
  4581. ‌ngx_http_v2_read_unbuffered_request_body(ngx_http_request_t *r)
  4582. {
  4583.     size_t                     window;
  4584.     ngx_buf_t                 *buf;
  4585.     ngx_int_t                  rc;
  4586.     ngx_connection_t          *fc;
  4587.     ngx_http_v2_stream_t      *stream;
  4588.     ngx_http_v2_connection_t  *h2c;

  4590.     stream = r->stream;
  4591.     fc = r->connection;

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

  4596.     if (fc->read->timedout) {
  4597.         if (stream->recv_window) {
  4598.             stream->skip_data = 1;
  4599.             fc->timedout = 1;

  4601.             return NGX_HTTP_REQUEST_TIME_OUT;
  4602.         }

  4604.         fc->read->timedout = 0;
  4605.     }

  4607.     if (fc->error) {
  4608.         stream->skip_data = 1;
  4609.         return NGX_HTTP_BAD_REQUEST;
  4610.     }

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

  4614.     if (rc != NGX_OK && rc != NGX_AGAIN) {
  4615.         stream->skip_data = 1;
  4616.         return rc;
  4617.     }

  4619.     if (rc == NGX_OK) {
  4620.         return NGX_OK;
  4621.     }

  4623.     if (r->request_body->rest == 0) {
  4624.         return NGX_AGAIN;
  4625.     }

  4627.     if (r->request_body->busy != NULL) {
  4628.         return NGX_AGAIN;
  4629.     }

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

  4633.     buf->pos = buf->start;
  4634.     buf->last = buf->start;

  4636.     window = buf->end - buf->start;
  4637.     h2c = stream->connection;

  4639.     if (h2c->state.stream == stream) {
  4640.         window -= h2c->state.length;
  4641.     }

  4643.     if (window <= stream->recv_window) {
  4644.         if (window < stream->recv_window) {
  4645.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  4646.                           "http2 negative window update");
  4647.             stream->skip_data = 1;
  4648.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4649.         }

  4651.         return NGX_AGAIN;
  4652.     }

  4654.     if (ngx_http_v2_send_window_update(h2c, stream->node->id,
  4655.                                        window - stream->recv_window)
  4656.         == NGX_ERROR)
  4657.     {
  4658.         stream->skip_data = 1;
  4659.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4660.     }

  4662.     if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4663.         stream->skip_data = 1;
  4664.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  4665.     }

  4667.     stream->recv_window = window;

  4669.     return NGX_AGAIN;
  4670. }


  4673. static ngx_int_t
  4674. ‌ngx_http_v2_terminate_stream(ngx_http_v2_connection_t *h2c,
  4675.     ngx_http_v2_stream_t *stream, ngx_uint_t status)
  4676. {
  4677.     ngx_event_t       *rev;
  4678.     ngx_connection_t  *fc;

  4680.     if (stream->rst_sent) {
  4681.         return NGX_OK;
  4682.     }

  4684.     if (ngx_http_v2_send_rst_stream(h2c, stream->node->id, status)
  4685.         == NGX_ERROR)
  4686.     {
  4687.         return NGX_ERROR;
  4688.     }

  4690.     stream->rst_sent = 1;
  4691.     stream->skip_data = 1;

  4693.     fc = stream->request->connection;
  4694.     fc->error = 1;

  4696.     rev = fc->read;
  4697.     rev->handler(rev);

  4699.     return NGX_OK;
  4700. }


  4703. void
  4704. ‌ngx_http_v2_close_stream(ngx_http_v2_stream_t *stream, ngx_int_t rc)
  4705. {
  4706.     ngx_pool_t                *pool;
  4707.     ngx_event_t               *ev;
  4708.     ngx_connection_t          *fc;
  4709.     ngx_http_v2_node_t        *node;
  4710.     ngx_http_v2_connection_t  *h2c;

  4712.     h2c = stream->connection;
  4713.     node = stream->node;

  4715.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
  4716.                    "http2 close stream %ui, queued %ui, processing %ui",
  4717.                    node->id, stream->queued, h2c->processing);

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

  4721.     if (stream->queued) {
  4722.         fc->error = 1;
  4723.         fc->write->handler = ngx_http_v2_retry_close_stream_handler;
  4724.         fc->read->handler = ngx_http_v2_retry_close_stream_handler;
  4725.         return;
  4726.     }

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

  4730.         if (!stream->out_closed) {
  4731.             if (ngx_http_v2_send_rst_stream(h2c, node->id,
  4732.                                       fc->timedout ? NGX_HTTP_V2_PROTOCOL_ERROR
  4733.                                                    : NGX_HTTP_V2_INTERNAL_ERROR)
  4734.                 != NGX_OK)
  4735.             {
  4736.                 h2c->connection->error = 1;
  4737.             }

  4739.         } else if (!stream->in_closed) {
  4740.             if (ngx_http_v2_send_rst_stream(h2c, node->id, NGX_HTTP_V2_NO_ERROR)
  4741.                 != NGX_OK)
  4742.             {
  4743.                 h2c->connection->error = 1;
  4744.             }
  4745.         }
  4746.     }

  4748.     if (h2c->state.stream == stream) {
  4749.         h2c->state.stream = NULL;
  4750.     }

  4752.     node->stream = NULL;

  4754.     ngx_queue_insert_tail(&h2c->closed, &node->reuse);
  4755.     h2c->closed_nodes++;

  4757.     /*
  4758.      * This pool keeps decoded request headers which can be used by log phase
  4759.      * handlers in ngx_http_free_request().
  4760.      *
  4761.      * The pointer is stored into local variable because the stream object
  4762.      * will be destroyed after a call to ngx_http_free_request().
  4763.      */
  4764.     pool = stream->pool;

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

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

  4770.     if (pool != h2c->state.pool) {
  4771.         ngx_destroy_pool(pool);

  4773.     } else {
  4774.         /* pool will be destroyed when the complete header is parsed */
  4775.         h2c->state.keep_pool = 0;
  4776.     }

  4778.     ev = fc->read;

  4780.     if (ev->timer_set) {
  4781.         ngx_del_timer(ev);
  4782.     }

  4784.     if (ev->posted) {
  4785.         ngx_delete_posted_event(ev);
  4786.     }

  4788.     ev = fc->write;

  4790.     if (ev->timer_set) {
  4791.         ngx_del_timer(ev);
  4792.     }

  4794.     if (ev->posted) {
  4795.         ngx_delete_posted_event(ev);
  4796.     }

  4798.     fc->data = h2c->free_fake_connections;
  4799.     h2c->free_fake_connections = fc;

  4801.     h2c->processing--;

  4803.     if (h2c->processing || h2c->blocked) {
  4804.         return;
  4805.     }

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

  4809.     ev->handler = ngx_http_v2_handle_connection_handler;
  4810.     ngx_post_event(ev, &ngx_posted_events);
  4811. }


  4814. static void
  4815. ‌ngx_http_v2_close_stream_handler(ngx_event_t *ev)
  4816. {
  4817.     ngx_connection_t    *fc;
  4818.     ngx_http_request_t  *r;

  4820.     fc = ev->data;
  4821.     r = fc->data;

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

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

  4829.         fc->timedout = 1;

  4831.         ngx_http_v2_close_stream(r->stream, NGX_HTTP_REQUEST_TIME_OUT);
  4832.         return;
  4833.     }

  4835.     ngx_http_v2_close_stream(r->stream, 0);
  4836. }


  4839. static void
  4840. ‌ngx_http_v2_retry_close_stream_handler(ngx_event_t *ev)
  4841. {
  4842.     ngx_connection_t    *fc;
  4843.     ngx_http_request_t  *r;

  4845.     fc = ev->data;
  4846.     r = fc->data;

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

  4851.     ngx_http_v2_close_stream(r->stream, 0);
  4852. }


  4855. static void
  4856. ‌ngx_http_v2_handle_connection_handler(ngx_event_t *rev)
  4857. {
  4858.     ngx_connection_t          *c;
  4859.     ngx_http_v2_connection_t  *h2c;

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

  4864.     c = rev->data;
  4865.     h2c = c->data;

  4867.     if (c->error) {
  4868.         ngx_http_v2_finalize_connection(h2c, 0);
  4869.         return;
  4870.     }

  4872.     rev->handler = ngx_http_v2_read_handler;

  4874.     if (rev->ready) {
  4875.         ngx_http_v2_read_handler(rev);
  4876.         return;
  4877.     }

  4879.     if (h2c->last_out && ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
  4880.         ngx_http_v2_finalize_connection(h2c, 0);
  4881.         return;
  4882.     }

  4884.     ngx_http_v2_handle_connection(c->data);
  4885. }


  4888. static void
  4889. ‌ngx_http_v2_idle_handler(ngx_event_t *rev)
  4890. {
  4891.     ngx_connection_t          *c;
  4892.     ngx_http_v2_srv_conf_t    *h2scf;
  4893.     ngx_http_v2_connection_t  *h2c;
  4894.     ngx_http_core_loc_conf_t  *clcf;

  4896.     c = rev->data;
  4897.     h2c = c->data;

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

  4901.     if (rev->timedout || c->close) {
  4902.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  4903.         return;
  4904.     }

  4906. #if (NGX_HAVE_KQUEUE)

  4908.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  4909.         if (rev->pending_eof) {
  4910.             c->log->handler = NULL;
  4911.             ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  4912.                           "kevent() reported that client %V closed "
  4913.                           "idle connection", &c->addr_text);
  4914. #if (NGX_HTTP_SSL)
  4915.             if (c->ssl) {
  4916.                 c->ssl->no_send_shutdown = 1;
  4917.             }
  4918. #endif
  4919.             ngx_http_close_connection(c);
  4920.             return;
  4921.         }
  4922.     }

  4924. #endif

  4926.     clcf = ngx_http_get_module_loc_conf(h2c->http_connection->conf_ctx,
  4927.                                         ngx_http_core_module);

  4929.     if (h2c->idle++ > 10 * clcf->keepalive_requests) {
  4930.         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
  4931.                       "http2 flood detected");
  4932.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_NO_ERROR);
  4933.         return;
  4934.     }

  4936.     c->destroyed = 0;
  4937.     ngx_reusable_connection(c, 0);

  4939.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4940.                                          ngx_http_v2_module);

  4942.     h2c->pool = ngx_create_pool(h2scf->pool_size, h2c->connection->log);
  4943.     if (h2c->pool == NULL) {
  4944.         ngx_http_v2_finalize_connection(h2c, NGX_HTTP_V2_INTERNAL_ERROR);
  4945.         return;
  4946.     }

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

  4950.     rev->handler = ngx_http_v2_read_handler;
  4951.     ngx_http_v2_read_handler(rev);
  4952. }


  4955. static void
  4956. ‌ngx_http_v2_finalize_connection(ngx_http_v2_connection_t *h2c,
  4957.     ngx_uint_t status)
  4958. {
  4959.     ngx_uint_t               i, size;
  4960.     ngx_event_t             *ev;
  4961.     ngx_connection_t        *c, *fc;
  4962.     ngx_http_request_t      *r;
  4963.     ngx_http_v2_node_t      *node;
  4964.     ngx_http_v2_stream_t    *stream;
  4965.     ngx_http_v2_srv_conf_t  *h2scf;

  4967.     c = h2c->connection;

  4969.     h2c->blocked = 1;

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

  4974.         if (ngx_http_v2_send_goaway(h2c, status) != NGX_ERROR) {
  4975.             (void) ngx_http_v2_send_output_queue(h2c);
  4976.         }
  4977.     }

  4979.     if (!h2c->processing) {
  4980.         goto done;
  4981.     }

  4983.     c->read->handler = ngx_http_empty_handler;
  4984.     c->write->handler = ngx_http_empty_handler;

  4986.     h2c->last_out = NULL;

  4988.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  4989.                                          ngx_http_v2_module);

  4991.     size = ngx_http_v2_index_size(h2scf);

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

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

  4998.             if (stream == NULL) {
  4999.                 continue;
  5000.             }

  5002.             stream->waiting = 0;

  5004.             r = stream->request;
  5005.             fc = r->connection;

  5007.             fc->error = 1;

  5009.             if (stream->queued) {
  5010.                 stream->queued = 0;

  5012.                 ev = fc->write;
  5013.                 ev->active = 0;
  5014.                 ev->ready = 1;

  5016.             } else {
  5017.                 ev = fc->read;
  5018.             }

  5020.             ev->eof = 1;
  5021.             ev->handler(ev);
  5022.         }
  5023.     }

  5025.     h2c->blocked = 0;

  5027.     if (h2c->processing) {
  5028.         c->error = 1;
  5029.         return;
  5030.     }

  5032. done:

  5034.     if (c->error) {
  5035.         ngx_http_close_connection(c);
  5036.         return;
  5037.     }

  5039.     ngx_http_v2_lingering_close(c);
  5040. }


  5043. static ngx_int_t
  5044. ‌ngx_http_v2_adjust_windows(ngx_http_v2_connection_t *h2c, ssize_t delta)
  5045. {
  5046.     ngx_uint_t               i, size;
  5047.     ngx_event_t             *wev;
  5048.     ngx_http_v2_node_t      *node;
  5049.     ngx_http_v2_stream_t    *stream;
  5050.     ngx_http_v2_srv_conf_t  *h2scf;

  5052.     h2scf = ngx_http_get_module_srv_conf(h2c->http_connection->conf_ctx,
  5053.                                          ngx_http_v2_module);

  5055.     size = ngx_http_v2_index_size(h2scf);

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

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

  5062.             if (stream == NULL) {
  5063.                 continue;
  5064.             }

  5066.             if (delta > 0
  5067.                 && stream->send_window
  5068.                       > (ssize_t) (NGX_HTTP_V2_MAX_WINDOW - delta))
  5069.             {
  5070.                 if (ngx_http_v2_terminate_stream(h2c, stream,
  5071.                                                  NGX_HTTP_V2_FLOW_CTRL_ERROR)
  5072.                     == NGX_ERROR)
  5073.                 {
  5074.                     return NGX_ERROR;
  5075.                 }

  5077.                 continue;
  5078.             }

  5080.             stream->send_window += delta;

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

  5086.             if (stream->send_window > 0 && stream->exhausted) {
  5087.                 stream->exhausted = 0;

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

  5091.                 wev->active = 0;
  5092.                 wev->ready = 1;

  5094.                 if (!wev->delayed) {
  5095.                     wev->handler(wev);
  5096.                 }
  5097.             }
  5098.         }
  5099.     }

  5101.     return NGX_OK;
  5102. }


  5105. static void
  5106. ‌ngx_http_v2_pool_cleanup(void *data)
  5107. {
  5108.     ngx_http_v2_connection_t  *h2c = data;

  5110.     if (h2c->state.pool) {
  5111.         ngx_destroy_pool(h2c->state.pool);
  5112.     }

  5114.     if (h2c->pool) {
  5115.         ngx_destroy_pool(h2c->pool);
  5116.     }
  5117. }

One Level Up Top Level