One Level Up Top Level

src/http/modules/ngx_http_proxy_v2_module.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Maxim Dounin
  4. * Copyright (C) Nginx, Inc.
  5. */


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


  14. ‌typedef enum {
  15.     ngx_http_proxy_v2_st_start = 0,
  16.     ngx_http_proxy_v2_st_length_2,
  17.     ngx_http_proxy_v2_st_length_3,
  18.     ngx_http_proxy_v2_st_type,
  19.     ngx_http_proxy_v2_st_flags,
  20.     ngx_http_proxy_v2_st_stream_id,
  21.     ngx_http_proxy_v2_st_stream_id_2,
  22.     ngx_http_proxy_v2_st_stream_id_3,
  23.     ngx_http_proxy_v2_st_stream_id_4,
  24.     ngx_http_proxy_v2_st_payload,
  25.     ngx_http_proxy_v2_st_padding
  26. ‌} ngx_http_proxy_v2_state_e;


  29. ‌typedef struct {
  30.     size_t                         init_window;
  31.     size_t                         send_window;
  32.     size_t                         recv_window;
  33.     ngx_uint_t                     last_stream_id;
  34. ‌} ngx_http_proxy_v2_conn_t;


  37. ‌typedef struct {
  38.     ngx_http_proxy_ctx_t           ctx;

  40.     ngx_http_proxy_v2_state_e      state;
  41.     ngx_uint_t                     frame_state;
  42.     ngx_uint_t                     fragment_state;

  44.     ngx_chain_t                   *in;
  45.     ngx_chain_t                   *out;
  46.     ngx_chain_t                   *free;
  47.     ngx_chain_t                   *busy;

  49.     ngx_http_proxy_v2_conn_t      *connection;

  51.     ngx_uint_t                     id;

  53.     ngx_uint_t                     pings;
  54.     ngx_uint_t                     settings;

  56.     off_t                          length;

  58.     ssize_t                        send_window;
  59.     size_t                         recv_window;

  61.     size_t                         rest;
  62.     ngx_uint_t                     stream_id;
  63.     u_char                         type;
  64.     u_char                         flags;
  65.     u_char                         padding;

  67.     ngx_uint_t                     error;
  68.     ngx_uint_t                     window_update;

  70.     ngx_uint_t                     setting_id;
  71.     ngx_uint_t                     setting_value;

  73.     u_char                         ping_data[8];

  75.     ngx_uint_t                     index;
  76.     ngx_str_t                      name;
  77.     ngx_str_t                      value;

  79.     u_char                        *field_end;
  80.     size_t                         header_limit;
  81.     size_t                         field_length;
  82.     size_t                         field_rest;
  83.     u_char                         field_state;

  85.     unsigned                       literal:1;
  86.     unsigned                       field_huffman:1;

  88.     unsigned                       header_sent:1;
  89.     unsigned                       output_closed:1;
  90.     unsigned                       output_blocked:1;
  91.     unsigned                       parsing_headers:1;
  92.     unsigned                       end_stream:1;
  93.     unsigned                       done:1;
  94.     unsigned                       status:1;
  95.     unsigned                       rst:1;
  96.     unsigned                       goaway:1;
  97. ‌} ngx_http_proxy_v2_ctx_t;


  100. ‌typedef struct {
  101.     u_char                        length_0;
  102.     u_char                        length_1;
  103.     u_char                        length_2;
  104.     u_char                        type;
  105.     u_char                        flags;
  106.     u_char                        stream_id_0;
  107.     u_char                        stream_id_1;
  108.     u_char                        stream_id_2;
  109.     u_char                        stream_id_3;
  110. ‌} ngx_http_proxy_v2_frame_t;


  113. static ngx_int_t ngx_http_proxy_v2_create_request(ngx_http_request_t *r);
  114. static ngx_int_t ngx_http_proxy_v2_reinit_request(ngx_http_request_t *r);
  115. static ngx_int_t ngx_http_proxy_v2_body_output_filter(void *data,
  116.     ngx_chain_t *in);
  117. static ngx_int_t ngx_http_proxy_v2_process_header(ngx_http_request_t *r);
  118. static ngx_int_t ngx_http_proxy_v2_filter_init(void *data);
  119. static ngx_int_t ngx_http_proxy_v2_non_buffered_filter(void *data,
  120.     ssize_t bytes);
  121. static ngx_int_t ngx_http_proxy_v2_body_filter(ngx_event_pipe_t *p,
  122.     ngx_buf_t *buf);
  123. static ngx_int_t ngx_http_proxy_v2_process_control_frame(ngx_http_request_t *r,
  124.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);
  125. static ngx_int_t ngx_http_proxy_v2_skip_frame(ngx_http_proxy_v2_ctx_t *ctx,
  126.     ngx_buf_t *b);
  127. static ngx_int_t ngx_http_proxy_v2_process_frames(ngx_http_request_t *r,
  128.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);

  130. static ngx_int_t ngx_http_proxy_v2_parse_frame(ngx_http_request_t *r,
  131.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);
  132. static ngx_int_t ngx_http_proxy_v2_parse_header(ngx_http_request_t *r,
  133.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);
  134. static ngx_int_t ngx_http_proxy_v2_parse_fragment(ngx_http_request_t *r,
  135.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);
  136. static ngx_int_t ngx_http_proxy_v2_validate_header_name(ngx_http_request_t *r,
  137.     ngx_str_t *s);
  138. static ngx_int_t ngx_http_proxy_v2_validate_header_value(ngx_http_request_t *r,
  139.     ngx_str_t *s);
  140. static ngx_int_t ngx_http_proxy_v2_parse_rst_stream(ngx_http_request_t *r,
  141.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);
  142. static ngx_int_t ngx_http_proxy_v2_parse_goaway(ngx_http_request_t *r,
  143.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);
  144. static ngx_int_t ngx_http_proxy_v2_parse_window_update(ngx_http_request_t *r,
  145.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);
  146. static ngx_int_t ngx_http_proxy_v2_parse_settings(ngx_http_request_t *r,
  147.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);
  148. static ngx_int_t ngx_http_proxy_v2_parse_ping(ngx_http_request_t *r,
  149.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b);

  151. static ngx_int_t ngx_http_proxy_v2_send_settings_ack(ngx_http_request_t *r,
  152.     ngx_http_proxy_v2_ctx_t *ctx);
  153. static ngx_int_t ngx_http_proxy_v2_send_ping_ack(ngx_http_request_t *r,
  154.     ngx_http_proxy_v2_ctx_t *ctx);
  155. static ngx_int_t ngx_http_proxy_v2_send_window_update(ngx_http_request_t *r,
  156.     ngx_http_proxy_v2_ctx_t *ctx);

  158. static ngx_chain_t *ngx_http_proxy_v2_get_buf(ngx_http_request_t *r,
  159.     ngx_http_proxy_v2_ctx_t *ctx);
  160. static ngx_http_proxy_v2_ctx_t *
  161.     ngx_http_proxy_v2_get_ctx(ngx_http_request_t *r);
  162. static ngx_int_t ngx_http_proxy_v2_get_connection_data(ngx_http_request_t *r,
  163.     ngx_http_proxy_v2_ctx_t *ctx, ngx_peer_connection_t *pc);
  164. static ngx_inline ngx_int_t ngx_http_proxy_v2_cached(ngx_http_request_t *r);
  165. static void ngx_http_proxy_v2_cleanup(void *data);

  167. static void ngx_http_proxy_v2_abort_request(ngx_http_request_t *r);
  168. static void ngx_http_proxy_v2_finalize_request(ngx_http_request_t *r,
  169.     ngx_int_t rc);


  172. ‌static ngx_http_module_t  ngx_http_proxy_v2_module_ctx = {
  173.     NULL,                                  /* preconfiguration */
  174.     NULL,                                  /* postconfiguration */

  176.     NULL,                                  /* create main configuration */
  177.     NULL,                                  /* init main configuration */

  179.     NULL,                                  /* create server configuration */
  180.     NULL,                                  /* merge server configuration */

  182.     NULL,                                  /* create location configuration */
  183.     NULL                                   /* merge location configuration */
  184. };


  187. ‌ngx_module_t  ngx_http_proxy_v2_module = {
  188.     NGX_MODULE_V1,
  189.     &ngx_http_proxy_v2_module_ctx,         /* module context */
  190.     NULL,                                  /* module directives */
  191.     NGX_HTTP_MODULE,                       /* module type */
  192.     NULL,                                  /* init master */
  193.     NULL,                                  /* init module */
  194.     NULL,                                  /* init process */
  195.     NULL,                                  /* init thread */
  196.     NULL,                                  /* exit thread */
  197.     NULL,                                  /* exit process */
  198.     NULL,                                  /* exit master */
  199.     NGX_MODULE_V1_PADDING
  200. };


  203. ‌static u_char  ngx_http_proxy_v2_connection_start[] =
  204.     "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"         /* connection preface */

  206.     "\x00\x00\x12\x04\x00\x00\x00\x00\x00"     /* settings frame */
  207.     "\x00\x01\x00\x00\x00\x00"                 /* header table size */
  208.     "\x00\x02\x00\x00\x00\x00"                 /* disable push */
  209.     "\x00\x04\x7f\xff\xff\xff"                 /* initial window */

  211.     "\x00\x00\x04\x08\x00\x00\x00\x00\x00"     /* window update frame */
  212.     "\x7f\xff\x00\x00";


  215. ngx_int_t
  216. ‌ngx_http_proxy_v2_handler(ngx_http_request_t *r)
  217. {
  218.     ngx_int_t                    rc;
  219.     ngx_http_upstream_t         *u;
  220.     ngx_http_proxy_v2_ctx_t     *ctx;
  221.     ngx_http_proxy_loc_conf_t   *plcf;
  222. #if (NGX_HTTP_CACHE)
  223.     ngx_http_proxy_main_conf_t  *pmcf;
  224. #endif

  226.     if (ngx_http_upstream_create(r) != NGX_OK) {
  227.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  228.     }

  230.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_proxy_v2_ctx_t));
  231.     if (ctx == NULL) {
  232.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  233.     }

  235.     ngx_http_set_ctx(r, ctx, ngx_http_proxy_v2_module);

  237.     ngx_http_set_ctx(r, &ctx->ctx, ngx_http_proxy_module);

  239.     plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);

  241.     plcf->upstream.preserve_output = 1;

  243.     u = r->upstream;

  245.     if (plcf->proxy_lengths == NULL) {
  246.         ctx->ctx.vars = plcf->vars;
  247.         u->schema = plcf->vars.schema;
  248. #if (NGX_HTTP_SSL)
  249.         u->ssl = plcf->ssl;
  250. #endif

  252.     } else {
  253.         if (ngx_http_proxy_eval(r, &ctx->ctx, plcf) != NGX_OK) {
  254.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  255.         }
  256.     }

  258. #if (NGX_HTTP_SSL)
  259.     ngx_str_set(&u->ssl_alpn_protocol, NGX_HTTP_V2_ALPN_PROTO);
  260. #endif

  262.     u->output.tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_module;

  264.     u->conf = &plcf->upstream;

  266. #if (NGX_HTTP_CACHE)
  267.     pmcf = ngx_http_get_module_main_conf(r, ngx_http_proxy_module);

  269.     u->caches = &pmcf->caches;
  270.     u->create_key = ngx_http_proxy_create_key;
  271. #endif

  273.     u->create_request = ngx_http_proxy_v2_create_request;
  274.     u->reinit_request = ngx_http_proxy_v2_reinit_request;
  275.     u->process_header = ngx_http_proxy_v2_process_header;
  276.     u->abort_request = ngx_http_proxy_v2_abort_request;
  277.     u->finalize_request = ngx_http_proxy_v2_finalize_request;

  279.     if (plcf->redirects) {
  280.         u->rewrite_redirect = ngx_http_proxy_rewrite_redirect;
  281.     }

  283.     if (plcf->cookie_domains || plcf->cookie_paths || plcf->cookie_flags) {
  284.         u->rewrite_cookie = ngx_http_proxy_rewrite_cookie;
  285.     }

  287.     u->buffering = plcf->upstream.buffering;

  289.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  290.     if (u->pipe == NULL) {
  291.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  292.     }

  294.     u->pipe->input_filter = ngx_http_proxy_v2_body_filter;
  295.     u->pipe->input_ctx = r;

  297.     u->input_filter_init = ngx_http_proxy_v2_filter_init;
  298.     u->input_filter = ngx_http_proxy_v2_non_buffered_filter;
  299.     u->input_filter_ctx = r;

  301.     u->accel = 1;

  303.     if (!plcf->upstream.request_buffering
  304.         && plcf->body_values == NULL && plcf->upstream.pass_request_body)
  305.     {
  306.         r->request_body_no_buffering = 1;
  307.     }

  309.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  311.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  312.         return rc;
  313.     }

  315.     return NGX_DONE;
  316. }


  319. static ngx_int_t
  320. ‌ngx_http_proxy_v2_create_request(ngx_http_request_t *r)
  321. {
  322.     u_char                       *p, *tmp, *key_tmp, *val_tmp, *headers_frame,
  323.                                  *headers_end;
  324.     size_t                        len, headers_len, tmp_len,
  325.                                   key_len, val_len, uri_len,
  326.                                   loc_len, body_len;
  327.     uintptr_t                     escape;
  328.     ngx_buf_t                    *b;
  329.     ngx_str_t                     method, host;
  330.     ngx_uint_t                    i, next, unparsed_uri;
  331.     ngx_chain_t                  *cl, *body;
  332.     ngx_list_part_t              *part;
  333.     ngx_table_elt_t              *header;
  334.     ngx_http_upstream_t          *u;
  335.     ngx_http_proxy_v2_ctx_t      *ctx;
  336.     ngx_http_script_code_pt       code;
  337.     ngx_http_script_engine_t      e, le;
  338.     ngx_http_proxy_headers_t     *headers;
  339.     ngx_http_proxy_v2_frame_t    *f;
  340.     ngx_http_proxy_loc_conf_t    *plcf;
  341.     ngx_http_script_len_code_pt   lcode;

  343.     u = r->upstream;

  345.     plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);

  347. #if (NGX_HTTP_CACHE)
  348.     headers = u->cacheable ? &plcf->headers_cache : &plcf->headers;
  349. #else
  350.     headers = &plcf->headers;
  351. #endif

  353.     if (u->method.len) {
  354.         /* HEAD was changed to GET to cache response */
  355.         method = u->method;

  357.     } else if (plcf->method) {
  358.         if (ngx_http_complex_value(r, plcf->method, &method) != NGX_OK) {
  359.             return NGX_ERROR;
  360.         }

  362.     } else {
  363.         method = r->method_name;
  364.     }

  366.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  368.     if (method.len == 4
  369.         && ngx_strncasecmp(method.data, (u_char *) "HEAD", 4) == 0)
  370.     {
  371.         ctx->ctx.head = 1;
  372.     }

  374.     len = sizeof(ngx_http_proxy_v2_connection_start) - 1
  375.           + sizeof(ngx_http_proxy_v2_frame_t);             /* headers frame */

  377.     headers_len = 0;

  379.     /* :method header */

  381.     if ((method.len == 3 && ngx_strncmp(method.data, "GET", 3) == 0)
  382.         || (method.len == 4 && ngx_strncmp(method.data, "POST", 4) == 0))
  383.     {
  384.         len += 1;
  385.         tmp_len = 0;

  387.     } else {
  388.         if (method.len > NGX_HTTP_V2_MAX_FIELD) {
  389.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  390.                           "too long http2 method: \"%V\"", &method);
  391.             return NGX_ERROR;
  392.         }

  394.         len += 1 + NGX_HTTP_V2_INT_OCTETS + method.len;
  395.         tmp_len = method.len;
  396.     }

  398.     /* :scheme header */

  400.     len += 1;

  402.     /* :path header */

  404.     escape = 0;
  405.     loc_len = 0;
  406.     unparsed_uri = 0;

  408.     if (plcf->proxy_lengths && ctx->ctx.vars.uri.len) {
  409.         uri_len = ctx->ctx.vars.uri.len;

  411.     } else if (ctx->ctx.vars.uri.len == 0 && r->valid_unparsed_uri) {
  412.         unparsed_uri = 1;
  413.         uri_len = r->unparsed_uri.len;

  415.     } else {
  416.         loc_len = (r->valid_location && ctx->ctx.vars.uri.len)
  417.                   ? ngx_min(plcf->location.len, r->uri.len) : 0;

  419.         if (r->quoted_uri || r->internal) {
  420.             escape = 2 * ngx_escape_uri(NULL, r->uri.data + loc_len,
  421.                                         r->uri.len - loc_len, NGX_ESCAPE_URI);
  422.         }

  424.         uri_len = ctx->ctx.vars.uri.len + r->uri.len - loc_len + escape
  425.                   + sizeof("?") - 1 + r->args.len;
  426.     }

  428.     if (uri_len == 0) {
  429.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  430.                       "zero length URI to proxy");
  431.         return NGX_ERROR;
  432.     }

  434.     if (uri_len > NGX_HTTP_V2_MAX_FIELD) {
  435.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  436.                       "too long http2 URI");
  437.         return NGX_ERROR;
  438.     }

  440.     len += 1 + NGX_HTTP_V2_INT_OCTETS + uri_len;

  442.     if (tmp_len < uri_len) {
  443.         tmp_len = uri_len;
  444.     }

  446.     /* :authority header */

  448.     host.len = 0;
  449. #if (NGX_SUPPRESS_WARN)
  450.     host.data = NULL;
  451. #endif

  453.     if (plcf->host_value
  454.         && ngx_http_complex_value(r, plcf->host_value, &host) != NGX_OK)
  455.     {
  456.         return NGX_ERROR;
  457.     }

  459.     if (host.len == 0) {
  460.         host = ctx->ctx.vars.host_header;
  461.     }

  463.     if (host.len > NGX_HTTP_V2_MAX_FIELD) {
  464.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  465.                       "too long http2 host: \"%V\"", &host);
  466.         return NGX_ERROR;
  467.     }

  469.     len += 1 + NGX_HTTP_V2_INT_OCTETS + host.len;

  471.     if (tmp_len < host.len) {
  472.         tmp_len = host.len;
  473.     }

  475.     /* other headers */

  477.     ngx_memzero(&le, sizeof(ngx_http_script_engine_t));

  479.     ngx_http_script_flush_no_cacheable_variables(r, plcf->body_flushes);
  480.     ngx_http_script_flush_no_cacheable_variables(r, headers->flushes);

  482.     body_len = 0;

  484.     if (plcf->body_lengths) {
  485.         le.ip = plcf->body_lengths->elts;
  486.         le.request = r;
  487.         le.flushed = 1;

  489.         while (*(uintptr_t *) le.ip) {
  490.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  491.             body_len += lcode(&le);
  492.         }

  494.         ctx->ctx.internal_body_length = body_len;

  496.     } else if (r->headers_in.chunked && r->reading_body) {
  497.         ctx->ctx.internal_body_length = -1;

  499.     } else {
  500.         ctx->ctx.internal_body_length = r->headers_in.content_length_n;
  501.     }

  503.     le.ip = headers->lengths->elts;
  504.     le.request = r;
  505.     le.flushed = 1;

  507.     while (*(uintptr_t *) le.ip) {

  509.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  510.         key_len = lcode(&le);

  512.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  513.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  514.         }
  515.         le.ip += sizeof(uintptr_t);

  517.         if (val_len == 0) {
  518.             continue;
  519.         }

  521.         if (key_len > NGX_HTTP_V2_MAX_FIELD) {
  522.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  523.                           "too long http2 header name");
  524.             return NGX_ERROR;
  525.         }

  527.         if (val_len > NGX_HTTP_V2_MAX_FIELD) {
  528.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  529.                           "too long http2 header value");
  530.             return NGX_ERROR;
  531.         }

  533.         headers_len += 1 + NGX_HTTP_V2_INT_OCTETS + key_len
  534.                          + NGX_HTTP_V2_INT_OCTETS + val_len;

  536.         if (tmp_len < key_len) {
  537.             tmp_len = key_len;
  538.         }

  540.         if (tmp_len < val_len) {
  541.             tmp_len = val_len;
  542.         }
  543.     }

  545.     len += headers_len;

  547.     if (plcf->upstream.pass_request_headers) {
  548.         part = &r->headers_in.headers.part;
  549.         header = part->elts;

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

  553.             if (i >= part->nelts) {
  554.                 if (part->next == NULL) {
  555.                     break;
  556.                 }

  558.                 part = part->next;
  559.                 header = part->elts;
  560.                 i = 0;
  561.             }

  563.             if (ngx_hash_find(&headers->hash, header[i].hash,
  564.                               header[i].lowcase_key, header[i].key.len))
  565.             {
  566.                 continue;
  567.             }

  569.             if (header[i].key.len > NGX_HTTP_V2_MAX_FIELD) {
  570.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  571.                               "too long http2 header name: \"%V\"",
  572.                               &header[i].key);
  573.                 return NGX_ERROR;
  574.             }

  576.             if (header[i].value.len > NGX_HTTP_V2_MAX_FIELD) {
  577.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  578.                               "too long http2 header value: \"%V: %V\"",
  579.                               &header[i].key, &header[i].value);
  580.                 return NGX_ERROR;
  581.             }

  583.             len += 1 + NGX_HTTP_V2_INT_OCTETS + header[i].key.len
  584.                      + NGX_HTTP_V2_INT_OCTETS + header[i].value.len;

  586.             if (tmp_len < header[i].key.len) {
  587.                 tmp_len = header[i].key.len;
  588.             }

  590.             if (tmp_len < header[i].value.len) {
  591.                 tmp_len = header[i].value.len;
  592.             }
  593.         }
  594.     }

  596.     /* continuation frames */

  598.     len += sizeof(ngx_http_proxy_v2_frame_t)
  599.            * (len / NGX_HTTP_V2_DEFAULT_FRAME_SIZE);


  602.     b = ngx_create_temp_buf(r->pool, len);
  603.     if (b == NULL) {
  604.         return NGX_ERROR;
  605.     }

  607.     cl = ngx_alloc_chain_link(r->pool);
  608.     if (cl == NULL) {
  609.         return NGX_ERROR;
  610.     }

  612.     cl->buf = b;
  613.     cl->next = NULL;

  615.     tmp = ngx_palloc(r->pool, tmp_len * 3);
  616.     if (tmp == NULL) {
  617.         return NGX_ERROR;
  618.     }

  620.     key_tmp = tmp + tmp_len;
  621.     val_tmp = tmp + 2 * tmp_len;

  623.     /* connection preface */

  625.     b->last = ngx_copy(b->last, ngx_http_proxy_v2_connection_start,
  626.                        sizeof(ngx_http_proxy_v2_connection_start) - 1);

  628.     /* headers frame */

  630.     headers_frame = b->last;

  632.     f = (ngx_http_proxy_v2_frame_t *) b->last;
  633.     b->last += sizeof(ngx_http_proxy_v2_frame_t);

  635.     f->length_0 = 0;
  636.     f->length_1 = 0;
  637.     f->length_2 = 0;
  638.     f->type = NGX_HTTP_V2_HEADERS_FRAME;
  639.     f->flags = 0;
  640.     f->stream_id_0 = 0;
  641.     f->stream_id_1 = 0;
  642.     f->stream_id_2 = 0;
  643.     f->stream_id_3 = 1;

  645.     if (method.len == 3 && ngx_strncmp(method.data, "GET", 3) == 0) {
  646.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_METHOD_GET_INDEX);

  648.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  649.                        "http proxy header: \":method: GET\"");

  651.     } else if (method.len == 4 && ngx_strncmp(method.data, "POST", 4) == 0) {
  652.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_METHOD_POST_INDEX);

  654.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  655.                        "http proxy header: \":method: POST\"");

  657.     } else {
  658.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_METHOD_INDEX);
  659.         b->last = ngx_http_v2_write_value(b->last, method.data,
  660.                                           method.len, tmp);

  662.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  663.                        "http proxy header: \":method: %V\"", &method);
  664.     }

  666. #if (NGX_HTTP_SSL)
  667.     if (u->ssl) {
  668.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTPS_INDEX);

  670.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  671.                        "http proxy header: \":scheme: https\"");
  672.     } else
  673. #endif
  674.     {
  675.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTP_INDEX);

  677.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  678.                        "http proxy header: \":scheme: http\"");
  679.     }

  681.     if (plcf->proxy_lengths && ctx->ctx.vars.uri.len) {

  683.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  684.         b->last = ngx_http_v2_write_value(b->last, ctx->ctx.vars.uri.data,
  685.                                           ctx->ctx.vars.uri.len, tmp);

  687.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  688.                        "http proxy header: \":path: %V\"", &ctx->ctx.vars.uri);

  690.     } else if (unparsed_uri) {

  692.         if (r->unparsed_uri.len == 1 && r->unparsed_uri.data[0] == '/') {
  693.             *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_PATH_ROOT_INDEX);

  695.         } else {
  696.             *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  697.             b->last = ngx_http_v2_write_value(b->last, r->unparsed_uri.data,
  698.                                               r->unparsed_uri.len, tmp);
  699.         }

  701.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  702.                        "http proxy header: \":path: %V\"", &r->unparsed_uri);

  704.     } else {
  705.         p = val_tmp;

  707.         if (r->valid_location) {
  708.             p = ngx_copy(p, ctx->ctx.vars.uri.data, ctx->ctx.vars.uri.len);
  709.         }

  711.         if (escape) {
  712.             ngx_escape_uri(p, r->uri.data + loc_len,
  713.                            r->uri.len - loc_len, NGX_ESCAPE_URI);
  714.             p += r->uri.len - loc_len + escape;

  716.         } else {
  717.             p = ngx_copy(p, r->uri.data + loc_len, r->uri.len - loc_len);
  718.         }

  720.         if (r->args.len > 0) {
  721.             *p++ = '?';
  722.             p = ngx_copy(p, r->args.data, r->args.len);
  723.         }

  725.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  726.         b->last = ngx_http_v2_write_value(b->last, val_tmp, p - val_tmp, tmp);

  728.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  729.                        "http proxy header: \":path: %*s\"", p - val_tmp,
  730.                        val_tmp);
  731.     }

  733.     *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_AUTHORITY_INDEX);
  734.     b->last = ngx_http_v2_write_value(b->last, host.data, host.len, tmp);

  736.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  737.                    "http proxy header: \":authority: %V\"", &host);

  739.     ngx_memzero(&e, sizeof(ngx_http_script_engine_t));

  741.     e.ip = headers->values->elts;
  742.     e.request = r;
  743.     e.flushed = 1;

  745.     le.ip = headers->lengths->elts;

  747.     headers_end = b->last + headers_len;

  749.     while (*(uintptr_t *) le.ip) {

  751.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  752.         key_len = lcode(&le);

  754.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  755.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  756.         }
  757.         le.ip += sizeof(uintptr_t);

  759.         if (val_len == 0) {
  760.             e.skip = 1;

  762.             while (*(uintptr_t *) e.ip) {
  763.                 code = *(ngx_http_script_code_pt *) e.ip;
  764.                 code((ngx_http_script_engine_t *) &e);
  765.             }
  766.             e.ip += sizeof(uintptr_t);

  768.             e.skip = 0;

  770.             continue;
  771.         }

  773.         if (headers_end - b->last < 1) {
  774.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  775.                           "no buffer space in HTTP/2 create request");
  776.             return NGX_ERROR;
  777.         }

  779.         *b->last++ = 0;

  781.         e.pos = key_tmp;
  782.         e.end = key_tmp + tmp_len;

  784.         code = *(ngx_http_script_code_pt *) e.ip;
  785.         code((ngx_http_script_engine_t *) &e);

  787.         if (e.status) {
  788.             return NGX_ERROR;
  789.         }

  791.         key_len = e.pos - key_tmp;

  793.         if (headers_end - b->last
  794.             < (ssize_t) (NGX_HTTP_V2_INT_OCTETS + key_len))
  795.         {
  796.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  797.                           "no buffer space in HTTP/2 create request");
  798.             return NGX_ERROR;
  799.         }

  801.         b->last = ngx_http_v2_write_name(b->last, key_tmp, key_len, tmp);

  803.         e.pos = val_tmp;
  804.         e.end = val_tmp + tmp_len;

  806.         while (*(uintptr_t *) e.ip) {
  807.             code = *(ngx_http_script_code_pt *) e.ip;
  808.             code((ngx_http_script_engine_t *) &e);
  809.         }
  810.         e.ip += sizeof(uintptr_t);

  812.         if (e.status) {
  813.             return NGX_ERROR;
  814.         }

  816.         val_len = e.pos - val_tmp;

  818.         if (headers_end - b->last
  819.             < (ssize_t) (NGX_HTTP_V2_INT_OCTETS + val_len))
  820.         {
  821.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  822.                           "no buffer space in HTTP/2 create request");
  823.             return NGX_ERROR;
  824.         }

  826.         b->last = ngx_http_v2_write_value(b->last, val_tmp, val_len, tmp);

  828. #if (NGX_DEBUG)
  829.         if (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP) {
  830.             ngx_strlow(key_tmp, key_tmp, key_len);

  832.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  833.                            "http proxy header: \"%*s: %*s\"",
  834.                            key_len, key_tmp, val_len, val_tmp);
  835.         }
  836. #endif
  837.     }

  839.     if (plcf->upstream.pass_request_headers) {
  840.         part = &r->headers_in.headers.part;
  841.         header = part->elts;

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

  845.             if (i >= part->nelts) {
  846.                 if (part->next == NULL) {
  847.                     break;
  848.                 }

  850.                 part = part->next;
  851.                 header = part->elts;
  852.                 i = 0;
  853.             }

  855.             if (ngx_hash_find(&headers->hash, header[i].hash,
  856.                               header[i].lowcase_key, header[i].key.len))
  857.             {
  858.                 continue;
  859.             }

  861.             *b->last++ = 0;

  863.             b->last = ngx_http_v2_write_name(b->last, header[i].key.data,
  864.                                              header[i].key.len, tmp);

  866.             b->last = ngx_http_v2_write_value(b->last, header[i].value.data,
  867.                                               header[i].value.len, tmp);

  869. #if (NGX_DEBUG)
  870.             if (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP) {
  871.                 ngx_strlow(tmp, header[i].key.data, header[i].key.len);

  873.                 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  874.                                "http proxy header: \"%*s: %V\"",
  875.                                header[i].key.len, tmp, &header[i].value);
  876.             }
  877. #endif
  878.         }
  879.     }

  881.     /* update headers frame length */

  883.     len = b->last - headers_frame - sizeof(ngx_http_proxy_v2_frame_t);

  885.     if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  886.         len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  887.         next = 1;

  889.     } else {
  890.         next = 0;
  891.     }

  893.     f = (ngx_http_proxy_v2_frame_t *) headers_frame;

  895.     f->length_0 = (u_char) ((len >> 16) & 0xff);
  896.     f->length_1 = (u_char) ((len >> 8) & 0xff);
  897.     f->length_2 = (u_char) (len & 0xff);

  899.     /* create additional continuation frames */

  901.     p = headers_frame;

  903.     while (next) {
  904.         p += sizeof(ngx_http_proxy_v2_frame_t) + NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  905.         len = b->last - p;

  907.         ngx_memmove(p + sizeof(ngx_http_proxy_v2_frame_t), p, len);
  908.         b->last += sizeof(ngx_http_proxy_v2_frame_t);

  910.         if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  911.             len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  912.             next = 1;

  914.         } else {
  915.             next = 0;
  916.         }

  918.         f = (ngx_http_proxy_v2_frame_t *) p;

  920.         f->length_0 = (u_char) ((len >> 16) & 0xff);
  921.         f->length_1 = (u_char) ((len >> 8) & 0xff);
  922.         f->length_2 = (u_char) (len & 0xff);
  923.         f->type = NGX_HTTP_V2_CONTINUATION_FRAME;
  924.         f->flags = 0;
  925.         f->stream_id_0 = 0;
  926.         f->stream_id_1 = 0;
  927.         f->stream_id_2 = 0;
  928.         f->stream_id_3 = 1;
  929.     }

  931.     f->flags |= NGX_HTTP_V2_END_HEADERS_FLAG;

  933.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  934.                    "http proxy header: %*xs%s, len: %uz",
  935.                    (size_t) ngx_min(b->last - b->pos, 256), b->pos,
  936.                    b->last - b->pos > 256 ? "..." : "",
  937.                    b->last - b->pos);

  939.     if (r->request_body_no_buffering) {

  941.         u->request_bufs = cl;

  943.     } else if (plcf->body_values == NULL && plcf->upstream.pass_request_body) {

  945.         body = u->request_bufs;
  946.         u->request_bufs = cl;

  948.         if (body == NULL) {
  949.             f = (ngx_http_proxy_v2_frame_t *) headers_frame;
  950.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;
  951.         }

  953.         while (body) {
  954.             b = ngx_alloc_buf(r->pool);
  955.             if (b == NULL) {
  956.                 return NGX_ERROR;
  957.             }

  959.             ngx_memcpy(b, body->buf, sizeof(ngx_buf_t));

  961.             cl->next = ngx_alloc_chain_link(r->pool);
  962.             if (cl->next == NULL) {
  963.                 return NGX_ERROR;
  964.             }

  966.             cl = cl->next;
  967.             cl->buf = b;

  969.             body = body->next;
  970.         }

  972.         b->last_buf = 1;

  974.     } else if (body_len) {

  976.         u->request_bufs = cl;

  978.         b = ngx_create_temp_buf(r->pool, body_len);
  979.         if (b == NULL) {
  980.             return NGX_ERROR;
  981.         }

  983.         cl->next = ngx_alloc_chain_link(r->pool);
  984.         if (cl->next == NULL) {
  985.             return NGX_ERROR;
  986.         }

  988.         cl = cl->next;
  989.         cl->buf = b;

  991.         e.ip = plcf->body_values->elts;
  992.         e.pos = b->last;
  993.         e.end = b->last + body_len;
  994.         e.request = r;
  995.         e.flushed = 1;
  996.         e.skip = 0;

  998.         while (*(uintptr_t *) e.ip) {
  999.             code = *(ngx_http_script_code_pt *) e.ip;
  1000.             code((ngx_http_script_engine_t *) &e);
  1001.         }

  1003.         if (e.status) {
  1004.             return NGX_ERROR;
  1005.         }

  1007.         b->last = e.pos;
  1008.         b->last_buf = 1;

  1010.     } else {
  1011.         u->request_bufs = cl;

  1013.         f = (ngx_http_proxy_v2_frame_t *) headers_frame;
  1014.         f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1016.         b->last_buf = 1;
  1017.     }

  1019.     u->output.output_filter = ngx_http_proxy_v2_body_output_filter;
  1020.     u->output.filter_ctx = r;

  1022.     b->flush = 1;
  1023.     cl->next = NULL;

  1025.     return NGX_OK;
  1026. }


  1029. static ngx_int_t
  1030. ‌ngx_http_proxy_v2_reinit_request(ngx_http_request_t *r)
  1031. {
  1032.     ngx_http_proxy_v2_ctx_t  *ctx;

  1034.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1036.     if (ctx == NULL) {
  1037.         return NGX_OK;
  1038.     }

  1040.     ctx->state = 0;
  1041.     ctx->header_sent = 0;
  1042.     ctx->output_closed = 0;
  1043.     ctx->output_blocked = 0;
  1044.     ctx->parsing_headers = 0;
  1045.     ctx->end_stream = 0;
  1046.     ctx->done = 0;
  1047.     ctx->status = 0;
  1048.     ctx->rst = 0;
  1049.     ctx->goaway = 0;
  1050.     ctx->connection = NULL;
  1051.     ctx->in = NULL;
  1052.     ctx->busy = NULL;
  1053.     ctx->out = NULL;

  1055.     return NGX_OK;
  1056. }


  1059. static ngx_int_t
  1060. ‌ngx_http_proxy_v2_body_output_filter(void *data, ngx_chain_t *in)
  1061. {
  1062.     ngx_http_request_t  *r = data;

  1064.     off_t                       file_pos;
  1065.     u_char                     *p, *pos, *start;
  1066.     size_t                      len, limit;
  1067.     ngx_buf_t                  *b;
  1068.     ngx_int_t                  rc;
  1069.     ngx_uint_t                 next, last;
  1070.     ngx_chain_t                *cl, *out, *ln, **ll;
  1071.     ngx_http_upstream_t        *u;
  1072.     ngx_http_proxy_v2_ctx_t    *ctx;
  1073.     ngx_http_proxy_v2_frame_t  *f;

  1075.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1076.                    "http proxy output filter");

  1078.     ctx = ngx_http_proxy_v2_get_ctx(r);

  1080.     if (ctx == NULL) {
  1081.         return NGX_ERROR;
  1082.     }

  1084.     if (in) {
  1085.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  1086.             return NGX_ERROR;
  1087.         }
  1088.     }

  1090.     out = NULL;
  1091.     ll = &out;

  1093.     if (!ctx->header_sent) {
  1094.         /* first buffer contains headers */

  1096.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1097.                        "http proxy output header");

  1099.         ctx->header_sent = 1;

  1101.         if (ctx->id != 1) {
  1102.             /*
  1103.              * keepalive connection: skip connection preface,
  1104.              * update stream identifiers
  1105.              */

  1107.             b = ctx->in->buf;
  1108.             b->pos += sizeof(ngx_http_proxy_v2_connection_start) - 1;

  1110.             p = b->pos;

  1112.             while (p < b->last) {
  1113.                 f = (ngx_http_proxy_v2_frame_t *) p;
  1114.                 p += sizeof(ngx_http_proxy_v2_frame_t);

  1116.                 f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1117.                 f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1118.                 f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1119.                 f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1121.                 p += (f->length_0 << 16) + (f->length_1 << 8) + f->length_2;
  1122.             }
  1123.         }

  1125.         if (ctx->in->buf->last_buf) {
  1126.             ctx->output_closed = 1;
  1127.         }

  1129.         *ll = ctx->in;
  1130.         ll = &ctx->in->next;

  1132.         ctx->in = ctx->in->next;
  1133.     }

  1135.     if (ctx->out) {
  1136.         /* queued control frames */

  1138.         *ll = ctx->out;

  1140.         for (cl = ctx->out, ll = &cl->next; cl; cl = cl->next) {
  1141.             ll = &cl->next;
  1142.         }

  1144.         ctx->out = NULL;
  1145.     }

  1147.     f = NULL;
  1148.     last = 0;

  1150.     limit = ngx_max(0, ctx->send_window);

  1152.     if (limit > ctx->connection->send_window) {
  1153.         limit = ctx->connection->send_window;
  1154.     }

  1156.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1157.                    "http proxy output limit: %uz w:%z:%uz",
  1158.                    limit, ctx->send_window, ctx->connection->send_window);

  1160. #if (NGX_SUPPRESS_WARN)
  1161.     file_pos = 0;
  1162.     pos = NULL;
  1163.     cl = NULL;
  1164. #endif

  1166.     in = ctx->in;

  1168.     while (in && limit > 0) {

  1170.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1171.                        "http proxy output in  l:%d f:%d %p, pos %p, size: %z "
  1172.                        "file: %O, size: %O",
  1173.                        in->buf->last_buf,
  1174.                        in->buf->in_file,
  1175.                        in->buf->start, in->buf->pos,
  1176.                        in->buf->last - in->buf->pos,
  1177.                        in->buf->file_pos,
  1178.                        in->buf->file_last - in->buf->file_pos);

  1180.         if (ngx_buf_special(in->buf)) {
  1181.             goto next;
  1182.         }

  1184.         if (in->buf->in_file) {
  1185.             file_pos = in->buf->file_pos;

  1187.         } else {
  1188.             pos = in->buf->pos;
  1189.         }

  1191.         next = 0;

  1193.         do {

  1195.             cl = ngx_http_proxy_v2_get_buf(r, ctx);
  1196.             if (cl == NULL) {
  1197.                 return NGX_ERROR;
  1198.             }

  1200.             b = cl->buf;

  1202.             f = (ngx_http_proxy_v2_frame_t *) b->last;
  1203.             b->last += sizeof(ngx_http_proxy_v2_frame_t);

  1205.             *ll = cl;
  1206.             ll = &cl->next;

  1208.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  1209.             if (cl == NULL) {
  1210.                 return NGX_ERROR;
  1211.             }

  1213.             b = cl->buf;
  1214.             start = b->start;

  1216.             ngx_memcpy(b, in->buf, sizeof(ngx_buf_t));

  1218.             /*
  1219.              * restore b->start to preserve memory allocated in the buffer,
  1220.              * to reuse it later for headers and control frames
  1221.              */

  1223.             b->start = start;

  1225.             if (in->buf->in_file) {
  1226.                 b->file_pos = file_pos;
  1227.                 file_pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1229.                 if (file_pos >= in->buf->file_last) {
  1230.                     file_pos = in->buf->file_last;
  1231.                     next = 1;
  1232.                 }

  1234.                 b->file_last = file_pos;
  1235.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1237.             } else {
  1238.                 b->pos = pos;
  1239.                 pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1241.                 if (pos >= in->buf->last) {
  1242.                     pos = in->buf->last;
  1243.                     next = 1;
  1244.                 }

  1246.                 b->last = pos;
  1247.                 len = (ngx_uint_t) (pos - b->pos);
  1248.             }

  1250.             b->tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter;
  1251.             b->shadow = in->buf;
  1252.             b->last_shadow = next;

  1254.             b->last_buf = 0;
  1255.             b->last_in_chain = 0;

  1257.             *ll = cl;
  1258.             ll = &cl->next;

  1260.             f->length_0 = (u_char) ((len >> 16) & 0xff);
  1261.             f->length_1 = (u_char) ((len >> 8) & 0xff);
  1262.             f->length_2 = (u_char) (len & 0xff);
  1263.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1264.             f->flags = 0;
  1265.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1266.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1267.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1268.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1270.             limit -= len;
  1271.             ctx->send_window -= len;
  1272.             ctx->connection->send_window -= len;

  1274.         } while (!next && limit > 0);

  1276.         if (!next) {
  1277.             /*
  1278.              * if the buffer wasn't fully sent due to flow control limits,
  1279.              * preserve position for future use
  1280.              */

  1282.             if (in->buf->in_file) {
  1283.                 in->buf->file_pos = file_pos;

  1285.             } else {
  1286.                 in->buf->pos = pos;
  1287.             }

  1289.             break;
  1290.         }

  1292.     next:

  1294.         if (in->buf->last_buf) {
  1295.             last = 1;
  1296.         }

  1298.         ln = in;
  1299.         in = in->next;

  1301.         ngx_free_chain(r->pool, ln);
  1302.     }

  1304.     ctx->in = in;

  1306.     if (last) {

  1308.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1309.                        "http proxy output last");

  1311.         ctx->output_closed = 1;

  1313.         if (f) {
  1314.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1316.         } else {
  1317.             cl = ngx_http_proxy_v2_get_buf(r, ctx);
  1318.             if (cl == NULL) {
  1319.                 return NGX_ERROR;
  1320.             }

  1322.             b = cl->buf;

  1324.             f = (ngx_http_proxy_v2_frame_t *) b->last;
  1325.             b->last += sizeof(ngx_http_proxy_v2_frame_t);

  1327.             f->length_0 = 0;
  1328.             f->length_1 = 0;
  1329.             f->length_2 = 0;
  1330.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1331.             f->flags = NGX_HTTP_V2_END_STREAM_FLAG;
  1332.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1333.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1334.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1335.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1337.             *ll = cl;
  1338.             ll = &cl->next;
  1339.         }

  1341.         cl->buf->last_buf = 1;
  1342.     }

  1344.     *ll = NULL;

  1346. #if (NGX_DEBUG)

  1348.     for (cl = out; cl; cl = cl->next) {
  1349.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1350.                        "http proxy output out l:%d f:%d %p, pos %p, size: %z "
  1351.                        "file: %O, size: %O",
  1352.                        cl->buf->last_buf,
  1353.                        cl->buf->in_file,
  1354.                        cl->buf->start, cl->buf->pos,
  1355.                        cl->buf->last - cl->buf->pos,
  1356.                        cl->buf->file_pos,
  1357.                        cl->buf->file_last - cl->buf->file_pos);
  1358.     }

  1360.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1361.                    "http proxy output limit: %uz w:%z:%uz",
  1362.                    limit, ctx->send_window, ctx->connection->send_window);

  1364. #endif

  1366.     rc = ngx_chain_writer(&r->upstream->writer, out);

  1368.     ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &out,
  1369.                          (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter);

  1371.     for (cl = ctx->free; cl; cl = cl->next) {

  1373.         /* mark original buffers as sent */

  1375.         if (cl->buf->shadow) {
  1376.             if (cl->buf->last_shadow) {
  1377.                 b = cl->buf->shadow;
  1378.                 b->pos = b->last;
  1379.             }

  1381.             cl->buf->shadow = NULL;
  1382.         }
  1383.     }

  1385.     if (rc == NGX_OK && ctx->in) {
  1386.         rc = NGX_AGAIN;
  1387.     }

  1389.     if (rc == NGX_AGAIN) {
  1390.         ctx->output_blocked = 1;

  1392.     } else {
  1393.         ctx->output_blocked = 0;
  1394.     }

  1396.     if (ctx->done) {

  1398.         /*
  1399.          * We have already got the response and were sending some additional
  1400.          * control frames.  Even if there is still something unsent, stop
  1401.          * here anyway.
  1402.          */

  1404.         u = r->upstream;
  1405.         u->length = 0;
  1406.         u->pipe->length = 0;

  1408.         if (ctx->in == NULL
  1409.             && ctx->out == NULL
  1410.             && ctx->output_closed
  1411.             && !ctx->output_blocked
  1412.             && !ctx->goaway
  1413.             && ctx->state == ngx_http_proxy_v2_st_start)
  1414.         {
  1415.             u->keepalive = 1;
  1416.         }

  1418.         ngx_post_event(u->peer.connection->read, &ngx_posted_events);
  1419.     }

  1421.     return rc;
  1422. }


  1425. static ngx_int_t
  1426. ‌ngx_http_proxy_v2_process_header(ngx_http_request_t *r)
  1427. {
  1428.     u_char                         *pos;
  1429.     ngx_str_t                      *status_line;
  1430.     ngx_int_t                       rc, status;
  1431.     ngx_buf_t                      *b;
  1432.     ngx_table_elt_t                *h;
  1433.     ngx_http_upstream_t            *u;
  1434.     ngx_http_proxy_v2_ctx_t        *ctx;
  1435.     ngx_http_upstream_header_t     *hh;
  1436.     ngx_http_upstream_main_conf_t  *umcf;

  1438.     u = r->upstream;
  1439.     b = &u->buffer;
  1440.     pos = b->pos;

  1442.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1443.                    "http proxy response: %*xs%s, len: %uz",
  1444.                    (size_t) ngx_min(b->last - b->pos, 256),
  1445.                    b->pos, b->last - b->pos > 256 ? "..." : "",
  1446.                    b->last - b->pos);

  1448.     ctx = ngx_http_proxy_v2_get_ctx(r);

  1450.     if (ctx == NULL) {
  1451.         return NGX_ERROR;
  1452.     }

  1454.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1456.     for ( ;; ) {

  1458.         if (ctx->state < ngx_http_proxy_v2_st_payload) {

  1460.             rc = ngx_http_proxy_v2_parse_frame(r, ctx, b);

  1462.             if (rc == NGX_AGAIN) {

  1464.                 /*
  1465.                  * there can be a lot of window update frames,
  1466.                  * so we reset buffer if it is empty and we haven't
  1467.                  * started parsing headers yet
  1468.                  */

  1470.                 if (!ctx->parsing_headers) {
  1471.                     b->pos = pos;
  1472.                     b->last = b->pos;
  1473.                 }

  1475.                 return NGX_AGAIN;
  1476.             }

  1478.             if (rc == NGX_ERROR) {
  1479.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1480.             }

  1482.             /*
  1483.              * RFC 7540 says that implementations MUST discard frames
  1484.              * that have unknown or unsupported types.  However, extension
  1485.              * frames that appear in the middle of a header block are
  1486.              * not permitted.  Also, for obvious reasons CONTINUATION frames
  1487.              * cannot appear before headers, and DATA frames are not expected
  1488.              * to appear before all headers are parsed.
  1489.              */

  1491.             if (ctx->type == NGX_HTTP_V2_DATA_FRAME
  1492.                 || (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  1493.                     && !ctx->parsing_headers)
  1494.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  1495.                     && ctx->parsing_headers))
  1496.             {
  1497.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1498.                               "upstream sent unexpected http2 frame: %d",
  1499.                               ctx->type);
  1500.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1501.             }

  1503.             if (ctx->id && ctx->stream_id && ctx->stream_id != ctx->id) {
  1504.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1505.                               "upstream sent frame for unknown stream %ui",
  1506.                               ctx->stream_id);
  1507.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1508.             }
  1509.         }

  1511.         /* frame payload */

  1513.         if (!ngx_http_proxy_v2_cached(r)) {

  1515.             if (ctx->type == NGX_HTTP_V2_RST_STREAM_FRAME) {
  1516.                 rc = ngx_http_proxy_v2_parse_rst_stream(r, ctx, b);

  1518.                 if (rc == NGX_AGAIN) {
  1519.                     return NGX_AGAIN;
  1520.                 }

  1522.                 if (rc == NGX_ERROR) {
  1523.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1524.                 }

  1526.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1527.                               "upstream rejected request with error %ui",
  1528.                               ctx->error);

  1530.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1531.             }

  1533.             rc = ngx_http_proxy_v2_process_control_frame(r, ctx, b);

  1535.             if (rc == NGX_AGAIN) {
  1536.                 return NGX_AGAIN;
  1537.             }

  1539.             if (rc == NGX_ERROR) {
  1540.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1541.             }

  1543.             if (rc == NGX_OK) {
  1544.                 continue;
  1545.             }
  1546.         }

  1548.         if (ctx->type != NGX_HTTP_V2_HEADERS_FRAME
  1549.             && ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME)
  1550.         {
  1551.             /* priority, unknown frames */

  1553.             rc = ngx_http_proxy_v2_skip_frame(ctx, b);

  1555.             if (rc == NGX_AGAIN) {
  1556.                 return NGX_AGAIN;
  1557.             }

  1559.             continue;
  1560.         }

  1562.         /* headers */

  1564.         for ( ;; ) {

  1566.             rc = ngx_http_proxy_v2_parse_header(r, ctx, b);

  1568.             if (rc == NGX_AGAIN) {
  1569.                 break;
  1570.             }

  1572.             if (rc == NGX_OK) {

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

  1576.                 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1577.                                "http proxy header: \"%V: %V\"",
  1578.                                &ctx->name, &ctx->value);

  1580.                 if (ctx->name.len && ctx->name.data[0] == ':') {

  1582.                     if (ctx->name.len != sizeof(":status") - 1
  1583.                         || ngx_strncmp(ctx->name.data, ":status",
  1584.                                        sizeof(":status") - 1)
  1585.                            != 0)
  1586.                     {
  1587.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1588.                                       "upstream sent invalid header \"%V: %V\"",
  1589.                                       &ctx->name, &ctx->value);
  1590.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1591.                     }

  1593.                     if (ctx->status) {
  1594.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1595.                                       "upstream sent duplicate :status header");
  1596.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1597.                     }

  1599.                     status_line = &ctx->value;

  1601.                     if (status_line->len != 3) {
  1602.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1603.                                       "upstream sent invalid :status \"%V\"",
  1604.                                       status_line);
  1605.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1606.                     }

  1608.                     status = ngx_atoi(status_line->data, 3);

  1610.                     if (status == NGX_ERROR) {
  1611.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1612.                                       "upstream sent invalid :status \"%V\"",
  1613.                                       status_line);
  1614.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1615.                     }

  1617.                     if (status < NGX_HTTP_OK && status != NGX_HTTP_EARLY_HINTS)
  1618.                     {
  1619.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1620.                                       "upstream sent unexpected :status \"%V\"",
  1621.                                       status_line);
  1622.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1623.                     }

  1625.                     u->headers_in.status_n = status;

  1627.                     if (u->state && u->state->status == 0) {
  1628.                         u->state->status = status;
  1629.                     }

  1631.                     ctx->status = 1;

  1633.                     continue;

  1635.                 } else if (!ctx->status) {
  1636.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1637.                                   "upstream sent no :status header");
  1638.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1639.                 }

  1641.                 h = ngx_list_push(&u->headers_in.headers);
  1642.                 if (h == NULL) {
  1643.                     return NGX_ERROR;
  1644.                 }

  1646.                 h->key = ctx->name;
  1647.                 h->value = ctx->value;
  1648.                 h->lowcase_key = h->key.data;
  1649.                 h->hash = ngx_hash_key(h->key.data, h->key.len);

  1651.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1652.                     continue;
  1653.                 }

  1655.                 hh = ngx_hash_find(&umcf->headers_in_hash, h->hash,
  1656.                                    h->lowcase_key, h->key.len);

  1658.                 if (hh) {
  1659.                     rc = hh->handler(r, h, hh->offset);

  1661.                     if (rc != NGX_OK) {
  1662.                         return rc;
  1663.                     }
  1664.                 }

  1666.                 continue;
  1667.             }

  1669.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

  1673.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1674.                                "http proxy header done");

  1676.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1677.                     if (ctx->end_stream) {
  1678.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1679.                                       "upstream prematurely closed stream");
  1680.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1681.                     }

  1683.                     ctx->status = 0;
  1684.                     return NGX_HTTP_UPSTREAM_EARLY_HINTS;
  1685.                 }

  1687.                 if (ctx->end_stream
  1688.                     && ctx->in == NULL
  1689.                     && ctx->out == NULL
  1690.                     && ctx->output_closed
  1691.                     && !ctx->output_blocked
  1692.                     && !ctx->goaway
  1693.                     && b->last == b->pos)
  1694.                 {
  1695.                     u->keepalive = 1;
  1696.                 }

  1698.                 return NGX_OK;
  1699.             }

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

  1703.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1704.                           "upstream sent invalid header");

  1706.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1707.         }

  1709.         /* rc == NGX_AGAIN */

  1711.         if (ctx->rest == 0) {
  1712.             ctx->state = ngx_http_proxy_v2_st_start;
  1713.             continue;
  1714.         }

  1716.         return NGX_AGAIN;
  1717.     }
  1718. }


  1721. static ngx_int_t
  1722. ‌ngx_http_proxy_v2_filter_init(void *data)
  1723. {
  1724.     ngx_http_request_t       *r = data;
  1725.     ngx_http_upstream_t      *u;
  1726.     ngx_http_proxy_v2_ctx_t  *ctx;

  1728.     u = r->upstream;
  1729.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1731.     if (ctx == NULL) {
  1732.         return NGX_ERROR;
  1733.     }

  1735.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1736.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED
  1737.         || ctx->ctx.head)
  1738.     {
  1739.         ctx->length = 0;

  1741.     } else {
  1742.         ctx->length = u->headers_in.content_length_n;
  1743.     }

  1745.     if (ctx->end_stream) {

  1747.         if (ctx->length > 0) {
  1748.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1749.                           "upstream prematurely closed stream");
  1750.             return NGX_ERROR;
  1751.         }

  1753.         u->length = 0;
  1754.         u->pipe->length = 0;
  1755.         ctx->done = 1;

  1757.     } else {
  1758.         u->length = 1;
  1759.         u->pipe->length = 1;
  1760.     }

  1762.     return NGX_OK;
  1763. }


  1766. static ngx_int_t
  1767. ‌ngx_http_proxy_v2_non_buffered_filter(void *data, ssize_t bytes)
  1768. {
  1769.     ngx_http_request_t   *r = data;

  1771.     ngx_int_t                 rc;
  1772.     ngx_buf_t                *b, *buf;
  1773.     ngx_chain_t              *cl, **ll;
  1774.     ngx_http_upstream_t      *u;
  1775.     ngx_http_proxy_v2_ctx_t  *ctx;

  1777.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1778.                    "http proxy filter bytes:%z", bytes);

  1780.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1782.     if (ctx == NULL) {
  1783.         return NGX_ERROR;
  1784.     }

  1786.     u = r->upstream;
  1787.     b = &u->buffer;

  1789.     b->pos = b->last;
  1790.     b->last += bytes;

  1792.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  1793.         ll = &cl->next;
  1794.     }

  1796.     for ( ;; ) {

  1798.         rc = ngx_http_proxy_v2_process_frames(r, ctx, b);

  1800.         if (rc == NGX_OK) {

  1802.             cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  1803.             if (cl == NULL) {
  1804.                 return NGX_ERROR;
  1805.             }

  1807.             *ll = cl;
  1808.             ll = &cl->next;

  1810.             buf = cl->buf;

  1812.             buf->flush = 1;
  1813.             buf->memory = 1;

  1815.             buf->pos = b->pos;
  1816.             buf->tag = u->output.tag;

  1818.             if (b->last - b->pos >= (ssize_t) ctx->rest - ctx->padding) {
  1819.                 b->pos += ctx->rest - ctx->padding;
  1820.                 buf->last = b->pos;
  1821.                 ctx->rest = ctx->padding;

  1823.             } else {
  1824.                 ctx->rest -= b->last - b->pos;
  1825.                 b->pos = b->last;
  1826.                 buf->last = b->pos;
  1827.             }

  1829.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1830.                            "http proxy output buf %p", buf->pos);

  1832.             if (ctx->length != -1) {

  1834.                 if (buf->last - buf->pos > ctx->length) {
  1835.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1836.                                   "upstream sent response body larger "
  1837.                                   "than indicated content length");
  1838.                     return NGX_ERROR;
  1839.                 }

  1841.                 ctx->length -= buf->last - buf->pos;
  1842.             }

  1844.             continue;
  1845.         }

  1847.         if (rc == NGX_DONE) {
  1848.             u->length = 0;
  1849.             break;
  1850.         }

  1852.         if (rc == NGX_AGAIN) {
  1853.             return NGX_AGAIN;
  1854.         }

  1856.         /* invalid response */

  1858.         return NGX_ERROR;
  1859.     }

  1861.     return NGX_OK;
  1862. }


  1865. static ngx_int_t
  1866. ‌ngx_http_proxy_v2_body_filter(ngx_event_pipe_t *p, ngx_buf_t *b)
  1867. {
  1868.     ngx_int_t                 rc;
  1869.     ngx_buf_t                *buf, **prev;
  1870.     ngx_chain_t              *cl;
  1871.     ngx_http_request_t       *r;
  1872.     ngx_http_proxy_v2_ctx_t  *ctx;

  1874.     if (b->pos == b->last) {
  1875.         return NGX_OK;
  1876.     }

  1878.     r = p->input_ctx;
  1879.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1881.     if (ctx == NULL) {
  1882.         return NGX_ERROR;
  1883.     }

  1885.     buf = NULL;
  1886.     prev = &b->shadow;

  1888.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1889.                    "http proxy filter bytes:%z", b->last - b->pos);

  1891.     for ( ;; ) {

  1893.         rc = ngx_http_proxy_v2_process_frames(r, ctx, b);

  1895.         if (rc == NGX_OK) {

  1897.             /* copy data frame payload for buffering */

  1899.             cl = ngx_chain_get_free_buf(p->pool, &p->free);
  1900.             if (cl == NULL) {
  1901.                 return NGX_ERROR;
  1902.             }

  1904.             buf = cl->buf;

  1906.             ngx_memzero(buf, sizeof(ngx_buf_t));

  1908.             buf->pos = b->pos;
  1909.             buf->start = b->start;
  1910.             buf->end = b->end;
  1911.             buf->tag = p->tag;
  1912.             buf->temporary = 1;
  1913.             buf->recycled = 1;

  1915.             *prev = buf;
  1916.             prev = &buf->shadow;

  1918.             if (p->in) {
  1919.                 *p->last_in = cl;

  1921.             } else {
  1922.                 p->in = cl;
  1923.             }

  1925.             p->last_in = &cl->next;

  1927.             /* STUB */ buf->num = b->num;

  1929.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1930.                            "http proxy copy buf %p", buf->pos);

  1932.             if (b->last - b->pos >= (ssize_t) ctx->rest - ctx->padding) {
  1933.                 b->pos += ctx->rest - ctx->padding;
  1934.                 buf->last = b->pos;
  1935.                 ctx->rest = ctx->padding;

  1937.             } else {
  1938.                 ctx->rest -= b->last - b->pos;
  1939.                 b->pos = b->last;
  1940.                 buf->last = b->pos;
  1941.             }

  1943.             if (ctx->length != -1) {

  1945.                 if (buf->last - buf->pos > ctx->length) {
  1946.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1947.                                   "upstream sent response body larger "
  1948.                                   "than indicated content length");
  1949.                     return NGX_ERROR;
  1950.                 }

  1952.                 ctx->length -= buf->last - buf->pos;
  1953.             }

  1955.             continue;
  1956.         }

  1958.         if (rc == NGX_DONE) {
  1959.             p->length = 0;
  1960.             break;
  1961.         }

  1963.         if (rc == NGX_AGAIN) {
  1964.             break;
  1965.         }

  1967.         /* invalid response */

  1969.         return NGX_ERROR;
  1970.     }

  1972.     if (buf) {
  1973.         buf->shadow = b;
  1974.         buf->last_shadow = 1;

  1976.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, p->log, 0,
  1977.                        "input buf %p %z", buf->pos, buf->last - buf->pos);

  1979.         return NGX_OK;
  1980.     }

  1982.     /* there is no data record in the buf, add it to free chain */

  1984.     if (ngx_event_pipe_add_free_buf(p, b) != NGX_OK) {
  1985.         return NGX_ERROR;
  1986.     }

  1988.     return NGX_OK;
  1989. }


  1992. static ngx_int_t
  1993. ‌ngx_http_proxy_v2_process_control_frame(ngx_http_request_t *r,
  1994.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  1995. {
  1996.     ngx_int_t             rc;
  1997.     ngx_http_upstream_t  *u;

  1999.     u = r->upstream;

  2001.     if (ctx->type == NGX_HTTP_V2_GOAWAY_FRAME) {

  2003.         rc = ngx_http_proxy_v2_parse_goaway(r, ctx, b);

  2005.         if (rc == NGX_AGAIN) {
  2006.             return NGX_AGAIN;
  2007.         }

  2009.         if (rc == NGX_ERROR) {
  2010.             return NGX_ERROR;
  2011.         }

  2013.         /*
  2014.          * If stream_id is lower than one we use, our
  2015.          * request won't be processed and needs to be retried.
  2016.          * If stream_id is greater or equal to the one we use,
  2017.          * we can continue normally (except we can't use this
  2018.          * connection for additional requests).  If there is
  2019.          * a real error, the connection will be closed.
  2020.          */

  2022.         if (ctx->stream_id < ctx->id) {

  2024.             /* TODO: we can retry non-idempotent requests */

  2026.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2027.                           "upstream sent goaway with error %ui",
  2028.                           ctx->error);

  2030.             return NGX_ERROR;
  2031.         }

  2033.         ctx->goaway = 1;

  2035.         return NGX_OK;
  2036.     }

  2038.     if (ctx->type == NGX_HTTP_V2_WINDOW_UPDATE_FRAME) {

  2040.         rc = ngx_http_proxy_v2_parse_window_update(r, ctx, b);

  2042.         if (rc == NGX_AGAIN) {
  2043.             return NGX_AGAIN;
  2044.         }

  2046.         if (rc == NGX_ERROR) {
  2047.             return NGX_ERROR;
  2048.         }

  2050.         if (ctx->in) {
  2051.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2052.         }

  2054.         return NGX_OK;
  2055.     }

  2057.     if (ctx->type == NGX_HTTP_V2_SETTINGS_FRAME) {

  2059.         rc = ngx_http_proxy_v2_parse_settings(r, ctx, b);

  2061.         if (rc == NGX_AGAIN) {
  2062.             return NGX_AGAIN;
  2063.         }

  2065.         if (rc == NGX_ERROR) {
  2066.             return NGX_ERROR;
  2067.         }

  2069.         if (ctx->in) {
  2070.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2071.         }

  2073.         return NGX_OK;
  2074.     }

  2076.     if (ctx->type == NGX_HTTP_V2_PING_FRAME) {

  2078.         rc = ngx_http_proxy_v2_parse_ping(r, ctx, b);

  2080.         if (rc == NGX_AGAIN) {
  2081.             return NGX_AGAIN;
  2082.         }

  2084.         if (rc == NGX_ERROR) {
  2085.             return NGX_ERROR;
  2086.         }

  2088.         ngx_post_event(u->peer.connection->write, &ngx_posted_events);

  2090.         return NGX_OK;
  2091.     }

  2093.     if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  2094.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2095.                       "upstream sent unexpected push promise frame");
  2096.         return NGX_ERROR;
  2097.     }

  2099.     return NGX_DECLINED;
  2100. }


  2103. static ngx_int_t
  2104. ‌ngx_http_proxy_v2_skip_frame(ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2105. {
  2106.     if (b->last - b->pos < (ssize_t) ctx->rest) {
  2107.         ctx->rest -= b->last - b->pos;
  2108.         b->pos = b->last;
  2109.         return NGX_AGAIN;
  2110.     }

  2112.     b->pos += ctx->rest;
  2113.     ctx->rest = 0;
  2114.     ctx->state = ngx_http_proxy_v2_st_start;

  2116.     return NGX_OK;
  2117. }


  2120. static ngx_int_t
  2121. ‌ngx_http_proxy_v2_process_frames(ngx_http_request_t *r,
  2122.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2123. {
  2124.     ngx_int_t             rc;
  2125.     ngx_table_elt_t      *h;
  2126.     ngx_http_upstream_t  *u;

  2128.     u = r->upstream;

  2130.     for ( ;; ) {

  2132.         if (ctx->state < ngx_http_proxy_v2_st_payload) {

  2134.             rc = ngx_http_proxy_v2_parse_frame(r, ctx, b);

  2136.             if (rc == NGX_AGAIN) {

  2138.                 if (ctx->done) {

  2140.                     if (ctx->length > 0) {
  2141.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2142.                                       "upstream prematurely closed stream");
  2143.                         return NGX_ERROR;
  2144.                     }

  2146.                     /*
  2147.                      * We have finished parsing the response and the
  2148.                      * remaining control frames.  If there are unsent
  2149.                      * control frames, post a write event to send them.
  2150.                      */

  2152.                     if (ctx->out) {
  2153.                         ngx_post_event(u->peer.connection->write,
  2154.                                        &ngx_posted_events);
  2155.                         return NGX_AGAIN;
  2156.                     }

  2158.                     if (ctx->in == NULL
  2159.                         && ctx->output_closed
  2160.                         && !ctx->output_blocked
  2161.                         && !ctx->goaway
  2162.                         && ctx->state == ngx_http_proxy_v2_st_start)
  2163.                     {
  2164.                         u->keepalive = 1;
  2165.                     }

  2167.                     return NGX_DONE;
  2168.                 }

  2170.                 return NGX_AGAIN;
  2171.             }

  2173.             if (rc == NGX_ERROR) {
  2174.                 return NGX_ERROR;
  2175.             }

  2177.             if ((ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  2178.                  && !ctx->parsing_headers)
  2179.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  2180.                     && ctx->parsing_headers))
  2181.             {
  2182.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2183.                               "upstream sent unexpected http2 frame: %d",
  2184.                               ctx->type);
  2185.                 return NGX_ERROR;
  2186.             }

  2188.             if (ctx->type == NGX_HTTP_V2_DATA_FRAME) {

  2190.                 if (ctx->stream_id != ctx->id) {
  2191.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2192.                                   "upstream sent data frame "
  2193.                                   "for unknown stream %ui",
  2194.                                   ctx->stream_id);
  2195.                     return NGX_ERROR;
  2196.                 }

  2198.                 if (ctx->rest > ctx->recv_window) {
  2199.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2200.                                   "upstream violated stream flow control, "
  2201.                                   "received %uz data frame with window %uz",
  2202.                                   ctx->rest, ctx->recv_window);
  2203.                     return NGX_ERROR;
  2204.                 }

  2206.                 if (ctx->rest > ctx->connection->recv_window) {
  2207.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2208.                                   "upstream violated connection flow control, "
  2209.                                   "received %uz data frame with window %uz",
  2210.                                   ctx->rest, ctx->connection->recv_window);
  2211.                     return NGX_ERROR;
  2212.                 }

  2214.                 ctx->recv_window -= ctx->rest;
  2215.                 ctx->connection->recv_window -= ctx->rest;

  2217.                 if (ctx->connection->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4
  2218.                     || ctx->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4)
  2219.                 {
  2220.                     if (ngx_http_proxy_v2_send_window_update(r, ctx)
  2221.                         != NGX_OK)
  2222.                     {
  2223.                         return NGX_ERROR;
  2224.                     }

  2226.                     ngx_post_event(u->peer.connection->write,
  2227.                                    &ngx_posted_events);
  2228.                 }
  2229.             }

  2231.             if (ctx->stream_id && ctx->stream_id != ctx->id) {
  2232.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2233.                               "upstream sent frame for unknown stream %ui",
  2234.                               ctx->stream_id);
  2235.                 return NGX_ERROR;
  2236.             }

  2238.             if (ctx->stream_id && ctx->done
  2239.                 && ctx->type != NGX_HTTP_V2_RST_STREAM_FRAME
  2240.                 && ctx->type != NGX_HTTP_V2_WINDOW_UPDATE_FRAME)
  2241.             {
  2242.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2243.                               "upstream sent frame for closed stream %ui",
  2244.                               ctx->stream_id);
  2245.                 return NGX_ERROR;
  2246.             }

  2248.             ctx->padding = 0;
  2249.         }

  2251.         if (ctx->state == ngx_http_proxy_v2_st_padding) {

  2253.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2254.                 ctx->rest -= b->last - b->pos;
  2255.                 b->pos = b->last;
  2256.                 return NGX_AGAIN;
  2257.             }

  2259.             b->pos += ctx->rest;
  2260.             ctx->rest = 0;
  2261.             ctx->state = ngx_http_proxy_v2_st_start;

  2263.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2264.                 ctx->done = 1;
  2265.             }

  2267.             continue;
  2268.         }

  2270.         /* frame payload */

  2272.         if (ctx->type == NGX_HTTP_V2_RST_STREAM_FRAME) {

  2274.             rc = ngx_http_proxy_v2_parse_rst_stream(r, ctx, b);

  2276.             if (rc == NGX_AGAIN) {
  2277.                 return NGX_AGAIN;
  2278.             }

  2280.             if (rc == NGX_ERROR) {
  2281.                 return NGX_ERROR;
  2282.             }

  2284.             if (ctx->error || !ctx->done) {
  2285.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2286.                               "upstream rejected request with error %ui",
  2287.                               ctx->error);
  2288.                 return NGX_ERROR;
  2289.             }

  2291.             if (ctx->rst) {
  2292.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2293.                               "upstream sent frame for closed stream %ui",
  2294.                               ctx->stream_id);
  2295.                 return NGX_ERROR;
  2296.             }

  2298.             ctx->rst = 1;

  2300.             continue;
  2301.         }

  2303.         rc = ngx_http_proxy_v2_process_control_frame(r, ctx, b);

  2305.         if (rc == NGX_AGAIN) {
  2306.             return NGX_AGAIN;
  2307.         }

  2309.         if (rc == NGX_ERROR) {
  2310.             return NGX_ERROR;
  2311.         }

  2313.         if (rc == NGX_OK) {
  2314.             continue;
  2315.         }

  2317.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME
  2318.             || ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME)
  2319.         {
  2320.             for ( ;; ) {

  2322.                 rc = ngx_http_proxy_v2_parse_header(r, ctx, b);

  2324.                 if (rc == NGX_AGAIN) {
  2325.                     break;
  2326.                 }

  2328.                 if (rc == NGX_OK) {

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

  2332.                     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2333.                                    "http proxy trailer: \"%V: %V\"",
  2334.                                    &ctx->name, &ctx->value);

  2336.                     if (ctx->name.len && ctx->name.data[0] == ':') {
  2337.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2338.                                       "upstream sent invalid "
  2339.                                       "trailer \"%V: %V\"",
  2340.                                       &ctx->name, &ctx->value);
  2341.                         return NGX_ERROR;
  2342.                     }

  2344.                     h = ngx_list_push(&u->headers_in.trailers);
  2345.                     if (h == NULL) {
  2346.                         return NGX_ERROR;
  2347.                     }

  2349.                     h->key = ctx->name;
  2350.                     h->value = ctx->value;
  2351.                     h->lowcase_key = h->key.data;
  2352.                     h->hash = ngx_hash_key(h->key.data, h->key.len);

  2354.                     continue;
  2355.                 }

  2357.                 if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

  2361.                     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2362.                                    "http proxy trailer done");

  2364.                     if (ctx->end_stream) {
  2365.                         ctx->done = 1;
  2366.                         break;
  2367.                     }

  2369.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2370.                                   "upstream sent trailer without "
  2371.                                   "end stream flag");
  2372.                     return NGX_ERROR;
  2373.                 }

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

  2377.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2378.                               "upstream sent invalid trailer");

  2380.                 return NGX_ERROR;
  2381.             }

  2383.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2384.                 continue;
  2385.             }

  2387.             /* rc == NGX_AGAIN */

  2389.             if (ctx->rest == 0) {
  2390.                 ctx->state = ngx_http_proxy_v2_st_start;
  2391.                 continue;
  2392.             }

  2394.             return NGX_AGAIN;
  2395.         }

  2397.         if (ctx->type != NGX_HTTP_V2_DATA_FRAME) {

  2399.             /* priority, unknown frames */

  2401.             rc = ngx_http_proxy_v2_skip_frame(ctx, b);

  2403.             if (rc == NGX_AGAIN) {
  2404.                 return NGX_AGAIN;
  2405.             }

  2407.             continue;
  2408.         }

  2410.         /*
  2411.          * data frame:
  2412.          *
  2413.          * +---------------+
  2414.          * |Pad Length? (8)|
  2415.          * +---------------+-----------------------------------------------+
  2416.          * |                            Data (*)                         ...
  2417.          * +---------------------------------------------------------------+
  2418.          * |                           Padding (*)                       ...
  2419.          * +---------------------------------------------------------------+
  2420.          */

  2422.         if (ctx->flags & NGX_HTTP_V2_PADDED_FLAG) {

  2424.             if (ctx->rest == 0) {
  2425.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2426.                               "upstream sent too short http2 frame");
  2427.                 return NGX_ERROR;
  2428.             }

  2430.             if (b->pos == b->last) {
  2431.                 return NGX_AGAIN;
  2432.             }

  2434.             ctx->flags &= ~NGX_HTTP_V2_PADDED_FLAG;
  2435.             ctx->padding = *b->pos++;
  2436.             ctx->rest -= 1;

  2438.             if (ctx->padding > ctx->rest) {
  2439.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2440.                               "upstream sent http2 frame with too long "
  2441.                               "padding: %d in frame %uz",
  2442.                               ctx->padding, ctx->rest);
  2443.                 return NGX_ERROR;
  2444.             }

  2446.             continue;
  2447.         }

  2449.         if (ctx->padding == ctx->rest) {

  2451.             if (ctx->padding) {
  2452.                 ctx->state = ngx_http_proxy_v2_st_padding;

  2454.             } else {
  2455.                 ctx->state = ngx_http_proxy_v2_st_start;

  2457.                 if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2458.                     ctx->done = 1;
  2459.                 }
  2460.             }

  2462.             continue;
  2463.         }

  2465.         if (b->pos == b->last) {
  2466.             return NGX_AGAIN;
  2467.         }

  2469.         return NGX_OK;
  2470.     }
  2471. }


  2474. static ngx_int_t
  2475. ‌ngx_http_proxy_v2_parse_frame(ngx_http_request_t *r,
  2476.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2477. {
  2478.     u_char                     ch, *p;
  2479.     ngx_http_proxy_v2_state_e  state;

  2481.     state = ctx->state;

  2483.     for (p = b->pos; p < b->last; p++) {
  2484.         ch = *p;

  2486. #if 0
  2487.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2488.                        "http proxy frame byte: %02Xd, s:%d", ch, state);
  2489. #endif

  2491.         switch (state) {

  2493.         case ngx_http_proxy_v2_st_start:
  2494.             ctx->rest = ch << 16;
  2495.             state = ngx_http_proxy_v2_st_length_2;
  2496.             break;

  2498.         case ngx_http_proxy_v2_st_length_2:
  2499.             ctx->rest |= ch << 8;
  2500.             state = ngx_http_proxy_v2_st_length_3;
  2501.             break;

  2503.         case ngx_http_proxy_v2_st_length_3:
  2504.             ctx->rest |= ch;

  2506.             if (ctx->rest > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  2507.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2508.                               "upstream sent too large http2 frame: %uz",
  2509.                               ctx->rest);
  2510.                 return NGX_ERROR;
  2511.             }

  2513.             state = ngx_http_proxy_v2_st_type;
  2514.             break;

  2516.         case ngx_http_proxy_v2_st_type:
  2517.             ctx->type = ch;
  2518.             state = ngx_http_proxy_v2_st_flags;
  2519.             break;

  2521.         case ngx_http_proxy_v2_st_flags:
  2522.             ctx->flags = ch;
  2523.             state = ngx_http_proxy_v2_st_stream_id;
  2524.             break;

  2526.         case ngx_http_proxy_v2_st_stream_id:
  2527.             ctx->stream_id = (ch & 0x7f) << 24;
  2528.             state = ngx_http_proxy_v2_st_stream_id_2;
  2529.             break;

  2531.         case ngx_http_proxy_v2_st_stream_id_2:
  2532.             ctx->stream_id |= ch << 16;
  2533.             state = ngx_http_proxy_v2_st_stream_id_3;
  2534.             break;

  2536.         case ngx_http_proxy_v2_st_stream_id_3:
  2537.             ctx->stream_id |= ch << 8;
  2538.             state = ngx_http_proxy_v2_st_stream_id_4;
  2539.             break;

  2541.         case ngx_http_proxy_v2_st_stream_id_4:
  2542.             ctx->stream_id |= ch;

  2544.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2545.                            "http proxy frame: %d, len: %uz, f:%d, i:%ui",
  2546.                            ctx->type, ctx->rest, ctx->flags, ctx->stream_id);

  2548.             b->pos = p + 1;

  2550.             ctx->state = ngx_http_proxy_v2_st_payload;
  2551.             ctx->frame_state = 0;

  2553.             return NGX_OK;

  2555.         /* suppress warning */
  2556.         case ngx_http_proxy_v2_st_payload:
  2557.         case ngx_http_proxy_v2_st_padding:
  2558.             break;
  2559.         }
  2560.     }

  2562.     b->pos = p;
  2563.     ctx->state = state;

  2565.     return NGX_AGAIN;
  2566. }


  2569. static ngx_int_t
  2570. ‌ngx_http_proxy_v2_parse_header(ngx_http_request_t *r,
  2571.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2572. {
  2573.     u_char     ch, *p, *last;
  2574.     size_t     min;
  2575.     ngx_int_t  rc;
  2576. ‌    enum {
  2577.         sw_start = 0,
  2578.         sw_padding_length,
  2579.         sw_dependency,
  2580.         sw_dependency_2,
  2581.         sw_dependency_3,
  2582.         sw_dependency_4,
  2583.         sw_weight,
  2584.         sw_fragment,
  2585.         sw_padding
  2586.     } state;

  2588.     state = ctx->frame_state;

  2590.     if (state == sw_start) {

  2592.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2593.                        "http proxy parse header: start");

  2595.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME) {
  2596.             ctx->parsing_headers = 1;
  2597.             ctx->fragment_state = 0;
  2598.             ctx->header_limit = r->upstream->conf->buffer_size;

  2600.             min = (ctx->flags & NGX_HTTP_V2_PADDED_FLAG ? 1 : 0)
  2601.                   + (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG ? 5 : 0);

  2603.             if (ctx->rest < min) {
  2604.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2605.                               "upstream sent headers frame "
  2606.                               "with invalid length: %uz",
  2607.                               ctx->rest);
  2608.                 return NGX_ERROR;
  2609.             }

  2611.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2612.                 ctx->end_stream = 1;
  2613.             }

  2615.             if (ctx->flags & NGX_HTTP_V2_PADDED_FLAG) {
  2616.                 state = sw_padding_length;

  2618.             } else if (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG) {
  2619.                 state = sw_dependency;

  2621.             } else {
  2622.                 state = sw_fragment;
  2623.             }

  2625.         } else if (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME) {
  2626.             state = sw_fragment;
  2627.         }

  2629.         ctx->padding = 0;
  2630.         ctx->frame_state = state;
  2631.     }

  2633.     if (state < sw_fragment) {

  2635.         if (b->last - b->pos < (ssize_t) ctx->rest) {
  2636.             last = b->last;

  2638.         } else {
  2639.             last = b->pos + ctx->rest;
  2640.         }

  2642.         for (p = b->pos; p < last; p++) {
  2643.             ch = *p;

  2645. #if 0
  2646.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2647.                            "http proxy header byte: %02Xd s:%d", ch, state);
  2648. #endif

  2650.             /*
  2651.              * headers frame:
  2652.              *
  2653.              * +---------------+
  2654.              * |Pad Length? (8)|
  2655.              * +-+-------------+----------------------------------------------+
  2656.              * |E|                 Stream Dependency? (31)                    |
  2657.              * +-+-------------+----------------------------------------------+
  2658.              * |  Weight? (8)  |
  2659.              * +-+-------------+----------------------------------------------+
  2660.              * |                   Header Block Fragment (*)                ...
  2661.              * +--------------------------------------------------------------+
  2662.              * |                           Padding (*)                      ...
  2663.              * +--------------------------------------------------------------+
  2664.              */

  2666.             switch (state) {

  2668.             case sw_padding_length:

  2670.                 ctx->padding = ch;

  2672.                 if (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG) {
  2673.                     state = sw_dependency;
  2674.                     break;
  2675.                 }

  2677.                 goto fragment;

  2679.             case sw_dependency:
  2680.                 state = sw_dependency_2;
  2681.                 break;

  2683.             case sw_dependency_2:
  2684.                 state = sw_dependency_3;
  2685.                 break;

  2687.             case sw_dependency_3:
  2688.                 state = sw_dependency_4;
  2689.                 break;

  2691.             case sw_dependency_4:
  2692.                 state = sw_weight;
  2693.                 break;

  2695.             case sw_weight:
  2696.                 goto fragment;

  2698.             /* suppress warning */
  2699.             case sw_start:
  2700.             case sw_fragment:
  2701.             case sw_padding:
  2702.                 break;
  2703.             }
  2704.         }

  2706.         ctx->rest -= p - b->pos;
  2707.         b->pos = p;

  2709.         ctx->frame_state = state;
  2710.         return NGX_AGAIN;

  2712.     fragment:

  2714.         p++;
  2715.         ctx->rest -= p - b->pos;
  2716.         b->pos = p;

  2718.         if (ctx->padding > ctx->rest) {
  2719.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2720.                           "upstream sent http2 frame with too long "
  2721.                           "padding: %d in frame %uz",
  2722.                           ctx->padding, ctx->rest);
  2723.             return NGX_ERROR;
  2724.         }

  2726.         state = sw_fragment;
  2727.         ctx->frame_state = state;
  2728.     }

  2730.     if (state == sw_fragment) {

  2732.         rc = ngx_http_proxy_v2_parse_fragment(r, ctx, b);

  2734.         if (rc == NGX_AGAIN) {
  2735.             return NGX_AGAIN;
  2736.         }

  2738.         if (rc == NGX_ERROR) {
  2739.             return NGX_ERROR;
  2740.         }

  2742.         if (rc == NGX_OK) {
  2743.             return NGX_OK;
  2744.         }

  2746.         /* rc == NGX_DONE */

  2748.         state = sw_padding;
  2749.         ctx->frame_state = state;
  2750.     }

  2752.     if (state == sw_padding) {

  2754.         if (b->last - b->pos < (ssize_t) ctx->rest) {

  2756.             ctx->rest -= b->last - b->pos;
  2757.             b->pos = b->last;

  2759.             return NGX_AGAIN;
  2760.         }

  2762.         b->pos += ctx->rest;
  2763.         ctx->rest = 0;

  2765.         ctx->state = ngx_http_proxy_v2_st_start;

  2767.         if (ctx->flags & NGX_HTTP_V2_END_HEADERS_FLAG) {

  2769.             if (ctx->fragment_state) {
  2770.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2771.                               "upstream sent truncated http2 header");
  2772.                 return NGX_ERROR;
  2773.             }

  2775.             ctx->parsing_headers = 0;

  2777.             return NGX_HTTP_PARSE_HEADER_DONE;
  2778.         }

  2780.         return NGX_AGAIN;
  2781.     }

  2783.     /* unreachable */

  2785.     return NGX_ERROR;
  2786. }


  2789. static ngx_int_t
  2790. ‌ngx_http_proxy_v2_parse_fragment(ngx_http_request_t *r,
  2791.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2792. {
  2793.     u_char      ch, *p, *last;
  2794.     size_t      len, size;
  2795.     ngx_uint_t  index, size_update;
  2796. ‌    enum {
  2797.         sw_start = 0,
  2798.         sw_index,
  2799.         sw_name_length,
  2800.         sw_name_length_2,
  2801.         sw_name_length_3,
  2802.         sw_name_length_4,
  2803.         sw_name,
  2804.         sw_name_bytes,
  2805.         sw_value_length,
  2806.         sw_value_length_2,
  2807.         sw_value_length_3,
  2808.         sw_value_length_4,
  2809.         sw_value,
  2810.         sw_value_bytes
  2811.     } state;

  2813.     /* header block fragment */

  2815. #if 0
  2816.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2817.                    "http proxy header fragment %p:%p rest:%uz",
  2818.                    b->pos, b->last, ctx->rest);
  2819. #endif

  2821.     if (b->last - b->pos < (ssize_t) ctx->rest - ctx->padding) {
  2822.         last = b->last;

  2824.     } else {
  2825.         last = b->pos + ctx->rest - ctx->padding;
  2826.     }

  2828.     state = ctx->fragment_state;

  2830.     for (p = b->pos; p < last; p++) {
  2831.         ch = *p;

  2833. #if 0
  2834.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2835.                        "http proxy header byte: %02Xd s:%d", ch, state);
  2836. #endif

  2838.         switch (state) {

  2840.         case sw_start:
  2841.             ctx->index = 0;

  2843.             if ((ch & 0x80) == 0x80) {
  2844.                 /*
  2845.                  * indexed header:
  2846.                  *
  2847.                  *   0   1   2   3   4   5   6   7
  2848.                  * +---+---+---+---+---+---+---+---+
  2849.                  * | 1 |        Index (7+)         |
  2850.                  * +---+---------------------------+
  2851.                  */

  2853.                 index = ch & ~0x80;

  2855.                 if (index == 0 || index > 61) {
  2856.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2857.                                   "upstream sent invalid http2 "
  2858.                                   "table index: %ui", index);
  2859.                     return NGX_ERROR;
  2860.                 }

  2862.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2863.                                "http proxy indexed header: %ui", index);

  2865.                 ctx->index = index;
  2866.                 ctx->literal = 0;

  2868.                 goto done;

  2870.             } else if ((ch & 0xc0) == 0x40) {
  2871.                 /*
  2872.                  * literal header with incremental indexing:
  2873.                  *
  2874.                  *   0   1   2   3   4   5   6   7
  2875.                  * +---+---+---+---+---+---+---+---+
  2876.                  * | 0 | 1 |      Index (6+)       |
  2877.                  * +---+---+-----------------------+
  2878.                  * | H |     Value Length (7+)     |
  2879.                  * +---+---------------------------+
  2880.                  * | Value String (Length octets)  |
  2881.                  * +-------------------------------+
  2882.                  *
  2883.                  *   0   1   2   3   4   5   6   7
  2884.                  * +---+---+---+---+---+---+---+---+
  2885.                  * | 0 | 1 |           0           |
  2886.                  * +---+---+-----------------------+
  2887.                  * | H |     Name Length (7+)      |
  2888.                  * +---+---------------------------+
  2889.                  * |  Name String (Length octets)  |
  2890.                  * +---+---------------------------+
  2891.                  * | H |     Value Length (7+)     |
  2892.                  * +---+---------------------------+
  2893.                  * | Value String (Length octets)  |
  2894.                  * +-------------------------------+
  2895.                  */

  2897.                 index = ch & ~0xc0;

  2899.                 if (index > 61) {
  2900.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2901.                                   "upstream sent invalid http2 "
  2902.                                   "table index: %ui", index);
  2903.                     return NGX_ERROR;
  2904.                 }

  2906.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2907.                                "http proxy literal header: %ui", index);

  2909.                 if (index == 0) {
  2910.                     state = sw_name_length;
  2911.                     break;
  2912.                 }

  2914.                 ctx->index = index;
  2915.                 ctx->literal = 1;

  2917.                 state = sw_value_length;
  2918.                 break;

  2920.             } else if ((ch & 0xe0) == 0x20) {
  2921.                 /*
  2922.                  * dynamic table size update:
  2923.                  *
  2924.                  *   0   1   2   3   4   5   6   7
  2925.                  * +---+---+---+---+---+---+---+---+
  2926.                  * | 0 | 0 | 1 |   Max size (5+)   |
  2927.                  * +---+---------------------------+
  2928.                  */

  2930.                 size_update = ch & ~0xe0;

  2932.                 if (size_update > 0) {
  2933.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2934.                                   "upstream sent invalid http2 "
  2935.                                   "dynamic table size update: %ui",
  2936.                                   size_update);
  2937.                     return NGX_ERROR;
  2938.                 }

  2940.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2941.                                "http proxy table size update: %ui",
  2942.                                size_update);

  2944.                 break;

  2946.             } else if ((ch & 0xf0) == 0x10) {
  2947.                 /*
  2948.                  *  literal header field never indexed:
  2949.                  *
  2950.                  *   0   1   2   3   4   5   6   7
  2951.                  * +---+---+---+---+---+---+---+---+
  2952.                  * | 0 | 0 | 0 | 1 |  Index (4+)   |
  2953.                  * +---+---+-----------------------+
  2954.                  * | H |     Value Length (7+)     |
  2955.                  * +---+---------------------------+
  2956.                  * | Value String (Length octets)  |
  2957.                  * +-------------------------------+
  2958.                  *
  2959.                  *   0   1   2   3   4   5   6   7
  2960.                  * +---+---+---+---+---+---+---+---+
  2961.                  * | 0 | 0 | 0 | 1 |       0       |
  2962.                  * +---+---+-----------------------+
  2963.                  * | H |     Name Length (7+)      |
  2964.                  * +---+---------------------------+
  2965.                  * |  Name String (Length octets)  |
  2966.                  * +---+---------------------------+
  2967.                  * | H |     Value Length (7+)     |
  2968.                  * +---+---------------------------+
  2969.                  * | Value String (Length octets)  |
  2970.                  * +-------------------------------+
  2971.                  */

  2973.                 index = ch & ~0xf0;

  2975.                 if (index == 0x0f) {
  2976.                     ctx->index = index;
  2977.                     ctx->literal = 1;
  2978.                     state = sw_index;
  2979.                     break;
  2980.                 }

  2982.                 if (index == 0) {
  2983.                     state = sw_name_length;
  2984.                     break;
  2985.                 }

  2987.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2988.                                "http proxy literal header never indexed: %ui",
  2989.                                index);

  2991.                 ctx->index = index;
  2992.                 ctx->literal = 1;

  2994.                 state = sw_value_length;
  2995.                 break;

  2997.             } else if ((ch & 0xf0) == 0x00) {
  2998.                 /*
  2999.                  * literal header field without indexing:
  3000.                  *
  3001.                  *   0   1   2   3   4   5   6   7
  3002.                  * +---+---+---+---+---+---+---+---+
  3003.                  * | 0 | 0 | 0 | 0 |  Index (4+)   |
  3004.                  * +---+---+-----------------------+
  3005.                  * | H |     Value Length (7+)     |
  3006.                  * +---+---------------------------+
  3007.                  * | Value String (Length octets)  |
  3008.                  * +-------------------------------+
  3009.                  *
  3010.                  *   0   1   2   3   4   5   6   7
  3011.                  * +---+---+---+---+---+---+---+---+
  3012.                  * | 0 | 0 | 0 | 0 |       0       |
  3013.                  * +---+---+-----------------------+
  3014.                  * | H |     Name Length (7+)      |
  3015.                  * +---+---------------------------+
  3016.                  * |  Name String (Length octets)  |
  3017.                  * +---+---------------------------+
  3018.                  * | H |     Value Length (7+)     |
  3019.                  * +---+---------------------------+
  3020.                  * | Value String (Length octets)  |
  3021.                  * +-------------------------------+
  3022.                  */

  3024.                 index = ch & ~0xf0;

  3026.                 if (index == 0x0f) {
  3027.                     ctx->index = index;
  3028.                     ctx->literal = 1;
  3029.                     state = sw_index;
  3030.                     break;
  3031.                 }

  3033.                 if (index == 0) {
  3034.                     state = sw_name_length;
  3035.                     break;
  3036.                 }

  3038.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3039.                              "http proxy literal header without indexing: %ui",
  3040.                                index);

  3042.                 ctx->index = index;
  3043.                 ctx->literal = 1;

  3045.                 state = sw_value_length;
  3046.                 break;
  3047.             }

  3049.             /* not reached */

  3051.             return NGX_ERROR;

  3053.         case sw_index:
  3054.             ctx->index = ctx->index + (ch & ~0x80);

  3056.             if (ch & 0x80) {
  3057.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3058.                               "upstream sent http2 table index "
  3059.                               "with continuation flag");
  3060.                 return NGX_ERROR;
  3061.             }

  3063.             if (ctx->index > 61) {
  3064.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3065.                               "upstream sent invalid http2 "
  3066.                               "table index: %ui", ctx->index);
  3067.                 return NGX_ERROR;
  3068.             }

  3070.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3071.                            "http proxy header index: %ui", ctx->index);

  3073.             state = sw_value_length;
  3074.             break;

  3076.         case sw_name_length:
  3077.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3078.             ctx->field_length = ch & ~0x80;

  3080.             if (ctx->field_length == 0x7f) {
  3081.                 state = sw_name_length_2;
  3082.                 break;
  3083.             }

  3085.             if (ctx->field_length == 0) {
  3086.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3087.                               "upstream sent zero http2 "
  3088.                               "header name length");
  3089.                 return NGX_ERROR;
  3090.             }

  3092.             state = sw_name;
  3093.             break;

  3095.         case sw_name_length_2:
  3096.             ctx->field_length += ch & ~0x80;

  3098.             if (ch & 0x80) {
  3099.                 state = sw_name_length_3;
  3100.                 break;
  3101.             }

  3103.             state = sw_name;
  3104.             break;

  3106.         case sw_name_length_3:
  3107.             ctx->field_length += (ch & ~0x80) << 7;

  3109.             if (ch & 0x80) {
  3110.                 state = sw_name_length_4;
  3111.                 break;
  3112.             }

  3114.             state = sw_name;
  3115.             break;

  3117.         case sw_name_length_4:
  3118.             ctx->field_length += (ch & ~0x80) << 14;

  3120.             if (ch & 0x80) {
  3121.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3122.                               "upstream sent too large http2 "
  3123.                               "header name length");
  3124.                 return NGX_ERROR;
  3125.             }

  3127.             state = sw_name;
  3128.             break;

  3130.         case sw_name:
  3131.             ctx->name.len = ctx->field_huffman ?
  3132.                             ctx->field_length * 8 / 5 : ctx->field_length;

  3134.             if (ctx->name.len > ctx->header_limit) {
  3135.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3136.                               "upstream sent too large http2 "
  3137.                               "header name length: %uz",
  3138.                               ctx->name.len);
  3139.                 return NGX_ERROR;
  3140.             }

  3142.             ctx->name.data = ngx_pnalloc(r->pool, ctx->name.len + 1);
  3143.             if (ctx->name.data == NULL) {
  3144.                 return NGX_ERROR;
  3145.             }

  3147.             ctx->field_end = ctx->name.data;
  3148.             ctx->field_rest = ctx->field_length;
  3149.             ctx->field_state = 0;

  3151.             state = sw_name_bytes;

  3153.             /* fall through */

  3155.         case sw_name_bytes:

  3157.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3158.                            "http proxy name: len:%uz h:%d last:%uz, rest:%uz",
  3159.                            ctx->field_length,
  3160.                            ctx->field_huffman,
  3161.                            last - p,
  3162.                            ctx->rest - (p - b->pos));

  3164.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3165.             ctx->field_rest -= size;

  3167.             if (ctx->field_huffman) {
  3168.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3169.                                          &ctx->field_end,
  3170.                                          ctx->field_rest == 0,
  3171.                                          r->connection->log)
  3172.                     != NGX_OK)
  3173.                 {
  3174.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3175.                                   "upstream sent invalid encoded header");
  3176.                     return NGX_ERROR;
  3177.                 }

  3179.                 ctx->name.len = ctx->field_end - ctx->name.data;
  3180.                 ctx->name.data[ctx->name.len] = '\0';

  3182.             } else {
  3183.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3184.                 ctx->name.data[ctx->name.len] = '\0';
  3185.             }

  3187.             p += size - 1;

  3189.             if (ctx->field_rest == 0) {
  3190.                 state = sw_value_length;
  3191.             }

  3193.             break;

  3195.         case sw_value_length:
  3196.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3197.             ctx->field_length = ch & ~0x80;

  3199.             if (ctx->field_length == 0x7f) {
  3200.                 state = sw_value_length_2;
  3201.                 break;
  3202.             }

  3204.             if (ctx->field_length == 0) {
  3205.                 ngx_str_set(&ctx->value, "");
  3206.                 goto done;
  3207.             }

  3209.             state = sw_value;
  3210.             break;

  3212.         case sw_value_length_2:
  3213.             ctx->field_length += ch & ~0x80;

  3215.             if (ch & 0x80) {
  3216.                 state = sw_value_length_3;
  3217.                 break;
  3218.             }

  3220.             state = sw_value;
  3221.             break;

  3223.         case sw_value_length_3:
  3224.             ctx->field_length += (ch & ~0x80) << 7;

  3226.             if (ch & 0x80) {
  3227.                 state = sw_value_length_4;
  3228.                 break;
  3229.             }

  3231.             state = sw_value;
  3232.             break;

  3234.         case sw_value_length_4:
  3235.             ctx->field_length += (ch & ~0x80) << 14;

  3237.             if (ch & 0x80) {
  3238.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3239.                               "upstream sent too large http2 "
  3240.                               "header value length");
  3241.                 return NGX_ERROR;
  3242.             }

  3244.             state = sw_value;
  3245.             break;

  3247.         case sw_value:
  3248.             ctx->value.len = ctx->field_huffman ?
  3249.                              ctx->field_length * 8 / 5 : ctx->field_length;

  3251.             if (ctx->value.len > ctx->header_limit) {
  3252.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3253.                               "upstream sent too large http2 "
  3254.                               "header value length: %uz",
  3255.                               ctx->value.len);
  3256.                 return NGX_ERROR;
  3257.             }

  3259.             ctx->value.data = ngx_pnalloc(r->pool, ctx->value.len + 1);
  3260.             if (ctx->value.data == NULL) {
  3261.                 return NGX_ERROR;
  3262.             }

  3264.             ctx->field_end = ctx->value.data;
  3265.             ctx->field_rest = ctx->field_length;
  3266.             ctx->field_state = 0;

  3268.             state = sw_value_bytes;

  3270.             /* fall through */

  3272.         case sw_value_bytes:

  3274.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3275.                            "http proxy value: len:%uz h:%d last:%uz, rest:%uz",
  3276.                            ctx->field_length,
  3277.                            ctx->field_huffman,
  3278.                            last - p,
  3279.                            ctx->rest - (p - b->pos));

  3281.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3282.             ctx->field_rest -= size;

  3284.             if (ctx->field_huffman) {
  3285.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3286.                                          &ctx->field_end,
  3287.                                          ctx->field_rest == 0,
  3288.                                          r->connection->log)
  3289.                     != NGX_OK)
  3290.                 {
  3291.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3292.                                   "upstream sent invalid encoded header");
  3293.                     return NGX_ERROR;
  3294.                 }

  3296.                 ctx->value.len = ctx->field_end - ctx->value.data;
  3297.                 ctx->value.data[ctx->value.len] = '\0';

  3299.             } else {
  3300.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3301.                 ctx->value.data[ctx->value.len] = '\0';
  3302.             }

  3304.             p += size - 1;

  3306.             if (ctx->field_rest == 0) {
  3307.                 goto done;
  3308.             }

  3310.             break;
  3311.         }

  3313.         continue;

  3315.     done:

  3317.         p++;
  3318.         ctx->rest -= p - b->pos;
  3319.         ctx->fragment_state = sw_start;
  3320.         b->pos = p;

  3322.         if (ctx->index) {
  3323.             ctx->name = *ngx_http_v2_get_static_name(ctx->index);
  3324.         }

  3326.         if (ctx->index && !ctx->literal) {
  3327.             ctx->value = *ngx_http_v2_get_static_value(ctx->index);
  3328.         }

  3330.         if (!ctx->index) {
  3331.             if (ngx_http_proxy_v2_validate_header_name(r, &ctx->name)
  3332.                 != NGX_OK)
  3333.             {
  3334.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3335.                               "upstream sent invalid header: \"%V: %V\"",
  3336.                               &ctx->name, &ctx->value);
  3337.                 return NGX_ERROR;
  3338.             }
  3339.         }

  3341.         if (!ctx->index || ctx->literal) {
  3342.             if (ngx_http_proxy_v2_validate_header_value(r, &ctx->value)
  3343.                 != NGX_OK)
  3344.             {
  3345.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3346.                               "upstream sent invalid header: \"%V: %V\"",
  3347.                               &ctx->name, &ctx->value);
  3348.                 return NGX_ERROR;
  3349.             }
  3350.         }

  3352.         len = ctx->name.len + ctx->value.len;

  3354.         if (len > ctx->header_limit) {
  3355.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3356.                           "upstream sent too large http2 header");
  3357.             return NGX_ERROR;
  3358.         }

  3360.         ctx->header_limit -= len;

  3362.         return NGX_OK;
  3363.     }

  3365.     ctx->rest -= p - b->pos;
  3366.     ctx->fragment_state = state;
  3367.     b->pos = p;

  3369.     if (ctx->rest > ctx->padding) {
  3370.         return NGX_AGAIN;
  3371.     }

  3373.     return NGX_DONE;
  3374. }


  3377. static ngx_int_t
  3378. ‌ngx_http_proxy_v2_validate_header_name(ngx_http_request_t *r, ngx_str_t *s)
  3379. {
  3380.     u_char      ch;
  3381.     ngx_uint_t  i;

  3383.     for (i = 0; i < s->len; i++) {
  3384.         ch = s->data[i];

  3386.         if (ch == ':' && i > 0) {
  3387.             return NGX_ERROR;
  3388.         }

  3390.         if (ch >= 'A' && ch <= 'Z') {
  3391.             return NGX_ERROR;
  3392.         }

  3394.         if (ch <= 0x20 || ch == 0x7f) {
  3395.             return NGX_ERROR;
  3396.         }
  3397.     }

  3399.     return NGX_OK;
  3400. }


  3403. static ngx_int_t
  3404. ‌ngx_http_proxy_v2_validate_header_value(ngx_http_request_t *r, ngx_str_t *s)
  3405. {
  3406.     u_char      ch;
  3407.     ngx_uint_t  i;

  3409.     for (i = 0; i < s->len; i++) {
  3410.         ch = s->data[i];

  3412.         if (ch == '\0' || ch == CR || ch == LF) {
  3413.             return NGX_ERROR;
  3414.         }
  3415.     }

  3417.     return NGX_OK;
  3418. }


  3421. static ngx_int_t
  3422. ‌ngx_http_proxy_v2_parse_rst_stream(ngx_http_request_t *r,
  3423.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3424. {
  3425.     u_char  ch, *p, *last;
  3426. ‌    enum {
  3427.         sw_start = 0,
  3428.         sw_error_2,
  3429.         sw_error_3,
  3430.         sw_error_4
  3431.     } state;

  3433.     if (b->last - b->pos < (ssize_t) ctx->rest) {
  3434.         last = b->last;

  3436.     } else {
  3437.         last = b->pos + ctx->rest;
  3438.     }

  3440.     state = ctx->frame_state;

  3442.     if (state == sw_start) {
  3443.         if (ctx->rest != 4) {
  3444.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3445.                           "upstream sent rst stream frame "
  3446.                           "with invalid length: %uz",
  3447.                           ctx->rest);
  3448.             return NGX_ERROR;
  3449.         }
  3450.     }

  3452.     for (p = b->pos; p < last; p++) {
  3453.         ch = *p;

  3455. #if 0
  3456.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3457.                        "http proxy rst byte: %02Xd s:%d", ch, state);
  3458. #endif

  3460.         switch (state) {

  3462.         case sw_start:
  3463.             ctx->error = (ngx_uint_t) ch << 24;
  3464.             state = sw_error_2;
  3465.             break;

  3467.         case sw_error_2:
  3468.             ctx->error |= ch << 16;
  3469.             state = sw_error_3;
  3470.             break;

  3472.         case sw_error_3:
  3473.             ctx->error |= ch << 8;
  3474.             state = sw_error_4;
  3475.             break;

  3477.         case sw_error_4:
  3478.             ctx->error |= ch;
  3479.             state = sw_start;

  3481.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3482.                            "http proxy error: %ui", ctx->error);

  3484.             break;
  3485.         }
  3486.     }

  3488.     ctx->rest -= p - b->pos;
  3489.     ctx->frame_state = state;
  3490.     b->pos = p;

  3492.     if (ctx->rest > 0) {
  3493.         return NGX_AGAIN;
  3494.     }

  3496.     ctx->state = ngx_http_proxy_v2_st_start;

  3498.     return NGX_OK;
  3499. }


  3502. static ngx_int_t
  3503. ‌ngx_http_proxy_v2_parse_goaway(ngx_http_request_t *r,
  3504.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3505. {
  3506.     u_char  ch, *p, *last;
  3507. ‌    enum {
  3508.         sw_start = 0,
  3509.         sw_last_stream_id_2,
  3510.         sw_last_stream_id_3,
  3511.         sw_last_stream_id_4,
  3512.         sw_error,
  3513.         sw_error_2,
  3514.         sw_error_3,
  3515.         sw_error_4,
  3516.         sw_debug
  3517.     } state;

  3519.     if (b->last - b->pos < (ssize_t) ctx->rest) {
  3520.         last = b->last;

  3522.     } else {
  3523.         last = b->pos + ctx->rest;
  3524.     }

  3526.     state = ctx->frame_state;

  3528.     if (state == sw_start) {

  3530.         if (ctx->stream_id) {
  3531.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3532.                           "upstream sent goaway frame "
  3533.                           "with non-zero stream id: %ui",
  3534.                           ctx->stream_id);
  3535.             return NGX_ERROR;
  3536.         }

  3538.         if (ctx->rest < 8) {
  3539.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3540.                           "upstream sent goaway frame "
  3541.                           "with invalid length: %uz",
  3542.                           ctx->rest);
  3543.             return NGX_ERROR;
  3544.         }
  3545.     }

  3547.     for (p = b->pos; p < last; p++) {
  3548.         ch = *p;

  3550. #if 0
  3551.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3552.                        "http proxy goaway byte: %02Xd s:%d", ch, state);
  3553. #endif

  3555.         switch (state) {

  3557.         case sw_start:
  3558.             ctx->stream_id = (ch & 0x7f) << 24;
  3559.             state = sw_last_stream_id_2;
  3560.             break;

  3562.         case sw_last_stream_id_2:
  3563.             ctx->stream_id |= ch << 16;
  3564.             state = sw_last_stream_id_3;
  3565.             break;

  3567.         case sw_last_stream_id_3:
  3568.             ctx->stream_id |= ch << 8;
  3569.             state = sw_last_stream_id_4;
  3570.             break;

  3572.         case sw_last_stream_id_4:
  3573.             ctx->stream_id |= ch;
  3574.             state = sw_error;
  3575.             break;

  3577.         case sw_error:
  3578.             ctx->error = (ngx_uint_t) ch << 24;
  3579.             state = sw_error_2;
  3580.             break;

  3582.         case sw_error_2:
  3583.             ctx->error |= ch << 16;
  3584.             state = sw_error_3;
  3585.             break;

  3587.         case sw_error_3:
  3588.             ctx->error |= ch << 8;
  3589.             state = sw_error_4;
  3590.             break;

  3592.         case sw_error_4:
  3593.             ctx->error |= ch;
  3594.             state = sw_debug;
  3595.             break;

  3597.         case sw_debug:
  3598.             break;
  3599.         }
  3600.     }

  3602.     ctx->rest -= p - b->pos;
  3603.     ctx->frame_state = state;
  3604.     b->pos = p;

  3606.     if (ctx->rest > 0) {
  3607.         return NGX_AGAIN;
  3608.     }

  3610.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3611.                    "http proxy goaway: %ui, stream %ui",
  3612.                    ctx->error, ctx->stream_id);

  3614.     ctx->state = ngx_http_proxy_v2_st_start;

  3616.     return NGX_OK;
  3617. }


  3620. static ngx_int_t
  3621. ‌ngx_http_proxy_v2_parse_window_update(ngx_http_request_t *r,
  3622.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3623. {
  3624.     u_char  ch, *p, *last;
  3625. ‌    enum {
  3626.         sw_start = 0,
  3627.         sw_size_2,
  3628.         sw_size_3,
  3629.         sw_size_4
  3630.     } state;

  3632.     if (b->last - b->pos < (ssize_t) ctx->rest) {
  3633.         last = b->last;

  3635.     } else {
  3636.         last = b->pos + ctx->rest;
  3637.     }

  3639.     state = ctx->frame_state;

  3641.     if (state == sw_start) {
  3642.         if (ctx->rest != 4) {
  3643.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3644.                           "upstream sent window update frame "
  3645.                           "with invalid length: %uz",
  3646.                           ctx->rest);
  3647.             return NGX_ERROR;
  3648.         }
  3649.     }

  3651.     for (p = b->pos; p < last; p++) {
  3652.         ch = *p;

  3654. #if 0
  3655.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3656.                        "http proxy window update byte: %02Xd s:%d", ch, state);
  3657. #endif

  3659.         switch (state) {

  3661.         case sw_start:
  3662.             ctx->window_update = (ch & 0x7f) << 24;
  3663.             state = sw_size_2;
  3664.             break;

  3666.         case sw_size_2:
  3667.             ctx->window_update |= ch << 16;
  3668.             state = sw_size_3;
  3669.             break;

  3671.         case sw_size_3:
  3672.             ctx->window_update |= ch << 8;
  3673.             state = sw_size_4;
  3674.             break;

  3676.         case sw_size_4:
  3677.             ctx->window_update |= ch;
  3678.             state = sw_start;
  3679.             break;
  3680.         }
  3681.     }

  3683.     ctx->rest -= p - b->pos;
  3684.     ctx->frame_state = state;
  3685.     b->pos = p;

  3687.     if (ctx->rest > 0) {
  3688.         return NGX_AGAIN;
  3689.     }

  3691.     ctx->state = ngx_http_proxy_v2_st_start;

  3693.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3694.                    "http proxy window update: %ui", ctx->window_update);

  3696.     if (ctx->window_update == 0) {
  3697.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3698.                       "upstream sent zero window update");
  3699.         return NGX_ERROR;
  3700.     }

  3702.     if (ctx->stream_id) {

  3704.         if (ctx->window_update > (size_t) NGX_HTTP_V2_MAX_WINDOW
  3705.                                  - ctx->send_window)
  3706.         {
  3707.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3708.                           "upstream sent too large window update");
  3709.             return NGX_ERROR;
  3710.         }

  3712.         ctx->send_window += ctx->window_update;

  3714.     } else {

  3716.         if (ctx->window_update > NGX_HTTP_V2_MAX_WINDOW
  3717.                                  - ctx->connection->send_window)
  3718.         {
  3719.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3720.                           "upstream sent too large window update");
  3721.             return NGX_ERROR;
  3722.         }

  3724.         ctx->connection->send_window += ctx->window_update;
  3725.     }

  3727.     return NGX_OK;
  3728. }


  3731. static ngx_int_t
  3732. ‌ngx_http_proxy_v2_parse_settings(ngx_http_request_t *r,
  3733.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3734. {
  3735.     u_char   ch, *p, *last;
  3736.     ssize_t  window_update;
  3737. ‌    enum {
  3738.         sw_start = 0,
  3739.         sw_id,
  3740.         sw_id_2,
  3741.         sw_value,
  3742.         sw_value_2,
  3743.         sw_value_3,
  3744.         sw_value_4
  3745.     } state;

  3747.     if (b->last - b->pos < (ssize_t) ctx->rest) {
  3748.         last = b->last;

  3750.     } else {
  3751.         last = b->pos + ctx->rest;
  3752.     }

  3754.     state = ctx->frame_state;

  3756.     if (state == sw_start) {

  3758.         if (ctx->stream_id) {
  3759.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3760.                           "upstream sent settings frame "
  3761.                           "with non-zero stream id: %ui",
  3762.                           ctx->stream_id);
  3763.             return NGX_ERROR;
  3764.         }

  3766.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  3767.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3768.                            "http proxy settings ack");

  3770.             if (ctx->rest != 0) {
  3771.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3772.                               "upstream sent settings frame "
  3773.                               "with ack flag and non-zero length: %uz",
  3774.                               ctx->rest);
  3775.                 return NGX_ERROR;
  3776.             }

  3778.             ctx->state = ngx_http_proxy_v2_st_start;

  3780.             return NGX_OK;
  3781.         }

  3783.         if (ctx->rest % 6 != 0) {
  3784.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3785.                           "upstream sent settings frame "
  3786.                           "with invalid length: %uz",
  3787.                           ctx->rest);
  3788.             return NGX_ERROR;
  3789.         }

  3791.         if (ctx->free == NULL && ctx->settings++ > 1000) {
  3792.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3793.                           "upstream sent too many settings frames");
  3794.             return NGX_ERROR;
  3795.         }
  3796.     }

  3798.     for (p = b->pos; p < last; p++) {
  3799.         ch = *p;

  3801. #if 0
  3802.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3803.                        "http proxy settings byte: %02Xd s:%d", ch, state);
  3804. #endif

  3806.         switch (state) {

  3808.         case sw_start:
  3809.         case sw_id:
  3810.             ctx->setting_id = ch << 8;
  3811.             state = sw_id_2;
  3812.             break;

  3814.         case sw_id_2:
  3815.             ctx->setting_id |= ch;
  3816.             state = sw_value;
  3817.             break;

  3819.         case sw_value:
  3820.             ctx->setting_value = (ngx_uint_t) ch << 24;
  3821.             state = sw_value_2;
  3822.             break;

  3824.         case sw_value_2:
  3825.             ctx->setting_value |= ch << 16;
  3826.             state = sw_value_3;
  3827.             break;

  3829.         case sw_value_3:
  3830.             ctx->setting_value |= ch << 8;
  3831.             state = sw_value_4;
  3832.             break;

  3834.         case sw_value_4:
  3835.             ctx->setting_value |= ch;
  3836.             state = sw_id;

  3838.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3839.                            "http proxy setting: %ui %ui",
  3840.                            ctx->setting_id, ctx->setting_value);

  3842.             /*
  3843.              * The following settings are defined by the protocol:
  3844.              *
  3845.              * SETTINGS_HEADER_TABLE_SIZE, SETTINGS_ENABLE_PUSH,
  3846.              * SETTINGS_MAX_CONCURRENT_STREAMS, SETTINGS_INITIAL_WINDOW_SIZE,
  3847.              * SETTINGS_MAX_FRAME_SIZE, SETTINGS_MAX_HEADER_LIST_SIZE
  3848.              *
  3849.              * Only SETTINGS_INITIAL_WINDOW_SIZE seems to be needed in
  3850.              * a simple client.
  3851.              */

  3853.             if (ctx->setting_id == 0x04) {
  3854.                 /* SETTINGS_INITIAL_WINDOW_SIZE */

  3856.                 if (ctx->setting_value > NGX_HTTP_V2_MAX_WINDOW) {
  3857.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3858.                                   "upstream sent settings frame "
  3859.                                   "with too large initial window size: %ui",
  3860.                                   ctx->setting_value);
  3861.                     return NGX_ERROR;
  3862.                 }

  3864.                 window_update = ctx->setting_value
  3865.                                 - ctx->connection->init_window;
  3866.                 ctx->connection->init_window = ctx->setting_value;

  3868.                 if (ctx->send_window > 0
  3869.                     && window_update > (ssize_t) NGX_HTTP_V2_MAX_WINDOW
  3870.                                        - ctx->send_window)
  3871.                 {
  3872.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3873.                                   "upstream sent settings frame "
  3874.                                   "with too large initial window size: %ui",
  3875.                                   ctx->setting_value);
  3876.                     return NGX_ERROR;
  3877.                 }

  3879.                 ctx->send_window += window_update;
  3880.             }

  3882.             break;
  3883.         }
  3884.     }

  3886.     ctx->rest -= p - b->pos;
  3887.     ctx->frame_state = state;
  3888.     b->pos = p;

  3890.     if (ctx->rest > 0) {
  3891.         return NGX_AGAIN;
  3892.     }

  3894.     ctx->state = ngx_http_proxy_v2_st_start;

  3896.     return ngx_http_proxy_v2_send_settings_ack(r, ctx);
  3897. }


  3900. static ngx_int_t
  3901. ‌ngx_http_proxy_v2_parse_ping(ngx_http_request_t *r,
  3902.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3903. {
  3904.     u_char  ch, *p, *last;
  3905. ‌    enum {
  3906.         sw_start = 0,
  3907.         sw_data_2,
  3908.         sw_data_3,
  3909.         sw_data_4,
  3910.         sw_data_5,
  3911.         sw_data_6,
  3912.         sw_data_7,
  3913.         sw_data_8
  3914.     } state;

  3916.     if (b->last - b->pos < (ssize_t) ctx->rest) {
  3917.         last = b->last;

  3919.     } else {
  3920.         last = b->pos + ctx->rest;
  3921.     }

  3923.     state = ctx->frame_state;

  3925.     if (state == sw_start) {

  3927.         if (ctx->stream_id) {
  3928.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3929.                           "upstream sent ping frame "
  3930.                           "with non-zero stream id: %ui",
  3931.                           ctx->stream_id);
  3932.             return NGX_ERROR;
  3933.         }

  3935.         if (ctx->rest != 8) {
  3936.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3937.                           "upstream sent ping frame "
  3938.                           "with invalid length: %uz",
  3939.                           ctx->rest);
  3940.             return NGX_ERROR;
  3941.         }

  3943.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  3944.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3945.                           "upstream sent ping frame with ack flag");
  3946.             return NGX_ERROR;
  3947.         }

  3949.         if (ctx->free == NULL && ctx->pings++ > 1000) {
  3950.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3951.                           "upstream sent too many ping frames");
  3952.             return NGX_ERROR;
  3953.         }
  3954.     }

  3956.     for (p = b->pos; p < last; p++) {
  3957.         ch = *p;

  3959. #if 0
  3960.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3961.                        "http proxy ping byte: %02Xd s:%d", ch, state);
  3962. #endif

  3964.         if (state < sw_data_8) {
  3965.             ctx->ping_data[state] = ch;
  3966.             state++;

  3968.         } else {
  3969.             ctx->ping_data[7] = ch;
  3970.             state = sw_start;

  3972.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3973.                            "http proxy ping");
  3974.         }
  3975.     }

  3977.     ctx->rest -= p - b->pos;
  3978.     ctx->frame_state = state;
  3979.     b->pos = p;

  3981.     if (ctx->rest > 0) {
  3982.         return NGX_AGAIN;
  3983.     }

  3985.     ctx->state = ngx_http_proxy_v2_st_start;

  3987.     return ngx_http_proxy_v2_send_ping_ack(r, ctx);
  3988. }


  3991. static ngx_int_t
  3992. ‌ngx_http_proxy_v2_send_settings_ack(ngx_http_request_t *r,
  3993.     ngx_http_proxy_v2_ctx_t *ctx)
  3994. {
  3995.     ngx_chain_t                *cl, **ll;
  3996.     ngx_http_proxy_v2_frame_t  *f;

  3998.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3999.                    "http proxy send settings ack");

  4001.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4002.         ll = &cl->next;
  4003.     }

  4005.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  4006.     if (cl == NULL) {
  4007.         return NGX_ERROR;
  4008.     }

  4010.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4011.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  4013.     f->length_0 = 0;
  4014.     f->length_1 = 0;
  4015.     f->length_2 = 0;
  4016.     f->type = NGX_HTTP_V2_SETTINGS_FRAME;
  4017.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  4018.     f->stream_id_0 = 0;
  4019.     f->stream_id_1 = 0;
  4020.     f->stream_id_2 = 0;
  4021.     f->stream_id_3 = 0;

  4023.     *ll = cl;

  4025.     return NGX_OK;
  4026. }


  4029. static ngx_int_t
  4030. ‌ngx_http_proxy_v2_send_ping_ack(ngx_http_request_t *r,
  4031.     ngx_http_proxy_v2_ctx_t *ctx)
  4032. {
  4033.     ngx_chain_t                *cl, **ll;
  4034.     ngx_http_proxy_v2_frame_t  *f;

  4036.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4037.                    "http proxy send ping ack");

  4039.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4040.         ll = &cl->next;
  4041.     }

  4043.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  4044.     if (cl == NULL) {
  4045.         return NGX_ERROR;
  4046.     }

  4048.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4049.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  4051.     f->length_0 = 0;
  4052.     f->length_1 = 0;
  4053.     f->length_2 = 8;
  4054.     f->type = NGX_HTTP_V2_PING_FRAME;
  4055.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  4056.     f->stream_id_0 = 0;
  4057.     f->stream_id_1 = 0;
  4058.     f->stream_id_2 = 0;
  4059.     f->stream_id_3 = 0;

  4061.     cl->buf->last = ngx_copy(cl->buf->last, ctx->ping_data, 8);

  4063.     *ll = cl;

  4065.     return NGX_OK;
  4066. }


  4069. static ngx_int_t
  4070. ‌ngx_http_proxy_v2_send_window_update(ngx_http_request_t *r,
  4071.     ngx_http_proxy_v2_ctx_t *ctx)
  4072. {
  4073.     size_t                      n;
  4074.     ngx_chain_t                *cl, **ll;
  4075.     ngx_http_proxy_v2_frame_t  *f;

  4077.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4078.                    "http proxy send window update: %uz %uz",
  4079.                    ctx->connection->recv_window, ctx->recv_window);

  4081.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4082.         ll = &cl->next;
  4083.     }

  4085.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  4086.     if (cl == NULL) {
  4087.         return NGX_ERROR;
  4088.     }

  4090.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4091.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  4093.     f->length_0 = 0;
  4094.     f->length_1 = 0;
  4095.     f->length_2 = 4;
  4096.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4097.     f->flags = 0;
  4098.     f->stream_id_0 = 0;
  4099.     f->stream_id_1 = 0;
  4100.     f->stream_id_2 = 0;
  4101.     f->stream_id_3 = 0;

  4103.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->connection->recv_window;
  4104.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4106.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4107.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4108.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4109.     *cl->buf->last++ = (u_char) (n & 0xff);

  4111.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4112.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  4114.     f->length_0 = 0;
  4115.     f->length_1 = 0;
  4116.     f->length_2 = 4;
  4117.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4118.     f->flags = 0;
  4119.     f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  4120.     f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  4121.     f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  4122.     f->stream_id_3 = (u_char) (ctx->id & 0xff);

  4124.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->recv_window;
  4125.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4127.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4128.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4129.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4130.     *cl->buf->last++ = (u_char) (n & 0xff);

  4132.     *ll = cl;

  4134.     return NGX_OK;
  4135. }


  4138. static ngx_chain_t *
  4139. ‌ngx_http_proxy_v2_get_buf(ngx_http_request_t *r, ngx_http_proxy_v2_ctx_t *ctx)
  4140. {
  4141.     u_char       *start;
  4142.     ngx_buf_t    *b;
  4143.     ngx_chain_t  *cl;

  4145.     cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  4146.     if (cl == NULL) {
  4147.         return NULL;
  4148.     }

  4150.     b = cl->buf;
  4151.     start = b->start;

  4153.     if (start == NULL) {

  4155.         /*
  4156.          * each buffer is large enough to hold two window update
  4157.          * frames in a row
  4158.          */

  4160.         start = ngx_palloc(r->pool, 2 * sizeof(ngx_http_proxy_v2_frame_t) + 8);
  4161.         if (start == NULL) {
  4162.             return NULL;
  4163.         }

  4165.     }

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

  4169.     b->start = start;
  4170.     b->pos = start;
  4171.     b->last = start;
  4172.     b->end = start + 2 * sizeof(ngx_http_proxy_v2_frame_t) + 8;

  4174.     b->tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter;
  4175.     b->temporary = 1;
  4176.     b->flush = 1;

  4178.     return cl;
  4179. }


  4182. static ngx_http_proxy_v2_ctx_t *
  4183. ‌ngx_http_proxy_v2_get_ctx(ngx_http_request_t *r)
  4184. {
  4185.     ngx_http_upstream_t      *u;
  4186.     ngx_http_proxy_v2_ctx_t  *ctx;

  4188.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  4190.     if (ctx->connection == NULL) {
  4191.         u = r->upstream;

  4193.         if (ngx_http_proxy_v2_get_connection_data(r, ctx, &u->peer) != NGX_OK) {
  4194.             return NULL;
  4195.         }
  4196.     }

  4198.     return ctx;
  4199. }


  4202. static ngx_int_t
  4203. ‌ngx_http_proxy_v2_get_connection_data(ngx_http_request_t *r,
  4204.     ngx_http_proxy_v2_ctx_t *ctx, ngx_peer_connection_t *pc)
  4205. {
  4206.     ngx_connection_t    *c;
  4207.     ngx_pool_cleanup_t  *cln;

  4209.     if (ngx_http_proxy_v2_cached(r)) {
  4210.         ctx->connection = ngx_palloc(r->pool, sizeof(ngx_http_proxy_v2_conn_t));
  4211.         if (ctx->connection == NULL) {
  4212.             return NGX_ERROR;
  4213.         }

  4215.         ctx->id = 0;

  4217.         goto done;
  4218.     }

  4220.     c = pc->connection;

  4222.     if (pc->cached) {

  4224.         /*
  4225.          * for cached connections, connection data can be found
  4226.          * in the cleanup handler
  4227.          */

  4229.         for (cln = c->pool->cleanup; cln; cln = cln->next) {
  4230.             if (cln->handler == ngx_http_proxy_v2_cleanup) {
  4231.                 ctx->connection = cln->data;
  4232.                 break;
  4233.             }
  4234.         }

  4236.         if (ctx->connection == NULL) {
  4237.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  4238.                           "no connection data found for "
  4239.                           "keepalive http2 connection");
  4240.             return NGX_ERROR;
  4241.         }

  4243.         ctx->send_window = ctx->connection->init_window;
  4244.         ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4246.         ctx->connection->last_stream_id += 2;
  4247.         ctx->id = ctx->connection->last_stream_id;

  4249.         return NGX_OK;
  4250.     }

  4252.     cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_proxy_v2_conn_t));
  4253.     if (cln == NULL) {
  4254.         return NGX_ERROR;
  4255.     }

  4257.     cln->handler = ngx_http_proxy_v2_cleanup;
  4258.     ctx->connection = cln->data;

  4260.     ctx->id = 1;

  4262. done:

  4264.     ctx->connection->init_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4265.     ctx->connection->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4266.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4268.     ctx->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4269.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4271.     ctx->connection->last_stream_id = 1;

  4273.     return NGX_OK;
  4274. }


  4277. static ngx_inline ngx_int_t
  4278. ‌ngx_http_proxy_v2_cached(ngx_http_request_t *r)
  4279. {
  4280. #if (NGX_HTTP_CACHE)
  4281.     return r->cached;
  4282. #else
  4283.     return 0;
  4284. #endif
  4285. }


  4288. static void
  4289. ‌ngx_http_proxy_v2_cleanup(void *data)
  4290. {
  4291. #if 0
  4292.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  4293.                    "http proxy cleanup");
  4294. #endif
  4295.     return;
  4296. }


  4299. static void
  4300. ‌ngx_http_proxy_v2_abort_request(ngx_http_request_t *r)
  4301. {
  4302.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4303.                    "abort proxy http2 request");
  4304.     return;
  4305. }


  4308. static void
  4309. ‌ngx_http_proxy_v2_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  4310. {
  4311.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4312.                    "finalize proxy http2 request");
  4313.     return;
  4314. }

One Level Up Top Level