One Level Up Top Level

src/http/modules/ngx_http_proxy_v2_module.c - nginx-1.31.3 nginx/ @ 42f8df65b

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                         field_length;
  81.     size_t                         field_rest;
  82.     u_char                         field_state;

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

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


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


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

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

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

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

  165. static void ngx_http_proxy_v2_abort_request(ngx_http_request_t *r);
  166. static void ngx_http_proxy_v2_finalize_request(ngx_http_request_t *r,
  167.     ngx_int_t rc);


  170. ‌static ngx_http_module_t  ngx_http_proxy_v2_module_ctx = {
  171.     NULL,                                  /* preconfiguration */
  172.     NULL,                                  /* postconfiguration */

  174.     NULL,                                  /* create main configuration */
  175.     NULL,                                  /* init main configuration */

  177.     NULL,                                  /* create server configuration */
  178.     NULL,                                  /* merge server configuration */

  180.     NULL,                                  /* create location configuration */
  181.     NULL                                   /* merge location configuration */
  182. };


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


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

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

  209.     "\x00\x00\x04\x08\x00\x00\x00\x00\x00"     /* window update frame */
  210.     "\x7f\xff\x00\x00";


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

  224.     if (ngx_http_upstream_create(r) != NGX_OK) {
  225.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  226.     }

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

  233.     ngx_http_set_ctx(r, ctx, ngx_http_proxy_v2_module);

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

  237.     plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);

  239.     plcf->upstream.preserve_output = 1;

  241.     u = r->upstream;

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

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

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

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

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

  264. #if (NGX_HTTP_CACHE)
  265.     pmcf = ngx_http_get_module_main_conf(r, ngx_http_proxy_module);

  267.     u->caches = &pmcf->caches;
  268.     u->create_key = ngx_http_proxy_create_key;
  269. #endif

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

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

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

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

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

  292.     u->pipe->input_filter = ngx_http_proxy_v2_body_filter;
  293.     u->pipe->input_ctx = r;

  295.     u->input_filter_init = ngx_http_proxy_v2_filter_init;
  296.     u->input_filter = ngx_http_proxy_v2_non_buffered_filter;
  297.     u->input_filter_ctx = r;

  299.     u->accel = 1;

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

  307.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  309.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  310.         return rc;
  311.     }

  313.     return NGX_DONE;
  314. }


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

  339.     u = r->upstream;

  341.     plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);

  343. #if (NGX_HTTP_CACHE)
  344.     headers = u->cacheable ? &plcf->headers_cache : &plcf->headers;
  345. #else
  346.     headers = &plcf->headers;
  347. #endif

  349.     if (u->method.len) {
  350.         /* HEAD was changed to GET to cache response */
  351.         method = u->method;

  353.     } else if (plcf->method) {
  354.         if (ngx_http_complex_value(r, plcf->method, &method) != NGX_OK) {
  355.             return NGX_ERROR;
  356.         }

  358.     } else {
  359.         method = r->method_name;
  360.     }

  362.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  364.     if (method.len == 4
  365.         && ngx_strncasecmp(method.data, (u_char *) "HEAD", 4) == 0)
  366.     {
  367.         ctx->ctx.head = 1;
  368.     }

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

  373.     /* :method header */

  375.     if ((method.len == 3 && ngx_strncmp(method.data, "GET", 3) == 0)
  376.         || (method.len == 4 && ngx_strncmp(method.data, "POST", 4) == 0))
  377.     {
  378.         len += 1;
  379.         tmp_len = 0;

  381.     } else {
  382.         if (method.len > NGX_HTTP_V2_MAX_FIELD) {
  383.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  384.                           "too long http2 method: \"%V\"", &method);
  385.             return NGX_ERROR;
  386.         }

  388.         len += 1 + NGX_HTTP_V2_INT_OCTETS + method.len;
  389.         tmp_len = method.len;
  390.     }

  392.     /* :scheme header */

  394.     len += 1;

  396.     /* :path header */

  398.     escape = 0;
  399.     loc_len = 0;
  400.     unparsed_uri = 0;

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

  405.     } else if (ctx->ctx.vars.uri.len == 0 && r->valid_unparsed_uri) {
  406.         unparsed_uri = 1;
  407.         uri_len = r->unparsed_uri.len;

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

  413.         if (r->quoted_uri || r->internal) {
  414.             escape = 2 * ngx_escape_uri(NULL, r->uri.data + loc_len,
  415.                                         r->uri.len - loc_len, NGX_ESCAPE_URI);
  416.         }

  418.         uri_len = ctx->ctx.vars.uri.len + r->uri.len - loc_len + escape
  419.                   + sizeof("?") - 1 + r->args.len;
  420.     }

  422.     if (uri_len == 0) {
  423.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  424.                       "zero length URI to proxy");
  425.         return NGX_ERROR;
  426.     }

  428.     if (uri_len > NGX_HTTP_V2_MAX_FIELD) {
  429.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  430.                       "too long http2 URI");
  431.         return NGX_ERROR;
  432.     }

  434.     len += 1 + NGX_HTTP_V2_INT_OCTETS + uri_len;

  436.     if (tmp_len < uri_len) {
  437.         tmp_len = uri_len;
  438.     }

  440.     /* :authority header */

  442.     host = &ctx->ctx.vars.host_header;

  444.     if (!plcf->host_set) {
  445.         if (host->len > NGX_HTTP_V2_MAX_FIELD) {
  446.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  447.                           "too long http2 host: \"%V\"", host);
  448.             return NGX_ERROR;
  449.         }

  451.         len += 1 + NGX_HTTP_V2_INT_OCTETS + host->len;

  453.         if (tmp_len < host->len) {
  454.             tmp_len = host->len;
  455.         }
  456.     }

  458.     /* other headers */

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

  462.     ngx_http_script_flush_no_cacheable_variables(r, plcf->body_flushes);
  463.     ngx_http_script_flush_no_cacheable_variables(r, headers->flushes);

  465.     body_len = 0;

  467.     if (plcf->body_lengths) {
  468.         le.ip = plcf->body_lengths->elts;
  469.         le.request = r;
  470.         le.flushed = 1;

  472.         while (*(uintptr_t *) le.ip) {
  473.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  474.             body_len += lcode(&le);
  475.         }

  477.         ctx->ctx.internal_body_length = body_len;

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

  482.     } else {
  483.         ctx->ctx.internal_body_length = r->headers_in.content_length_n;
  484.     }

  486.     le.ip = headers->lengths->elts;
  487.     le.request = r;
  488.     le.flushed = 1;

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

  492.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  493.         key_len = lcode(&le);

  495.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  496.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  497.         }
  498.         le.ip += sizeof(uintptr_t);

  500.         if (val_len == 0) {
  501.             continue;
  502.         }

  504.         if (key_len > NGX_HTTP_V2_MAX_FIELD) {
  505.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  506.                           "too long http2 header name");
  507.             return NGX_ERROR;
  508.         }

  510.         if (val_len > NGX_HTTP_V2_MAX_FIELD) {
  511.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  512.                           "too long http2 header value");
  513.             return NGX_ERROR;
  514.         }

  516.         len += 1 + NGX_HTTP_V2_INT_OCTETS + key_len
  517.                  + NGX_HTTP_V2_INT_OCTETS + val_len;

  519.         if (tmp_len < key_len) {
  520.             tmp_len = key_len;
  521.         }

  523.         if (tmp_len < val_len) {
  524.             tmp_len = val_len;
  525.         }
  526.     }

  528.     if (plcf->upstream.pass_request_headers) {
  529.         part = &r->headers_in.headers.part;
  530.         header = part->elts;

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

  534.             if (i >= part->nelts) {
  535.                 if (part->next == NULL) {
  536.                     break;
  537.                 }

  539.                 part = part->next;
  540.                 header = part->elts;
  541.                 i = 0;
  542.             }

  544.             if (ngx_hash_find(&headers->hash, header[i].hash,
  545.                               header[i].lowcase_key, header[i].key.len))
  546.             {
  547.                 continue;
  548.             }

  550.             if (header[i].key.len > NGX_HTTP_V2_MAX_FIELD) {
  551.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  552.                               "too long http2 header name: \"%V\"",
  553.                               &header[i].key);
  554.                 return NGX_ERROR;
  555.             }

  557.             if (header[i].value.len > NGX_HTTP_V2_MAX_FIELD) {
  558.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  559.                               "too long http2 header value: \"%V: %V\"",
  560.                               &header[i].key, &header[i].value);
  561.                 return NGX_ERROR;
  562.             }

  564.             len += 1 + NGX_HTTP_V2_INT_OCTETS + header[i].key.len
  565.                      + NGX_HTTP_V2_INT_OCTETS + header[i].value.len;

  567.             if (tmp_len < header[i].key.len) {
  568.                 tmp_len = header[i].key.len;
  569.             }

  571.             if (tmp_len < header[i].value.len) {
  572.                 tmp_len = header[i].value.len;
  573.             }
  574.         }
  575.     }

  577.     /* continuation frames */

  579.     len += sizeof(ngx_http_proxy_v2_frame_t)
  580.            * (len / NGX_HTTP_V2_DEFAULT_FRAME_SIZE);


  583.     b = ngx_create_temp_buf(r->pool, len);
  584.     if (b == NULL) {
  585.         return NGX_ERROR;
  586.     }

  588.     cl = ngx_alloc_chain_link(r->pool);
  589.     if (cl == NULL) {
  590.         return NGX_ERROR;
  591.     }

  593.     cl->buf = b;
  594.     cl->next = NULL;

  596.     tmp = ngx_palloc(r->pool, tmp_len * 3);
  597.     if (tmp == NULL) {
  598.         return NGX_ERROR;
  599.     }

  601.     key_tmp = tmp + tmp_len;
  602.     val_tmp = tmp + 2 * tmp_len;

  604.     /* connection preface */

  606.     b->last = ngx_copy(b->last, ngx_http_proxy_v2_connection_start,
  607.                        sizeof(ngx_http_proxy_v2_connection_start) - 1);

  609.     /* headers frame */

  611.     headers_frame = b->last;

  613.     f = (ngx_http_proxy_v2_frame_t *) b->last;
  614.     b->last += sizeof(ngx_http_proxy_v2_frame_t);

  616.     f->length_0 = 0;
  617.     f->length_1 = 0;
  618.     f->length_2 = 0;
  619.     f->type = NGX_HTTP_V2_HEADERS_FRAME;
  620.     f->flags = 0;
  621.     f->stream_id_0 = 0;
  622.     f->stream_id_1 = 0;
  623.     f->stream_id_2 = 0;
  624.     f->stream_id_3 = 1;

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

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

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

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

  638.     } else {
  639.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_METHOD_INDEX);
  640.         b->last = ngx_http_v2_write_value(b->last, method.data,
  641.                                           method.len, tmp);

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

  647. #if (NGX_HTTP_SSL)
  648.     if (u->ssl) {
  649.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTPS_INDEX);

  651.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  652.                        "http proxy header: \":scheme: https\"");
  653.     } else
  654. #endif
  655.     {
  656.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTP_INDEX);

  658.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  659.                        "http proxy header: \":scheme: http\"");
  660.     }

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

  664.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  665.         b->last = ngx_http_v2_write_value(b->last, ctx->ctx.vars.uri.data,
  666.                                           ctx->ctx.vars.uri.len, tmp);

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

  671.     } else if (unparsed_uri) {

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

  676.         } else {
  677.             *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  678.             b->last = ngx_http_v2_write_value(b->last, r->unparsed_uri.data,
  679.                                               r->unparsed_uri.len, tmp);
  680.         }

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

  685.     } else {
  686.         p = val_tmp;

  688.         if (r->valid_location) {
  689.             p = ngx_copy(p, ctx->ctx.vars.uri.data, ctx->ctx.vars.uri.len);
  690.         }

  692.         if (escape) {
  693.             ngx_escape_uri(p, r->uri.data + loc_len,
  694.                            r->uri.len - loc_len, NGX_ESCAPE_URI);
  695.             p += r->uri.len - loc_len + escape;

  697.         } else {
  698.             p = ngx_copy(p, r->uri.data + loc_len, r->uri.len - loc_len);
  699.         }

  701.         if (r->args.len > 0) {
  702.             *p++ = '?';
  703.             p = ngx_copy(p, r->args.data, r->args.len);
  704.         }

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

  709.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  710.                        "http proxy header: \":path: %*s\"", p - val_tmp,
  711.                        val_tmp);
  712.     }

  714.     if (!plcf->host_set) {
  715.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_AUTHORITY_INDEX);
  716.         b->last = ngx_http_v2_write_value(b->last, host->data, host->len, tmp);

  718.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  719.                        "http proxy header: \":authority: %V\"", host);
  720.     }

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

  724.     e.ip = headers->values->elts;
  725.     e.request = r;
  726.     e.flushed = 1;

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

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

  732.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  733.         key_len = lcode(&le);

  735.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  736.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  737.         }
  738.         le.ip += sizeof(uintptr_t);

  740.         if (val_len == 0) {
  741.             e.skip = 1;

  743.             while (*(uintptr_t *) e.ip) {
  744.                 code = *(ngx_http_script_code_pt *) e.ip;
  745.                 code((ngx_http_script_engine_t *) &e);
  746.             }
  747.             e.ip += sizeof(uintptr_t);

  749.             e.skip = 0;

  751.             continue;
  752.         }

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

  756.         e.pos = key_tmp;

  758.         code = *(ngx_http_script_code_pt *) e.ip;
  759.         code((ngx_http_script_engine_t *) &e);

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

  763.         e.pos = val_tmp;

  765.         while (*(uintptr_t *) e.ip) {
  766.             code = *(ngx_http_script_code_pt *) e.ip;
  767.             code((ngx_http_script_engine_t *) &e);
  768.         }
  769.         e.ip += sizeof(uintptr_t);

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

  773. #if (NGX_DEBUG)
  774.         if (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP) {
  775.             ngx_strlow(key_tmp, key_tmp, key_len);

  777.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  778.                            "http proxy header: \"%*s: %*s\"",
  779.                            key_len, key_tmp, val_len, val_tmp);
  780.         }
  781. #endif
  782.     }

  784.     if (plcf->upstream.pass_request_headers) {
  785.         part = &r->headers_in.headers.part;
  786.         header = part->elts;

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

  790.             if (i >= part->nelts) {
  791.                 if (part->next == NULL) {
  792.                     break;
  793.                 }

  795.                 part = part->next;
  796.                 header = part->elts;
  797.                 i = 0;
  798.             }

  800.             if (ngx_hash_find(&headers->hash, header[i].hash,
  801.                               header[i].lowcase_key, header[i].key.len))
  802.             {
  803.                 continue;
  804.             }

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

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

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

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

  818.                 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  819.                                "http proxy header: \"%*s: %V\"",
  820.                                header[i].key.len, tmp, &header[i].value);
  821.             }
  822. #endif
  823.         }
  824.     }

  826.     /* update headers frame length */

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

  830.     if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  831.         len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  832.         next = 1;

  834.     } else {
  835.         next = 0;
  836.     }

  838.     f = (ngx_http_proxy_v2_frame_t *) headers_frame;

  840.     f->length_0 = (u_char) ((len >> 16) & 0xff);
  841.     f->length_1 = (u_char) ((len >> 8) & 0xff);
  842.     f->length_2 = (u_char) (len & 0xff);

  844.     /* create additional continuation frames */

  846.     p = headers_frame;

  848.     while (next) {
  849.         p += sizeof(ngx_http_proxy_v2_frame_t) + NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  850.         len = b->last - p;

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

  855.         if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  856.             len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  857.             next = 1;

  859.         } else {
  860.             next = 0;
  861.         }

  863.         f = (ngx_http_proxy_v2_frame_t *) p;

  865.         f->length_0 = (u_char) ((len >> 16) & 0xff);
  866.         f->length_1 = (u_char) ((len >> 8) & 0xff);
  867.         f->length_2 = (u_char) (len & 0xff);
  868.         f->type = NGX_HTTP_V2_CONTINUATION_FRAME;
  869.         f->flags = 0;
  870.         f->stream_id_0 = 0;
  871.         f->stream_id_1 = 0;
  872.         f->stream_id_2 = 0;
  873.         f->stream_id_3 = 1;
  874.     }

  876.     f->flags |= NGX_HTTP_V2_END_HEADERS_FLAG;

  878.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  879.                    "http proxy header: %*xs%s, len: %uz",
  880.                    (size_t) ngx_min(b->last - b->pos, 256), b->pos,
  881.                    b->last - b->pos > 256 ? "..." : "",
  882.                    b->last - b->pos);

  884.     if (r->request_body_no_buffering) {

  886.         u->request_bufs = cl;

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

  890.         body = u->request_bufs;
  891.         u->request_bufs = cl;

  893.         if (body == NULL) {
  894.             f = (ngx_http_proxy_v2_frame_t *) headers_frame;
  895.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;
  896.         }

  898.         while (body) {
  899.             b = ngx_alloc_buf(r->pool);
  900.             if (b == NULL) {
  901.                 return NGX_ERROR;
  902.             }

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

  906.             cl->next = ngx_alloc_chain_link(r->pool);
  907.             if (cl->next == NULL) {
  908.                 return NGX_ERROR;
  909.             }

  911.             cl = cl->next;
  912.             cl->buf = b;

  914.             body = body->next;
  915.         }

  917.         b->last_buf = 1;

  919.     } else if (body_len) {

  921.         u->request_bufs = cl;

  923.         b = ngx_create_temp_buf(r->pool, body_len);
  924.         if (b == NULL) {
  925.             return NGX_ERROR;
  926.         }

  928.         cl->next = ngx_alloc_chain_link(r->pool);
  929.         if (cl->next == NULL) {
  930.             return NGX_ERROR;
  931.         }

  933.         cl = cl->next;
  934.         cl->buf = b;

  936.         e.ip = plcf->body_values->elts;
  937.         e.pos = b->last;
  938.         e.request = r;
  939.         e.flushed = 1;
  940.         e.skip = 0;

  942.         while (*(uintptr_t *) e.ip) {
  943.             code = *(ngx_http_script_code_pt *) e.ip;
  944.             code((ngx_http_script_engine_t *) &e);
  945.         }

  947.         b->last = e.pos;
  948.         b->last_buf = 1;

  950.     } else {
  951.         u->request_bufs = cl;

  953.         f = (ngx_http_proxy_v2_frame_t *) headers_frame;
  954.         f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  956.         b->last_buf = 1;
  957.     }

  959.     u->output.output_filter = ngx_http_proxy_v2_body_output_filter;
  960.     u->output.filter_ctx = r;

  962.     b->flush = 1;
  963.     cl->next = NULL;

  965.     return NGX_OK;
  966. }


  969. static ngx_int_t
  970. ‌ngx_http_proxy_v2_reinit_request(ngx_http_request_t *r)
  971. {
  972.     ngx_http_proxy_v2_ctx_t  *ctx;

  974.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  976.     if (ctx == NULL) {
  977.         return NGX_OK;
  978.     }

  980.     ctx->state = 0;
  981.     ctx->header_sent = 0;
  982.     ctx->output_closed = 0;
  983.     ctx->output_blocked = 0;
  984.     ctx->parsing_headers = 0;
  985.     ctx->end_stream = 0;
  986.     ctx->done = 0;
  987.     ctx->status = 0;
  988.     ctx->rst = 0;
  989.     ctx->goaway = 0;
  990.     ctx->connection = NULL;
  991.     ctx->in = NULL;
  992.     ctx->busy = NULL;
  993.     ctx->out = NULL;

  995.     return NGX_OK;
  996. }


  999. static ngx_int_t
  1000. ‌ngx_http_proxy_v2_body_output_filter(void *data, ngx_chain_t *in)
  1001. {
  1002.     ngx_http_request_t  *r = data;

  1004.     off_t                       file_pos;
  1005.     u_char                     *p, *pos, *start;
  1006.     size_t                      len, limit;
  1007.     ngx_buf_t                  *b;
  1008.     ngx_int_t                  rc;
  1009.     ngx_uint_t                 next, last;
  1010.     ngx_chain_t                *cl, *out, *ln, **ll;
  1011.     ngx_http_upstream_t        *u;
  1012.     ngx_http_proxy_v2_ctx_t    *ctx;
  1013.     ngx_http_proxy_v2_frame_t  *f;

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

  1018.     ctx = ngx_http_proxy_v2_get_ctx(r);

  1020.     if (ctx == NULL) {
  1021.         return NGX_ERROR;
  1022.     }

  1024.     if (in) {
  1025.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  1026.             return NGX_ERROR;
  1027.         }
  1028.     }

  1030.     out = NULL;
  1031.     ll = &out;

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

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

  1039.         ctx->header_sent = 1;

  1041.         if (ctx->id != 1) {
  1042.             /*
  1043.              * keepalive connection: skip connection preface,
  1044.              * update stream identifiers
  1045.              */

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

  1050.             p = b->pos;

  1052.             while (p < b->last) {
  1053.                 f = (ngx_http_proxy_v2_frame_t *) p;
  1054.                 p += sizeof(ngx_http_proxy_v2_frame_t);

  1056.                 f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1057.                 f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1058.                 f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1059.                 f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1061.                 p += (f->length_0 << 16) + (f->length_1 << 8) + f->length_2;
  1062.             }
  1063.         }

  1065.         if (ctx->in->buf->last_buf) {
  1066.             ctx->output_closed = 1;
  1067.         }

  1069.         *ll = ctx->in;
  1070.         ll = &ctx->in->next;

  1072.         ctx->in = ctx->in->next;
  1073.     }

  1075.     if (ctx->out) {
  1076.         /* queued control frames */

  1078.         *ll = ctx->out;

  1080.         for (cl = ctx->out, ll = &cl->next; cl; cl = cl->next) {
  1081.             ll = &cl->next;
  1082.         }

  1084.         ctx->out = NULL;
  1085.     }

  1087.     f = NULL;
  1088.     last = 0;

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

  1092.     if (limit > ctx->connection->send_window) {
  1093.         limit = ctx->connection->send_window;
  1094.     }

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

  1100. #if (NGX_SUPPRESS_WARN)
  1101.     file_pos = 0;
  1102.     pos = NULL;
  1103.     cl = NULL;
  1104. #endif

  1106.     in = ctx->in;

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

  1110.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1111.                        "http proxy output in  l:%d f:%d %p, pos %p, size: %z "
  1112.                        "file: %O, size: %O",
  1113.                        in->buf->last_buf,
  1114.                        in->buf->in_file,
  1115.                        in->buf->start, in->buf->pos,
  1116.                        in->buf->last - in->buf->pos,
  1117.                        in->buf->file_pos,
  1118.                        in->buf->file_last - in->buf->file_pos);

  1120.         if (ngx_buf_special(in->buf)) {
  1121.             goto next;
  1122.         }

  1124.         if (in->buf->in_file) {
  1125.             file_pos = in->buf->file_pos;

  1127.         } else {
  1128.             pos = in->buf->pos;
  1129.         }

  1131.         next = 0;

  1133.         do {

  1135.             cl = ngx_http_proxy_v2_get_buf(r, ctx);
  1136.             if (cl == NULL) {
  1137.                 return NGX_ERROR;
  1138.             }

  1140.             b = cl->buf;

  1142.             f = (ngx_http_proxy_v2_frame_t *) b->last;
  1143.             b->last += sizeof(ngx_http_proxy_v2_frame_t);

  1145.             *ll = cl;
  1146.             ll = &cl->next;

  1148.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  1149.             if (cl == NULL) {
  1150.                 return NGX_ERROR;
  1151.             }

  1153.             b = cl->buf;
  1154.             start = b->start;

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

  1158.             /*
  1159.              * restore b->start to preserve memory allocated in the buffer,
  1160.              * to reuse it later for headers and control frames
  1161.              */

  1163.             b->start = start;

  1165.             if (in->buf->in_file) {
  1166.                 b->file_pos = file_pos;
  1167.                 file_pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1169.                 if (file_pos >= in->buf->file_last) {
  1170.                     file_pos = in->buf->file_last;
  1171.                     next = 1;
  1172.                 }

  1174.                 b->file_last = file_pos;
  1175.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1177.             } else {
  1178.                 b->pos = pos;
  1179.                 pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1181.                 if (pos >= in->buf->last) {
  1182.                     pos = in->buf->last;
  1183.                     next = 1;
  1184.                 }

  1186.                 b->last = pos;
  1187.                 len = (ngx_uint_t) (pos - b->pos);
  1188.             }

  1190.             b->tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter;
  1191.             b->shadow = in->buf;
  1192.             b->last_shadow = next;

  1194.             b->last_buf = 0;
  1195.             b->last_in_chain = 0;

  1197.             *ll = cl;
  1198.             ll = &cl->next;

  1200.             f->length_0 = (u_char) ((len >> 16) & 0xff);
  1201.             f->length_1 = (u_char) ((len >> 8) & 0xff);
  1202.             f->length_2 = (u_char) (len & 0xff);
  1203.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1204.             f->flags = 0;
  1205.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1206.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1207.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1208.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1210.             limit -= len;
  1211.             ctx->send_window -= len;
  1212.             ctx->connection->send_window -= len;

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

  1216.         if (!next) {
  1217.             /*
  1218.              * if the buffer wasn't fully sent due to flow control limits,
  1219.              * preserve position for future use
  1220.              */

  1222.             if (in->buf->in_file) {
  1223.                 in->buf->file_pos = file_pos;

  1225.             } else {
  1226.                 in->buf->pos = pos;
  1227.             }

  1229.             break;
  1230.         }

  1232.     next:

  1234.         if (in->buf->last_buf) {
  1235.             last = 1;
  1236.         }

  1238.         ln = in;
  1239.         in = in->next;

  1241.         ngx_free_chain(r->pool, ln);
  1242.     }

  1244.     ctx->in = in;

  1246.     if (last) {

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

  1251.         ctx->output_closed = 1;

  1253.         if (f) {
  1254.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1256.         } else {
  1257.             cl = ngx_http_proxy_v2_get_buf(r, ctx);
  1258.             if (cl == NULL) {
  1259.                 return NGX_ERROR;
  1260.             }

  1262.             b = cl->buf;

  1264.             f = (ngx_http_proxy_v2_frame_t *) b->last;
  1265.             b->last += sizeof(ngx_http_proxy_v2_frame_t);

  1267.             f->length_0 = 0;
  1268.             f->length_1 = 0;
  1269.             f->length_2 = 0;
  1270.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1271.             f->flags = NGX_HTTP_V2_END_STREAM_FLAG;
  1272.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1273.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1274.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1275.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1277.             *ll = cl;
  1278.             ll = &cl->next;
  1279.         }

  1281.         cl->buf->last_buf = 1;
  1282.     }

  1284.     *ll = NULL;

  1286. #if (NGX_DEBUG)

  1288.     for (cl = out; cl; cl = cl->next) {
  1289.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1290.                        "http proxy output out l:%d f:%d %p, pos %p, size: %z "
  1291.                        "file: %O, size: %O",
  1292.                        cl->buf->last_buf,
  1293.                        cl->buf->in_file,
  1294.                        cl->buf->start, cl->buf->pos,
  1295.                        cl->buf->last - cl->buf->pos,
  1296.                        cl->buf->file_pos,
  1297.                        cl->buf->file_last - cl->buf->file_pos);
  1298.     }

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

  1304. #endif

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

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

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

  1313.         /* mark original buffers as sent */

  1315.         if (cl->buf->shadow) {
  1316.             if (cl->buf->last_shadow) {
  1317.                 b = cl->buf->shadow;
  1318.                 b->pos = b->last;
  1319.             }

  1321.             cl->buf->shadow = NULL;
  1322.         }
  1323.     }

  1325.     if (rc == NGX_OK && ctx->in) {
  1326.         rc = NGX_AGAIN;
  1327.     }

  1329.     if (rc == NGX_AGAIN) {
  1330.         ctx->output_blocked = 1;

  1332.     } else {
  1333.         ctx->output_blocked = 0;
  1334.     }

  1336.     if (ctx->done) {

  1338.         /*
  1339.          * We have already got the response and were sending some additional
  1340.          * control frames.  Even if there is still something unsent, stop
  1341.          * here anyway.
  1342.          */

  1344.         u = r->upstream;
  1345.         u->length = 0;
  1346.         u->pipe->length = 0;

  1348.         if (ctx->in == NULL
  1349.             && ctx->out == NULL
  1350.             && ctx->output_closed
  1351.             && !ctx->output_blocked
  1352.             && !ctx->goaway
  1353.             && ctx->state == ngx_http_proxy_v2_st_start)
  1354.         {
  1355.             u->keepalive = 1;
  1356.         }

  1358.         ngx_post_event(u->peer.connection->read, &ngx_posted_events);
  1359.     }

  1361.     return rc;
  1362. }


  1365. static ngx_int_t
  1366. ‌ngx_http_proxy_v2_process_header(ngx_http_request_t *r)
  1367. {
  1368.     u_char                         *pos;
  1369.     ngx_str_t                      *status_line;
  1370.     ngx_int_t                       rc, status;
  1371.     ngx_buf_t                      *b;
  1372.     ngx_table_elt_t                *h;
  1373.     ngx_http_upstream_t            *u;
  1374.     ngx_http_proxy_v2_ctx_t        *ctx;
  1375.     ngx_http_upstream_header_t     *hh;
  1376.     ngx_http_upstream_main_conf_t  *umcf;

  1378.     u = r->upstream;
  1379.     b = &u->buffer;
  1380.     pos = b->pos;

  1382.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1383.                    "http proxy response: %*xs%s, len: %uz",
  1384.                    (size_t) ngx_min(b->last - b->pos, 256),
  1385.                    b->pos, b->last - b->pos > 256 ? "..." : "",
  1386.                    b->last - b->pos);

  1388.     ctx = ngx_http_proxy_v2_get_ctx(r);

  1390.     if (ctx == NULL) {
  1391.         return NGX_ERROR;
  1392.     }

  1394.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1396.     for ( ;; ) {

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

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

  1402.             if (rc == NGX_AGAIN) {

  1404.                 /*
  1405.                  * there can be a lot of window update frames,
  1406.                  * so we reset buffer if it is empty and we haven't
  1407.                  * started parsing headers yet
  1408.                  */

  1410.                 if (!ctx->parsing_headers) {
  1411.                     b->pos = pos;
  1412.                     b->last = b->pos;
  1413.                 }

  1415.                 return NGX_AGAIN;
  1416.             }

  1418.             if (rc == NGX_ERROR) {
  1419.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1420.             }

  1422.             /*
  1423.              * RFC 7540 says that implementations MUST discard frames
  1424.              * that have unknown or unsupported types.  However, extension
  1425.              * frames that appear in the middle of a header block are
  1426.              * not permitted.  Also, for obvious reasons CONTINUATION frames
  1427.              * cannot appear before headers, and DATA frames are not expected
  1428.              * to appear before all headers are parsed.
  1429.              */

  1431.             if (ctx->type == NGX_HTTP_V2_DATA_FRAME
  1432.                 || (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  1433.                     && !ctx->parsing_headers)
  1434.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  1435.                     && ctx->parsing_headers))
  1436.             {
  1437.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1438.                               "upstream sent unexpected http2 frame: %d",
  1439.                               ctx->type);
  1440.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1441.             }

  1443.             if (ctx->id && ctx->stream_id && ctx->stream_id != ctx->id) {
  1444.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1445.                               "upstream sent frame for unknown stream %ui",
  1446.                               ctx->stream_id);
  1447.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1448.             }
  1449.         }

  1451.         /* frame payload */

  1453.         if (u->peer.connection) {

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

  1458.                 if (rc == NGX_AGAIN) {
  1459.                     return NGX_AGAIN;
  1460.                 }

  1462.                 if (rc == NGX_ERROR) {
  1463.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1464.                 }

  1466.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1467.                               "upstream rejected request with error %ui",
  1468.                               ctx->error);

  1470.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1471.             }

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

  1475.             if (rc == NGX_AGAIN) {
  1476.                 return NGX_AGAIN;
  1477.             }

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

  1483.             if (rc == NGX_OK) {
  1484.                 continue;
  1485.             }
  1486.         }

  1488.         if (ctx->type != NGX_HTTP_V2_HEADERS_FRAME
  1489.             && ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME)
  1490.         {
  1491.             /* priority, unknown frames */

  1493.             rc = ngx_http_proxy_v2_skip_frame(ctx, b);

  1495.             if (rc == NGX_AGAIN) {
  1496.                 return NGX_AGAIN;
  1497.             }

  1499.             continue;
  1500.         }

  1502.         /* headers */

  1504.         for ( ;; ) {

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

  1508.             if (rc == NGX_AGAIN) {
  1509.                 break;
  1510.             }

  1512.             if (rc == NGX_OK) {

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

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

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

  1522.                     if (ctx->name.len != sizeof(":status") - 1
  1523.                         || ngx_strncmp(ctx->name.data, ":status",
  1524.                                        sizeof(":status") - 1)
  1525.                            != 0)
  1526.                     {
  1527.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1528.                                       "upstream sent invalid header \"%V: %V\"",
  1529.                                       &ctx->name, &ctx->value);
  1530.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1531.                     }

  1533.                     if (ctx->status) {
  1534.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1535.                                       "upstream sent duplicate :status header");
  1536.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1537.                     }

  1539.                     status_line = &ctx->value;

  1541.                     if (status_line->len != 3) {
  1542.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1543.                                       "upstream sent invalid :status \"%V\"",
  1544.                                       status_line);
  1545.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1546.                     }

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

  1550.                     if (status == NGX_ERROR) {
  1551.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1552.                                       "upstream sent invalid :status \"%V\"",
  1553.                                       status_line);
  1554.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1555.                     }

  1557.                     if (status < NGX_HTTP_OK && status != NGX_HTTP_EARLY_HINTS)
  1558.                     {
  1559.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1560.                                       "upstream sent unexpected :status \"%V\"",
  1561.                                       status_line);
  1562.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1563.                     }

  1565.                     u->headers_in.status_n = status;

  1567.                     if (u->state && u->state->status == 0) {
  1568.                         u->state->status = status;
  1569.                     }

  1571.                     ctx->status = 1;

  1573.                     continue;

  1575.                 } else if (!ctx->status) {
  1576.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1577.                                   "upstream sent no :status header");
  1578.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1579.                 }

  1581.                 h = ngx_list_push(&u->headers_in.headers);
  1582.                 if (h == NULL) {
  1583.                     return NGX_ERROR;
  1584.                 }

  1586.                 h->key = ctx->name;
  1587.                 h->value = ctx->value;
  1588.                 h->lowcase_key = h->key.data;
  1589.                 h->hash = ngx_hash_key(h->key.data, h->key.len);

  1591.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1592.                     continue;
  1593.                 }

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

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

  1601.                     if (rc != NGX_OK) {
  1602.                         return rc;
  1603.                     }
  1604.                 }

  1606.                 continue;
  1607.             }

  1609.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1616.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1617.                     if (ctx->end_stream) {
  1618.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1619.                                       "upstream prematurely closed stream");
  1620.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1621.                     }

  1623.                     ctx->status = 0;
  1624.                     return NGX_HTTP_UPSTREAM_EARLY_HINTS;
  1625.                 }

  1627.                 if (ctx->end_stream
  1628.                     && ctx->in == NULL
  1629.                     && ctx->out == NULL
  1630.                     && ctx->output_closed
  1631.                     && !ctx->output_blocked
  1632.                     && !ctx->goaway
  1633.                     && b->last == b->pos)
  1634.                 {
  1635.                     u->keepalive = 1;
  1636.                 }

  1638.                 return NGX_OK;
  1639.             }

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

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

  1646.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1647.         }

  1649.         /* rc == NGX_AGAIN */

  1651.         if (ctx->rest == 0) {
  1652.             ctx->state = ngx_http_proxy_v2_st_start;
  1653.             continue;
  1654.         }

  1656.         return NGX_AGAIN;
  1657.     }
  1658. }


  1661. static ngx_int_t
  1662. ‌ngx_http_proxy_v2_filter_init(void *data)
  1663. {
  1664.     ngx_http_request_t       *r = data;
  1665.     ngx_http_upstream_t      *u;
  1666.     ngx_http_proxy_v2_ctx_t  *ctx;

  1668.     u = r->upstream;
  1669.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1671.     if (ctx == NULL) {
  1672.         return NGX_ERROR;
  1673.     }

  1675.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1676.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED
  1677.         || ctx->ctx.head)
  1678.     {
  1679.         ctx->length = 0;

  1681.     } else {
  1682.         ctx->length = u->headers_in.content_length_n;
  1683.     }

  1685.     if (ctx->end_stream) {

  1687.         if (ctx->length > 0) {
  1688.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1689.                           "upstream prematurely closed stream");
  1690.             return NGX_ERROR;
  1691.         }

  1693.         u->length = 0;
  1694.         u->pipe->length = 0;
  1695.         ctx->done = 1;

  1697.     } else {
  1698.         u->length = 1;
  1699.         u->pipe->length = 1;
  1700.     }

  1702.     return NGX_OK;
  1703. }


  1706. static ngx_int_t
  1707. ‌ngx_http_proxy_v2_non_buffered_filter(void *data, ssize_t bytes)
  1708. {
  1709.     ngx_http_request_t   *r = data;

  1711.     ngx_int_t                 rc;
  1712.     ngx_buf_t                *b, *buf;
  1713.     ngx_chain_t              *cl, **ll;
  1714.     ngx_http_upstream_t      *u;
  1715.     ngx_http_proxy_v2_ctx_t  *ctx;

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

  1720.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1722.     if (ctx == NULL) {
  1723.         return NGX_ERROR;
  1724.     }

  1726.     u = r->upstream;
  1727.     b = &u->buffer;

  1729.     b->pos = b->last;
  1730.     b->last += bytes;

  1732.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  1733.         ll = &cl->next;
  1734.     }

  1736.     for ( ;; ) {

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

  1740.         if (rc == NGX_OK) {

  1742.             cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  1743.             if (cl == NULL) {
  1744.                 return NGX_ERROR;
  1745.             }

  1747.             *ll = cl;
  1748.             ll = &cl->next;

  1750.             buf = cl->buf;

  1752.             buf->flush = 1;
  1753.             buf->memory = 1;

  1755.             buf->pos = b->pos;
  1756.             buf->tag = u->output.tag;

  1758.             if (b->last - b->pos >= (ssize_t) ctx->rest - ctx->padding) {
  1759.                 b->pos += ctx->rest - ctx->padding;
  1760.                 buf->last = b->pos;
  1761.                 ctx->rest = ctx->padding;

  1763.             } else {
  1764.                 ctx->rest -= b->last - b->pos;
  1765.                 b->pos = b->last;
  1766.                 buf->last = b->pos;
  1767.             }

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

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

  1774.                 if (buf->last - buf->pos > ctx->length) {
  1775.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1776.                                   "upstream sent response body larger "
  1777.                                   "than indicated content length");
  1778.                     return NGX_ERROR;
  1779.                 }

  1781.                 ctx->length -= buf->last - buf->pos;
  1782.             }

  1784.             continue;
  1785.         }

  1787.         if (rc == NGX_DONE) {
  1788.             u->length = 0;
  1789.             break;
  1790.         }

  1792.         if (rc == NGX_AGAIN) {
  1793.             return NGX_AGAIN;
  1794.         }

  1796.         /* invalid response */

  1798.         return NGX_ERROR;
  1799.     }

  1801.     return NGX_OK;
  1802. }


  1805. static ngx_int_t
  1806. ‌ngx_http_proxy_v2_body_filter(ngx_event_pipe_t *p, ngx_buf_t *b)
  1807. {
  1808.     ngx_int_t                 rc;
  1809.     ngx_buf_t                *buf, **prev;
  1810.     ngx_chain_t              *cl;
  1811.     ngx_http_request_t       *r;
  1812.     ngx_http_proxy_v2_ctx_t  *ctx;

  1814.     if (b->pos == b->last) {
  1815.         return NGX_OK;
  1816.     }

  1818.     r = p->input_ctx;
  1819.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1821.     if (ctx == NULL) {
  1822.         return NGX_ERROR;
  1823.     }

  1825.     buf = NULL;
  1826.     prev = &b->shadow;

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

  1831.     for ( ;; ) {

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

  1835.         if (rc == NGX_OK) {

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

  1839.             cl = ngx_chain_get_free_buf(p->pool, &p->free);
  1840.             if (cl == NULL) {
  1841.                 return NGX_ERROR;
  1842.             }

  1844.             buf = cl->buf;

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

  1848.             buf->pos = b->pos;
  1849.             buf->start = b->start;
  1850.             buf->end = b->end;
  1851.             buf->tag = p->tag;
  1852.             buf->temporary = 1;
  1853.             buf->recycled = 1;

  1855.             *prev = buf;
  1856.             prev = &buf->shadow;

  1858.             if (p->in) {
  1859.                 *p->last_in = cl;

  1861.             } else {
  1862.                 p->in = cl;
  1863.             }

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

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

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

  1872.             if (b->last - b->pos >= (ssize_t) ctx->rest - ctx->padding) {
  1873.                 b->pos += ctx->rest - ctx->padding;
  1874.                 buf->last = b->pos;
  1875.                 ctx->rest = ctx->padding;

  1877.             } else {
  1878.                 ctx->rest -= b->last - b->pos;
  1879.                 b->pos = b->last;
  1880.                 buf->last = b->pos;
  1881.             }

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

  1885.                 if (buf->last - buf->pos > ctx->length) {
  1886.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1887.                                   "upstream sent response body larger "
  1888.                                   "than indicated content length");
  1889.                     return NGX_ERROR;
  1890.                 }

  1892.                 ctx->length -= buf->last - buf->pos;
  1893.             }

  1895.             continue;
  1896.         }

  1898.         if (rc == NGX_DONE) {
  1899.             p->length = 0;
  1900.             break;
  1901.         }

  1903.         if (rc == NGX_AGAIN) {
  1904.             break;
  1905.         }

  1907.         /* invalid response */

  1909.         return NGX_ERROR;
  1910.     }

  1912.     if (buf) {
  1913.         buf->shadow = b;
  1914.         buf->last_shadow = 1;

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

  1919.         return NGX_OK;
  1920.     }

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

  1924.     if (ngx_event_pipe_add_free_buf(p, b) != NGX_OK) {
  1925.         return NGX_ERROR;
  1926.     }

  1928.     return NGX_OK;
  1929. }


  1932. static ngx_int_t
  1933. ‌ngx_http_proxy_v2_process_control_frame(ngx_http_request_t *r,
  1934.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  1935. {
  1936.     ngx_int_t             rc;
  1937.     ngx_http_upstream_t  *u;

  1939.     u = r->upstream;

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

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

  1945.         if (rc == NGX_AGAIN) {
  1946.             return NGX_AGAIN;
  1947.         }

  1949.         if (rc == NGX_ERROR) {
  1950.             return NGX_ERROR;
  1951.         }

  1953.         /*
  1954.          * If stream_id is lower than one we use, our
  1955.          * request won't be processed and needs to be retried.
  1956.          * If stream_id is greater or equal to the one we use,
  1957.          * we can continue normally (except we can't use this
  1958.          * connection for additional requests).  If there is
  1959.          * a real error, the connection will be closed.
  1960.          */

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

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

  1966.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1967.                           "upstream sent goaway with error %ui",
  1968.                           ctx->error);

  1970.             return NGX_ERROR;
  1971.         }

  1973.         ctx->goaway = 1;

  1975.         return NGX_OK;
  1976.     }

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

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

  1982.         if (rc == NGX_AGAIN) {
  1983.             return NGX_AGAIN;
  1984.         }

  1986.         if (rc == NGX_ERROR) {
  1987.             return NGX_ERROR;
  1988.         }

  1990.         if (ctx->in) {
  1991.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1992.         }

  1994.         return NGX_OK;
  1995.     }

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

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

  2001.         if (rc == NGX_AGAIN) {
  2002.             return NGX_AGAIN;
  2003.         }

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

  2009.         if (ctx->in) {
  2010.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2011.         }

  2013.         return NGX_OK;
  2014.     }

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

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

  2020.         if (rc == NGX_AGAIN) {
  2021.             return NGX_AGAIN;
  2022.         }

  2024.         if (rc == NGX_ERROR) {
  2025.             return NGX_ERROR;
  2026.         }

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

  2030.         return NGX_OK;
  2031.     }

  2033.     if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  2034.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2035.                       "upstream sent unexpected push promise frame");
  2036.         return NGX_ERROR;
  2037.     }

  2039.     return NGX_DECLINED;
  2040. }


  2043. static ngx_int_t
  2044. ‌ngx_http_proxy_v2_skip_frame(ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2045. {
  2046.     if (b->last - b->pos < (ssize_t) ctx->rest) {
  2047.         ctx->rest -= b->last - b->pos;
  2048.         b->pos = b->last;
  2049.         return NGX_AGAIN;
  2050.     }

  2052.     b->pos += ctx->rest;
  2053.     ctx->rest = 0;
  2054.     ctx->state = ngx_http_proxy_v2_st_start;

  2056.     return NGX_OK;
  2057. }


  2060. static ngx_int_t
  2061. ‌ngx_http_proxy_v2_process_frames(ngx_http_request_t *r,
  2062.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2063. {
  2064.     ngx_int_t             rc;
  2065.     ngx_table_elt_t      *h;
  2066.     ngx_http_upstream_t  *u;

  2068.     u = r->upstream;

  2070.     for ( ;; ) {

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

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

  2076.             if (rc == NGX_AGAIN) {

  2078.                 if (ctx->done) {

  2080.                     if (ctx->length > 0) {
  2081.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2082.                                       "upstream prematurely closed stream");
  2083.                         return NGX_ERROR;
  2084.                     }

  2086.                     /*
  2087.                      * We have finished parsing the response and the
  2088.                      * remaining control frames.  If there are unsent
  2089.                      * control frames, post a write event to send them.
  2090.                      */

  2092.                     if (ctx->out) {
  2093.                         ngx_post_event(u->peer.connection->write,
  2094.                                        &ngx_posted_events);
  2095.                         return NGX_AGAIN;
  2096.                     }

  2098.                     if (ctx->in == NULL
  2099.                         && ctx->output_closed
  2100.                         && !ctx->output_blocked
  2101.                         && !ctx->goaway
  2102.                         && ctx->state == ngx_http_proxy_v2_st_start)
  2103.                     {
  2104.                         u->keepalive = 1;
  2105.                     }

  2107.                     return NGX_DONE;
  2108.                 }

  2110.                 return NGX_AGAIN;
  2111.             }

  2113.             if (rc == NGX_ERROR) {
  2114.                 return NGX_ERROR;
  2115.             }

  2117.             if ((ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  2118.                  && !ctx->parsing_headers)
  2119.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  2120.                     && ctx->parsing_headers))
  2121.             {
  2122.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2123.                               "upstream sent unexpected http2 frame: %d",
  2124.                               ctx->type);
  2125.                 return NGX_ERROR;
  2126.             }

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

  2130.                 if (ctx->stream_id != ctx->id) {
  2131.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2132.                                   "upstream sent data frame "
  2133.                                   "for unknown stream %ui",
  2134.                                   ctx->stream_id);
  2135.                     return NGX_ERROR;
  2136.                 }

  2138.                 if (ctx->rest > ctx->recv_window) {
  2139.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2140.                                   "upstream violated stream flow control, "
  2141.                                   "received %uz data frame with window %uz",
  2142.                                   ctx->rest, ctx->recv_window);
  2143.                     return NGX_ERROR;
  2144.                 }

  2146.                 if (ctx->rest > ctx->connection->recv_window) {
  2147.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2148.                                   "upstream violated connection flow control, "
  2149.                                   "received %uz data frame with window %uz",
  2150.                                   ctx->rest, ctx->connection->recv_window);
  2151.                     return NGX_ERROR;
  2152.                 }

  2154.                 ctx->recv_window -= ctx->rest;
  2155.                 ctx->connection->recv_window -= ctx->rest;

  2157.                 if (ctx->connection->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4
  2158.                     || ctx->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4)
  2159.                 {
  2160.                     if (ngx_http_proxy_v2_send_window_update(r, ctx)
  2161.                         != NGX_OK)
  2162.                     {
  2163.                         return NGX_ERROR;
  2164.                     }

  2166.                     ngx_post_event(u->peer.connection->write,
  2167.                                    &ngx_posted_events);
  2168.                 }
  2169.             }

  2171.             if (ctx->stream_id && ctx->stream_id != ctx->id) {
  2172.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2173.                               "upstream sent frame for unknown stream %ui",
  2174.                               ctx->stream_id);
  2175.                 return NGX_ERROR;
  2176.             }

  2178.             if (ctx->stream_id && ctx->done
  2179.                 && ctx->type != NGX_HTTP_V2_RST_STREAM_FRAME
  2180.                 && ctx->type != NGX_HTTP_V2_WINDOW_UPDATE_FRAME)
  2181.             {
  2182.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2183.                               "upstream sent frame for closed stream %ui",
  2184.                               ctx->stream_id);
  2185.                 return NGX_ERROR;
  2186.             }

  2188.             ctx->padding = 0;
  2189.         }

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

  2193.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2194.                 ctx->rest -= b->last - b->pos;
  2195.                 b->pos = b->last;
  2196.                 return NGX_AGAIN;
  2197.             }

  2199.             b->pos += ctx->rest;
  2200.             ctx->rest = 0;
  2201.             ctx->state = ngx_http_proxy_v2_st_start;

  2203.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2204.                 ctx->done = 1;
  2205.             }

  2207.             continue;
  2208.         }

  2210.         /* frame payload */

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

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

  2216.             if (rc == NGX_AGAIN) {
  2217.                 return NGX_AGAIN;
  2218.             }

  2220.             if (rc == NGX_ERROR) {
  2221.                 return NGX_ERROR;
  2222.             }

  2224.             if (ctx->error || !ctx->done) {
  2225.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2226.                               "upstream rejected request with error %ui",
  2227.                               ctx->error);
  2228.                 return NGX_ERROR;
  2229.             }

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

  2238.             ctx->rst = 1;

  2240.             continue;
  2241.         }

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

  2245.         if (rc == NGX_AGAIN) {
  2246.             return NGX_AGAIN;
  2247.         }

  2249.         if (rc == NGX_ERROR) {
  2250.             return NGX_ERROR;
  2251.         }

  2253.         if (rc == NGX_OK) {
  2254.             continue;
  2255.         }

  2257.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME
  2258.             || ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME)
  2259.         {
  2260.             for ( ;; ) {

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

  2264.                 if (rc == NGX_AGAIN) {
  2265.                     break;
  2266.                 }

  2268.                 if (rc == NGX_OK) {

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

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

  2276.                     if (ctx->name.len && ctx->name.data[0] == ':') {
  2277.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2278.                                       "upstream sent invalid "
  2279.                                       "trailer \"%V: %V\"",
  2280.                                       &ctx->name, &ctx->value);
  2281.                         return NGX_ERROR;
  2282.                     }

  2284.                     h = ngx_list_push(&u->headers_in.trailers);
  2285.                     if (h == NULL) {
  2286.                         return NGX_ERROR;
  2287.                     }

  2289.                     h->key = ctx->name;
  2290.                     h->value = ctx->value;
  2291.                     h->lowcase_key = h->key.data;
  2292.                     h->hash = ngx_hash_key(h->key.data, h->key.len);

  2294.                     continue;
  2295.                 }

  2297.                 if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2304.                     if (ctx->end_stream) {
  2305.                         ctx->done = 1;
  2306.                         break;
  2307.                     }

  2309.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2310.                                   "upstream sent trailer without "
  2311.                                   "end stream flag");
  2312.                     return NGX_ERROR;
  2313.                 }

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

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

  2320.                 return NGX_ERROR;
  2321.             }

  2323.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2324.                 continue;
  2325.             }

  2327.             /* rc == NGX_AGAIN */

  2329.             if (ctx->rest == 0) {
  2330.                 ctx->state = ngx_http_proxy_v2_st_start;
  2331.                 continue;
  2332.             }

  2334.             return NGX_AGAIN;
  2335.         }

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

  2339.             /* priority, unknown frames */

  2341.             rc = ngx_http_proxy_v2_skip_frame(ctx, b);

  2343.             if (rc == NGX_AGAIN) {
  2344.                 return NGX_AGAIN;
  2345.             }

  2347.             continue;
  2348.         }

  2350.         /*
  2351.          * data frame:
  2352.          *
  2353.          * +---------------+
  2354.          * |Pad Length? (8)|
  2355.          * +---------------+-----------------------------------------------+
  2356.          * |                            Data (*)                         ...
  2357.          * +---------------------------------------------------------------+
  2358.          * |                           Padding (*)                       ...
  2359.          * +---------------------------------------------------------------+
  2360.          */

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

  2364.             if (ctx->rest == 0) {
  2365.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2366.                               "upstream sent too short http2 frame");
  2367.                 return NGX_ERROR;
  2368.             }

  2370.             if (b->pos == b->last) {
  2371.                 return NGX_AGAIN;
  2372.             }

  2374.             ctx->flags &= ~NGX_HTTP_V2_PADDED_FLAG;
  2375.             ctx->padding = *b->pos++;
  2376.             ctx->rest -= 1;

  2378.             if (ctx->padding > ctx->rest) {
  2379.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2380.                               "upstream sent http2 frame with too long "
  2381.                               "padding: %d in frame %uz",
  2382.                               ctx->padding, ctx->rest);
  2383.                 return NGX_ERROR;
  2384.             }

  2386.             continue;
  2387.         }

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

  2391.             if (ctx->padding) {
  2392.                 ctx->state = ngx_http_proxy_v2_st_padding;

  2394.             } else {
  2395.                 ctx->state = ngx_http_proxy_v2_st_start;

  2397.                 if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2398.                     ctx->done = 1;
  2399.                 }
  2400.             }

  2402.             continue;
  2403.         }

  2405.         if (b->pos == b->last) {
  2406.             return NGX_AGAIN;
  2407.         }

  2409.         return NGX_OK;
  2410.     }
  2411. }


  2414. static ngx_int_t
  2415. ‌ngx_http_proxy_v2_parse_frame(ngx_http_request_t *r,
  2416.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2417. {
  2418.     u_char                     ch, *p;
  2419.     ngx_http_proxy_v2_state_e  state;

  2421.     state = ctx->state;

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

  2426. #if 0
  2427.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2428.                        "http proxy frame byte: %02Xd, s:%d", ch, state);
  2429. #endif

  2431.         switch (state) {

  2433.         case ngx_http_proxy_v2_st_start:
  2434.             ctx->rest = ch << 16;
  2435.             state = ngx_http_proxy_v2_st_length_2;
  2436.             break;

  2438.         case ngx_http_proxy_v2_st_length_2:
  2439.             ctx->rest |= ch << 8;
  2440.             state = ngx_http_proxy_v2_st_length_3;
  2441.             break;

  2443.         case ngx_http_proxy_v2_st_length_3:
  2444.             ctx->rest |= ch;

  2446.             if (ctx->rest > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  2447.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2448.                               "upstream sent too large http2 frame: %uz",
  2449.                               ctx->rest);
  2450.                 return NGX_ERROR;
  2451.             }

  2453.             state = ngx_http_proxy_v2_st_type;
  2454.             break;

  2456.         case ngx_http_proxy_v2_st_type:
  2457.             ctx->type = ch;
  2458.             state = ngx_http_proxy_v2_st_flags;
  2459.             break;

  2461.         case ngx_http_proxy_v2_st_flags:
  2462.             ctx->flags = ch;
  2463.             state = ngx_http_proxy_v2_st_stream_id;
  2464.             break;

  2466.         case ngx_http_proxy_v2_st_stream_id:
  2467.             ctx->stream_id = (ch & 0x7f) << 24;
  2468.             state = ngx_http_proxy_v2_st_stream_id_2;
  2469.             break;

  2471.         case ngx_http_proxy_v2_st_stream_id_2:
  2472.             ctx->stream_id |= ch << 16;
  2473.             state = ngx_http_proxy_v2_st_stream_id_3;
  2474.             break;

  2476.         case ngx_http_proxy_v2_st_stream_id_3:
  2477.             ctx->stream_id |= ch << 8;
  2478.             state = ngx_http_proxy_v2_st_stream_id_4;
  2479.             break;

  2481.         case ngx_http_proxy_v2_st_stream_id_4:
  2482.             ctx->stream_id |= ch;

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

  2488.             b->pos = p + 1;

  2490.             ctx->state = ngx_http_proxy_v2_st_payload;
  2491.             ctx->frame_state = 0;

  2493.             return NGX_OK;

  2495.         /* suppress warning */
  2496.         case ngx_http_proxy_v2_st_payload:
  2497.         case ngx_http_proxy_v2_st_padding:
  2498.             break;
  2499.         }
  2500.     }

  2502.     b->pos = p;
  2503.     ctx->state = state;

  2505.     return NGX_AGAIN;
  2506. }


  2509. static ngx_int_t
  2510. ‌ngx_http_proxy_v2_parse_header(ngx_http_request_t *r,
  2511.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2512. {
  2513.     u_char     ch, *p, *last;
  2514.     size_t     min;
  2515.     ngx_int_t  rc;
  2516. ‌    enum {
  2517.         sw_start = 0,
  2518.         sw_padding_length,
  2519.         sw_dependency,
  2520.         sw_dependency_2,
  2521.         sw_dependency_3,
  2522.         sw_dependency_4,
  2523.         sw_weight,
  2524.         sw_fragment,
  2525.         sw_padding
  2526.     } state;

  2528.     state = ctx->frame_state;

  2530.     if (state == sw_start) {

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

  2535.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME) {
  2536.             ctx->parsing_headers = 1;
  2537.             ctx->fragment_state = 0;

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

  2542.             if (ctx->rest < min) {
  2543.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2544.                               "upstream sent headers frame "
  2545.                               "with invalid length: %uz",
  2546.                               ctx->rest);
  2547.                 return NGX_ERROR;
  2548.             }

  2550.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2551.                 ctx->end_stream = 1;
  2552.             }

  2554.             if (ctx->flags & NGX_HTTP_V2_PADDED_FLAG) {
  2555.                 state = sw_padding_length;

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

  2560.             } else {
  2561.                 state = sw_fragment;
  2562.             }

  2564.         } else if (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME) {
  2565.             state = sw_fragment;
  2566.         }

  2568.         ctx->padding = 0;
  2569.         ctx->frame_state = state;
  2570.     }

  2572.     if (state < sw_fragment) {

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

  2577.         } else {
  2578.             last = b->pos + ctx->rest;
  2579.         }

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

  2584. #if 0
  2585.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2586.                            "http proxy header byte: %02Xd s:%d", ch, state);
  2587. #endif

  2589.             /*
  2590.              * headers frame:
  2591.              *
  2592.              * +---------------+
  2593.              * |Pad Length? (8)|
  2594.              * +-+-------------+----------------------------------------------+
  2595.              * |E|                 Stream Dependency? (31)                    |
  2596.              * +-+-------------+----------------------------------------------+
  2597.              * |  Weight? (8)  |
  2598.              * +-+-------------+----------------------------------------------+
  2599.              * |                   Header Block Fragment (*)                ...
  2600.              * +--------------------------------------------------------------+
  2601.              * |                           Padding (*)                      ...
  2602.              * +--------------------------------------------------------------+
  2603.              */

  2605.             switch (state) {

  2607.             case sw_padding_length:

  2609.                 ctx->padding = ch;

  2611.                 if (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG) {
  2612.                     state = sw_dependency;
  2613.                     break;
  2614.                 }

  2616.                 goto fragment;

  2618.             case sw_dependency:
  2619.                 state = sw_dependency_2;
  2620.                 break;

  2622.             case sw_dependency_2:
  2623.                 state = sw_dependency_3;
  2624.                 break;

  2626.             case sw_dependency_3:
  2627.                 state = sw_dependency_4;
  2628.                 break;

  2630.             case sw_dependency_4:
  2631.                 state = sw_weight;
  2632.                 break;

  2634.             case sw_weight:
  2635.                 goto fragment;

  2637.             /* suppress warning */
  2638.             case sw_start:
  2639.             case sw_fragment:
  2640.             case sw_padding:
  2641.                 break;
  2642.             }
  2643.         }

  2645.         ctx->rest -= p - b->pos;
  2646.         b->pos = p;

  2648.         ctx->frame_state = state;
  2649.         return NGX_AGAIN;

  2651.     fragment:

  2653.         p++;
  2654.         ctx->rest -= p - b->pos;
  2655.         b->pos = p;

  2657.         if (ctx->padding > ctx->rest) {
  2658.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2659.                           "upstream sent http2 frame with too long "
  2660.                           "padding: %d in frame %uz",
  2661.                           ctx->padding, ctx->rest);
  2662.             return NGX_ERROR;
  2663.         }

  2665.         state = sw_fragment;
  2666.         ctx->frame_state = state;
  2667.     }

  2669.     if (state == sw_fragment) {

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

  2673.         if (rc == NGX_AGAIN) {
  2674.             return NGX_AGAIN;
  2675.         }

  2677.         if (rc == NGX_ERROR) {
  2678.             return NGX_ERROR;
  2679.         }

  2681.         if (rc == NGX_OK) {
  2682.             return NGX_OK;
  2683.         }

  2685.         /* rc == NGX_DONE */

  2687.         state = sw_padding;
  2688.         ctx->frame_state = state;
  2689.     }

  2691.     if (state == sw_padding) {

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

  2695.             ctx->rest -= b->last - b->pos;
  2696.             b->pos = b->last;

  2698.             return NGX_AGAIN;
  2699.         }

  2701.         b->pos += ctx->rest;
  2702.         ctx->rest = 0;

  2704.         ctx->state = ngx_http_proxy_v2_st_start;

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

  2708.             if (ctx->fragment_state) {
  2709.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2710.                               "upstream sent truncated http2 header");
  2711.                 return NGX_ERROR;
  2712.             }

  2714.             ctx->parsing_headers = 0;

  2716.             return NGX_HTTP_PARSE_HEADER_DONE;
  2717.         }

  2719.         return NGX_AGAIN;
  2720.     }

  2722.     /* unreachable */

  2724.     return NGX_ERROR;
  2725. }


  2728. static ngx_int_t
  2729. ‌ngx_http_proxy_v2_parse_fragment(ngx_http_request_t *r,
  2730.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2731. {
  2732.     u_char      ch, *p, *last;
  2733.     size_t      size;
  2734.     ngx_uint_t  index, size_update;
  2735. ‌    enum {
  2736.         sw_start = 0,
  2737.         sw_index,
  2738.         sw_name_length,
  2739.         sw_name_length_2,
  2740.         sw_name_length_3,
  2741.         sw_name_length_4,
  2742.         sw_name,
  2743.         sw_name_bytes,
  2744.         sw_value_length,
  2745.         sw_value_length_2,
  2746.         sw_value_length_3,
  2747.         sw_value_length_4,
  2748.         sw_value,
  2749.         sw_value_bytes
  2750.     } state;

  2752.     /* header block fragment */

  2754. #if 0
  2755.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2756.                    "http proxy header fragment %p:%p rest:%uz",
  2757.                    b->pos, b->last, ctx->rest);
  2758. #endif

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

  2763.     } else {
  2764.         last = b->pos + ctx->rest - ctx->padding;
  2765.     }

  2767.     state = ctx->fragment_state;

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

  2772. #if 0
  2773.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2774.                        "http proxy header byte: %02Xd s:%d", ch, state);
  2775. #endif

  2777.         switch (state) {

  2779.         case sw_start:
  2780.             ctx->index = 0;

  2782.             if ((ch & 0x80) == 0x80) {
  2783.                 /*
  2784.                  * indexed header:
  2785.                  *
  2786.                  *   0   1   2   3   4   5   6   7
  2787.                  * +---+---+---+---+---+---+---+---+
  2788.                  * | 1 |        Index (7+)         |
  2789.                  * +---+---------------------------+
  2790.                  */

  2792.                 index = ch & ~0x80;

  2794.                 if (index == 0 || index > 61) {
  2795.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2796.                                   "upstream sent invalid http2 "
  2797.                                   "table index: %ui", index);
  2798.                     return NGX_ERROR;
  2799.                 }

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

  2804.                 ctx->index = index;
  2805.                 ctx->literal = 0;

  2807.                 goto done;

  2809.             } else if ((ch & 0xc0) == 0x40) {
  2810.                 /*
  2811.                  * literal header with incremental indexing:
  2812.                  *
  2813.                  *   0   1   2   3   4   5   6   7
  2814.                  * +---+---+---+---+---+---+---+---+
  2815.                  * | 0 | 1 |      Index (6+)       |
  2816.                  * +---+---+-----------------------+
  2817.                  * | H |     Value Length (7+)     |
  2818.                  * +---+---------------------------+
  2819.                  * | Value String (Length octets)  |
  2820.                  * +-------------------------------+
  2821.                  *
  2822.                  *   0   1   2   3   4   5   6   7
  2823.                  * +---+---+---+---+---+---+---+---+
  2824.                  * | 0 | 1 |           0           |
  2825.                  * +---+---+-----------------------+
  2826.                  * | H |     Name Length (7+)      |
  2827.                  * +---+---------------------------+
  2828.                  * |  Name String (Length octets)  |
  2829.                  * +---+---------------------------+
  2830.                  * | H |     Value Length (7+)     |
  2831.                  * +---+---------------------------+
  2832.                  * | Value String (Length octets)  |
  2833.                  * +-------------------------------+
  2834.                  */

  2836.                 index = ch & ~0xc0;

  2838.                 if (index > 61) {
  2839.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2840.                                   "upstream sent invalid http2 "
  2841.                                   "table index: %ui", index);
  2842.                     return NGX_ERROR;
  2843.                 }

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

  2848.                 if (index == 0) {
  2849.                     state = sw_name_length;
  2850.                     break;
  2851.                 }

  2853.                 ctx->index = index;
  2854.                 ctx->literal = 1;

  2856.                 state = sw_value_length;
  2857.                 break;

  2859.             } else if ((ch & 0xe0) == 0x20) {
  2860.                 /*
  2861.                  * dynamic table size update:
  2862.                  *
  2863.                  *   0   1   2   3   4   5   6   7
  2864.                  * +---+---+---+---+---+---+---+---+
  2865.                  * | 0 | 0 | 1 |   Max size (5+)   |
  2866.                  * +---+---------------------------+
  2867.                  */

  2869.                 size_update = ch & ~0xe0;

  2871.                 if (size_update > 0) {
  2872.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2873.                                   "upstream sent invalid http2 "
  2874.                                   "dynamic table size update: %ui",
  2875.                                   size_update);
  2876.                     return NGX_ERROR;
  2877.                 }

  2879.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2880.                                "http proxy table size update: %ui",
  2881.                                size_update);

  2883.                 break;

  2885.             } else if ((ch & 0xf0) == 0x10) {
  2886.                 /*
  2887.                  *  literal header field never indexed:
  2888.                  *
  2889.                  *   0   1   2   3   4   5   6   7
  2890.                  * +---+---+---+---+---+---+---+---+
  2891.                  * | 0 | 0 | 0 | 1 |  Index (4+)   |
  2892.                  * +---+---+-----------------------+
  2893.                  * | H |     Value Length (7+)     |
  2894.                  * +---+---------------------------+
  2895.                  * | Value String (Length octets)  |
  2896.                  * +-------------------------------+
  2897.                  *
  2898.                  *   0   1   2   3   4   5   6   7
  2899.                  * +---+---+---+---+---+---+---+---+
  2900.                  * | 0 | 0 | 0 | 1 |       0       |
  2901.                  * +---+---+-----------------------+
  2902.                  * | H |     Name Length (7+)      |
  2903.                  * +---+---------------------------+
  2904.                  * |  Name String (Length octets)  |
  2905.                  * +---+---------------------------+
  2906.                  * | H |     Value Length (7+)     |
  2907.                  * +---+---------------------------+
  2908.                  * | Value String (Length octets)  |
  2909.                  * +-------------------------------+
  2910.                  */

  2912.                 index = ch & ~0xf0;

  2914.                 if (index == 0x0f) {
  2915.                     ctx->index = index;
  2916.                     ctx->literal = 1;
  2917.                     state = sw_index;
  2918.                     break;
  2919.                 }

  2921.                 if (index == 0) {
  2922.                     state = sw_name_length;
  2923.                     break;
  2924.                 }

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

  2930.                 ctx->index = index;
  2931.                 ctx->literal = 1;

  2933.                 state = sw_value_length;
  2934.                 break;

  2936.             } else if ((ch & 0xf0) == 0x00) {
  2937.                 /*
  2938.                  * literal header field without indexing:
  2939.                  *
  2940.                  *   0   1   2   3   4   5   6   7
  2941.                  * +---+---+---+---+---+---+---+---+
  2942.                  * | 0 | 0 | 0 | 0 |  Index (4+)   |
  2943.                  * +---+---+-----------------------+
  2944.                  * | H |     Value Length (7+)     |
  2945.                  * +---+---------------------------+
  2946.                  * | Value String (Length octets)  |
  2947.                  * +-------------------------------+
  2948.                  *
  2949.                  *   0   1   2   3   4   5   6   7
  2950.                  * +---+---+---+---+---+---+---+---+
  2951.                  * | 0 | 0 | 0 | 0 |       0       |
  2952.                  * +---+---+-----------------------+
  2953.                  * | H |     Name Length (7+)      |
  2954.                  * +---+---------------------------+
  2955.                  * |  Name String (Length octets)  |
  2956.                  * +---+---------------------------+
  2957.                  * | H |     Value Length (7+)     |
  2958.                  * +---+---------------------------+
  2959.                  * | Value String (Length octets)  |
  2960.                  * +-------------------------------+
  2961.                  */

  2963.                 index = ch & ~0xf0;

  2965.                 if (index == 0x0f) {
  2966.                     ctx->index = index;
  2967.                     ctx->literal = 1;
  2968.                     state = sw_index;
  2969.                     break;
  2970.                 }

  2972.                 if (index == 0) {
  2973.                     state = sw_name_length;
  2974.                     break;
  2975.                 }

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

  2981.                 ctx->index = index;
  2982.                 ctx->literal = 1;

  2984.                 state = sw_value_length;
  2985.                 break;
  2986.             }

  2988.             /* not reached */

  2990.             return NGX_ERROR;

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

  2995.             if (ch & 0x80) {
  2996.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2997.                               "upstream sent http2 table index "
  2998.                               "with continuation flag");
  2999.                 return NGX_ERROR;
  3000.             }

  3002.             if (ctx->index > 61) {
  3003.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3004.                               "upstream sent invalid http2 "
  3005.                               "table index: %ui", ctx->index);
  3006.                 return NGX_ERROR;
  3007.             }

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

  3012.             state = sw_value_length;
  3013.             break;

  3015.         case sw_name_length:
  3016.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3017.             ctx->field_length = ch & ~0x80;

  3019.             if (ctx->field_length == 0x7f) {
  3020.                 state = sw_name_length_2;
  3021.                 break;
  3022.             }

  3024.             if (ctx->field_length == 0) {
  3025.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3026.                               "upstream sent zero http2 "
  3027.                               "header name length");
  3028.                 return NGX_ERROR;
  3029.             }

  3031.             state = sw_name;
  3032.             break;

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

  3037.             if (ch & 0x80) {
  3038.                 state = sw_name_length_3;
  3039.                 break;
  3040.             }

  3042.             state = sw_name;
  3043.             break;

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

  3048.             if (ch & 0x80) {
  3049.                 state = sw_name_length_4;
  3050.                 break;
  3051.             }

  3053.             state = sw_name;
  3054.             break;

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

  3059.             if (ch & 0x80) {
  3060.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3061.                               "upstream sent too large http2 "
  3062.                               "header name length");
  3063.                 return NGX_ERROR;
  3064.             }

  3066.             state = sw_name;
  3067.             break;

  3069.         case sw_name:
  3070.             ctx->name.len = ctx->field_huffman ?
  3071.                             ctx->field_length * 8 / 5 : ctx->field_length;

  3073.             ctx->name.data = ngx_pnalloc(r->pool, ctx->name.len + 1);
  3074.             if (ctx->name.data == NULL) {
  3075.                 return NGX_ERROR;
  3076.             }

  3078.             ctx->field_end = ctx->name.data;
  3079.             ctx->field_rest = ctx->field_length;
  3080.             ctx->field_state = 0;

  3082.             state = sw_name_bytes;

  3084.             /* fall through */

  3086.         case sw_name_bytes:

  3088.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3089.                            "http proxy name: len:%uz h:%d last:%uz, rest:%uz",
  3090.                            ctx->field_length,
  3091.                            ctx->field_huffman,
  3092.                            last - p,
  3093.                            ctx->rest - (p - b->pos));

  3095.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3096.             ctx->field_rest -= size;

  3098.             if (ctx->field_huffman) {
  3099.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3100.                                          &ctx->field_end,
  3101.                                          ctx->field_rest == 0,
  3102.                                          r->connection->log)
  3103.                     != NGX_OK)
  3104.                 {
  3105.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3106.                                   "upstream sent invalid encoded header");
  3107.                     return NGX_ERROR;
  3108.                 }

  3110.                 ctx->name.len = ctx->field_end - ctx->name.data;
  3111.                 ctx->name.data[ctx->name.len] = '\0';

  3113.             } else {
  3114.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3115.                 ctx->name.data[ctx->name.len] = '\0';
  3116.             }

  3118.             p += size - 1;

  3120.             if (ctx->field_rest == 0) {
  3121.                 state = sw_value_length;
  3122.             }

  3124.             break;

  3126.         case sw_value_length:
  3127.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3128.             ctx->field_length = ch & ~0x80;

  3130.             if (ctx->field_length == 0x7f) {
  3131.                 state = sw_value_length_2;
  3132.                 break;
  3133.             }

  3135.             if (ctx->field_length == 0) {
  3136.                 ngx_str_set(&ctx->value, "");
  3137.                 goto done;
  3138.             }

  3140.             state = sw_value;
  3141.             break;

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

  3146.             if (ch & 0x80) {
  3147.                 state = sw_value_length_3;
  3148.                 break;
  3149.             }

  3151.             state = sw_value;
  3152.             break;

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

  3157.             if (ch & 0x80) {
  3158.                 state = sw_value_length_4;
  3159.                 break;
  3160.             }

  3162.             state = sw_value;
  3163.             break;

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

  3168.             if (ch & 0x80) {
  3169.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3170.                               "upstream sent too large http2 "
  3171.                               "header value length");
  3172.                 return NGX_ERROR;
  3173.             }

  3175.             state = sw_value;
  3176.             break;

  3178.         case sw_value:
  3179.             ctx->value.len = ctx->field_huffman ?
  3180.                              ctx->field_length * 8 / 5 : ctx->field_length;

  3182.             ctx->value.data = ngx_pnalloc(r->pool, ctx->value.len + 1);
  3183.             if (ctx->value.data == NULL) {
  3184.                 return NGX_ERROR;
  3185.             }

  3187.             ctx->field_end = ctx->value.data;
  3188.             ctx->field_rest = ctx->field_length;
  3189.             ctx->field_state = 0;

  3191.             state = sw_value_bytes;

  3193.             /* fall through */

  3195.         case sw_value_bytes:

  3197.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3198.                            "http proxy value: len:%uz h:%d last:%uz, rest:%uz",
  3199.                            ctx->field_length,
  3200.                            ctx->field_huffman,
  3201.                            last - p,
  3202.                            ctx->rest - (p - b->pos));

  3204.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3205.             ctx->field_rest -= size;

  3207.             if (ctx->field_huffman) {
  3208.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3209.                                          &ctx->field_end,
  3210.                                          ctx->field_rest == 0,
  3211.                                          r->connection->log)
  3212.                     != NGX_OK)
  3213.                 {
  3214.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3215.                                   "upstream sent invalid encoded header");
  3216.                     return NGX_ERROR;
  3217.                 }

  3219.                 ctx->value.len = ctx->field_end - ctx->value.data;
  3220.                 ctx->value.data[ctx->value.len] = '\0';

  3222.             } else {
  3223.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3224.                 ctx->value.data[ctx->value.len] = '\0';
  3225.             }

  3227.             p += size - 1;

  3229.             if (ctx->field_rest == 0) {
  3230.                 goto done;
  3231.             }

  3233.             break;
  3234.         }

  3236.         continue;

  3238.     done:

  3240.         p++;
  3241.         ctx->rest -= p - b->pos;
  3242.         ctx->fragment_state = sw_start;
  3243.         b->pos = p;

  3245.         if (ctx->index) {
  3246.             ctx->name = *ngx_http_v2_get_static_name(ctx->index);
  3247.         }

  3249.         if (ctx->index && !ctx->literal) {
  3250.             ctx->value = *ngx_http_v2_get_static_value(ctx->index);
  3251.         }

  3253.         if (!ctx->index) {
  3254.             if (ngx_http_proxy_v2_validate_header_name(r, &ctx->name)
  3255.                 != NGX_OK)
  3256.             {
  3257.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3258.                               "upstream sent invalid header: \"%V: %V\"",
  3259.                               &ctx->name, &ctx->value);
  3260.                 return NGX_ERROR;
  3261.             }
  3262.         }

  3264.         if (!ctx->index || ctx->literal) {
  3265.             if (ngx_http_proxy_v2_validate_header_value(r, &ctx->value)
  3266.                 != NGX_OK)
  3267.             {
  3268.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3269.                               "upstream sent invalid header: \"%V: %V\"",
  3270.                               &ctx->name, &ctx->value);
  3271.                 return NGX_ERROR;
  3272.             }
  3273.         }

  3275.         return NGX_OK;
  3276.     }

  3278.     ctx->rest -= p - b->pos;
  3279.     ctx->fragment_state = state;
  3280.     b->pos = p;

  3282.     if (ctx->rest > ctx->padding) {
  3283.         return NGX_AGAIN;
  3284.     }

  3286.     return NGX_DONE;
  3287. }


  3290. static ngx_int_t
  3291. ‌ngx_http_proxy_v2_validate_header_name(ngx_http_request_t *r, ngx_str_t *s)
  3292. {
  3293.     u_char      ch;
  3294.     ngx_uint_t  i;

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

  3299.         if (ch == ':' && i > 0) {
  3300.             return NGX_ERROR;
  3301.         }

  3303.         if (ch >= 'A' && ch <= 'Z') {
  3304.             return NGX_ERROR;
  3305.         }

  3307.         if (ch <= 0x20 || ch == 0x7f) {
  3308.             return NGX_ERROR;
  3309.         }
  3310.     }

  3312.     return NGX_OK;
  3313. }


  3316. static ngx_int_t
  3317. ‌ngx_http_proxy_v2_validate_header_value(ngx_http_request_t *r, ngx_str_t *s)
  3318. {
  3319.     u_char      ch;
  3320.     ngx_uint_t  i;

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

  3325.         if (ch == '\0' || ch == CR || ch == LF) {
  3326.             return NGX_ERROR;
  3327.         }
  3328.     }

  3330.     return NGX_OK;
  3331. }


  3334. static ngx_int_t
  3335. ‌ngx_http_proxy_v2_parse_rst_stream(ngx_http_request_t *r,
  3336.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3337. {
  3338.     u_char  ch, *p, *last;
  3339. ‌    enum {
  3340.         sw_start = 0,
  3341.         sw_error_2,
  3342.         sw_error_3,
  3343.         sw_error_4
  3344.     } state;

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

  3349.     } else {
  3350.         last = b->pos + ctx->rest;
  3351.     }

  3353.     state = ctx->frame_state;

  3355.     if (state == sw_start) {
  3356.         if (ctx->rest != 4) {
  3357.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3358.                           "upstream sent rst stream frame "
  3359.                           "with invalid length: %uz",
  3360.                           ctx->rest);
  3361.             return NGX_ERROR;
  3362.         }
  3363.     }

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

  3368. #if 0
  3369.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3370.                        "http proxy rst byte: %02Xd s:%d", ch, state);
  3371. #endif

  3373.         switch (state) {

  3375.         case sw_start:
  3376.             ctx->error = (ngx_uint_t) ch << 24;
  3377.             state = sw_error_2;
  3378.             break;

  3380.         case sw_error_2:
  3381.             ctx->error |= ch << 16;
  3382.             state = sw_error_3;
  3383.             break;

  3385.         case sw_error_3:
  3386.             ctx->error |= ch << 8;
  3387.             state = sw_error_4;
  3388.             break;

  3390.         case sw_error_4:
  3391.             ctx->error |= ch;
  3392.             state = sw_start;

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

  3397.             break;
  3398.         }
  3399.     }

  3401.     ctx->rest -= p - b->pos;
  3402.     ctx->frame_state = state;
  3403.     b->pos = p;

  3405.     if (ctx->rest > 0) {
  3406.         return NGX_AGAIN;
  3407.     }

  3409.     ctx->state = ngx_http_proxy_v2_st_start;

  3411.     return NGX_OK;
  3412. }


  3415. static ngx_int_t
  3416. ‌ngx_http_proxy_v2_parse_goaway(ngx_http_request_t *r,
  3417.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3418. {
  3419.     u_char  ch, *p, *last;
  3420. ‌    enum {
  3421.         sw_start = 0,
  3422.         sw_last_stream_id_2,
  3423.         sw_last_stream_id_3,
  3424.         sw_last_stream_id_4,
  3425.         sw_error,
  3426.         sw_error_2,
  3427.         sw_error_3,
  3428.         sw_error_4,
  3429.         sw_debug
  3430.     } state;

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

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

  3439.     state = ctx->frame_state;

  3441.     if (state == sw_start) {

  3443.         if (ctx->stream_id) {
  3444.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3445.                           "upstream sent goaway frame "
  3446.                           "with non-zero stream id: %ui",
  3447.                           ctx->stream_id);
  3448.             return NGX_ERROR;
  3449.         }

  3451.         if (ctx->rest < 8) {
  3452.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3453.                           "upstream sent goaway frame "
  3454.                           "with invalid length: %uz",
  3455.                           ctx->rest);
  3456.             return NGX_ERROR;
  3457.         }
  3458.     }

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

  3463. #if 0
  3464.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3465.                        "http proxy goaway byte: %02Xd s:%d", ch, state);
  3466. #endif

  3468.         switch (state) {

  3470.         case sw_start:
  3471.             ctx->stream_id = (ch & 0x7f) << 24;
  3472.             state = sw_last_stream_id_2;
  3473.             break;

  3475.         case sw_last_stream_id_2:
  3476.             ctx->stream_id |= ch << 16;
  3477.             state = sw_last_stream_id_3;
  3478.             break;

  3480.         case sw_last_stream_id_3:
  3481.             ctx->stream_id |= ch << 8;
  3482.             state = sw_last_stream_id_4;
  3483.             break;

  3485.         case sw_last_stream_id_4:
  3486.             ctx->stream_id |= ch;
  3487.             state = sw_error;
  3488.             break;

  3490.         case sw_error:
  3491.             ctx->error = (ngx_uint_t) ch << 24;
  3492.             state = sw_error_2;
  3493.             break;

  3495.         case sw_error_2:
  3496.             ctx->error |= ch << 16;
  3497.             state = sw_error_3;
  3498.             break;

  3500.         case sw_error_3:
  3501.             ctx->error |= ch << 8;
  3502.             state = sw_error_4;
  3503.             break;

  3505.         case sw_error_4:
  3506.             ctx->error |= ch;
  3507.             state = sw_debug;
  3508.             break;

  3510.         case sw_debug:
  3511.             break;
  3512.         }
  3513.     }

  3515.     ctx->rest -= p - b->pos;
  3516.     ctx->frame_state = state;
  3517.     b->pos = p;

  3519.     if (ctx->rest > 0) {
  3520.         return NGX_AGAIN;
  3521.     }

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

  3527.     ctx->state = ngx_http_proxy_v2_st_start;

  3529.     return NGX_OK;
  3530. }


  3533. static ngx_int_t
  3534. ‌ngx_http_proxy_v2_parse_window_update(ngx_http_request_t *r,
  3535.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3536. {
  3537.     u_char  ch, *p, *last;
  3538. ‌    enum {
  3539.         sw_start = 0,
  3540.         sw_size_2,
  3541.         sw_size_3,
  3542.         sw_size_4
  3543.     } state;

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

  3548.     } else {
  3549.         last = b->pos + ctx->rest;
  3550.     }

  3552.     state = ctx->frame_state;

  3554.     if (state == sw_start) {
  3555.         if (ctx->rest != 4) {
  3556.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3557.                           "upstream sent window update frame "
  3558.                           "with invalid length: %uz",
  3559.                           ctx->rest);
  3560.             return NGX_ERROR;
  3561.         }
  3562.     }

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

  3567. #if 0
  3568.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3569.                        "http proxy window update byte: %02Xd s:%d", ch, state);
  3570. #endif

  3572.         switch (state) {

  3574.         case sw_start:
  3575.             ctx->window_update = (ch & 0x7f) << 24;
  3576.             state = sw_size_2;
  3577.             break;

  3579.         case sw_size_2:
  3580.             ctx->window_update |= ch << 16;
  3581.             state = sw_size_3;
  3582.             break;

  3584.         case sw_size_3:
  3585.             ctx->window_update |= ch << 8;
  3586.             state = sw_size_4;
  3587.             break;

  3589.         case sw_size_4:
  3590.             ctx->window_update |= ch;
  3591.             state = sw_start;
  3592.             break;
  3593.         }
  3594.     }

  3596.     ctx->rest -= p - b->pos;
  3597.     ctx->frame_state = state;
  3598.     b->pos = p;

  3600.     if (ctx->rest > 0) {
  3601.         return NGX_AGAIN;
  3602.     }

  3604.     ctx->state = ngx_http_proxy_v2_st_start;

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

  3609.     if (ctx->stream_id) {

  3611.         if (ctx->window_update > (size_t) NGX_HTTP_V2_MAX_WINDOW
  3612.                                  - ctx->send_window)
  3613.         {
  3614.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3615.                           "upstream sent too large window update");
  3616.             return NGX_ERROR;
  3617.         }

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

  3621.     } else {

  3623.         if (ctx->window_update > NGX_HTTP_V2_MAX_WINDOW
  3624.                                  - ctx->connection->send_window)
  3625.         {
  3626.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3627.                           "upstream sent too large window update");
  3628.             return NGX_ERROR;
  3629.         }

  3631.         ctx->connection->send_window += ctx->window_update;
  3632.     }

  3634.     return NGX_OK;
  3635. }


  3638. static ngx_int_t
  3639. ‌ngx_http_proxy_v2_parse_settings(ngx_http_request_t *r,
  3640.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3641. {
  3642.     u_char   ch, *p, *last;
  3643.     ssize_t  window_update;
  3644. ‌    enum {
  3645.         sw_start = 0,
  3646.         sw_id,
  3647.         sw_id_2,
  3648.         sw_value,
  3649.         sw_value_2,
  3650.         sw_value_3,
  3651.         sw_value_4
  3652.     } state;

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

  3657.     } else {
  3658.         last = b->pos + ctx->rest;
  3659.     }

  3661.     state = ctx->frame_state;

  3663.     if (state == sw_start) {

  3665.         if (ctx->stream_id) {
  3666.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3667.                           "upstream sent settings frame "
  3668.                           "with non-zero stream id: %ui",
  3669.                           ctx->stream_id);
  3670.             return NGX_ERROR;
  3671.         }

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

  3677.             if (ctx->rest != 0) {
  3678.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3679.                               "upstream sent settings frame "
  3680.                               "with ack flag and non-zero length: %uz",
  3681.                               ctx->rest);
  3682.                 return NGX_ERROR;
  3683.             }

  3685.             ctx->state = ngx_http_proxy_v2_st_start;

  3687.             return NGX_OK;
  3688.         }

  3690.         if (ctx->rest % 6 != 0) {
  3691.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3692.                           "upstream sent settings frame "
  3693.                           "with invalid length: %uz",
  3694.                           ctx->rest);
  3695.             return NGX_ERROR;
  3696.         }

  3698.         if (ctx->free == NULL && ctx->settings++ > 1000) {
  3699.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3700.                           "upstream sent too many settings frames");
  3701.             return NGX_ERROR;
  3702.         }
  3703.     }

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

  3708. #if 0
  3709.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3710.                        "http proxy settings byte: %02Xd s:%d", ch, state);
  3711. #endif

  3713.         switch (state) {

  3715.         case sw_start:
  3716.         case sw_id:
  3717.             ctx->setting_id = ch << 8;
  3718.             state = sw_id_2;
  3719.             break;

  3721.         case sw_id_2:
  3722.             ctx->setting_id |= ch;
  3723.             state = sw_value;
  3724.             break;

  3726.         case sw_value:
  3727.             ctx->setting_value = (ngx_uint_t) ch << 24;
  3728.             state = sw_value_2;
  3729.             break;

  3731.         case sw_value_2:
  3732.             ctx->setting_value |= ch << 16;
  3733.             state = sw_value_3;
  3734.             break;

  3736.         case sw_value_3:
  3737.             ctx->setting_value |= ch << 8;
  3738.             state = sw_value_4;
  3739.             break;

  3741.         case sw_value_4:
  3742.             ctx->setting_value |= ch;
  3743.             state = sw_id;

  3745.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3746.                            "http proxy setting: %ui %ui",
  3747.                            ctx->setting_id, ctx->setting_value);

  3749.             /*
  3750.              * The following settings are defined by the protocol:
  3751.              *
  3752.              * SETTINGS_HEADER_TABLE_SIZE, SETTINGS_ENABLE_PUSH,
  3753.              * SETTINGS_MAX_CONCURRENT_STREAMS, SETTINGS_INITIAL_WINDOW_SIZE,
  3754.              * SETTINGS_MAX_FRAME_SIZE, SETTINGS_MAX_HEADER_LIST_SIZE
  3755.              *
  3756.              * Only SETTINGS_INITIAL_WINDOW_SIZE seems to be needed in
  3757.              * a simple client.
  3758.              */

  3760.             if (ctx->setting_id == 0x04) {
  3761.                 /* SETTINGS_INITIAL_WINDOW_SIZE */

  3763.                 if (ctx->setting_value > NGX_HTTP_V2_MAX_WINDOW) {
  3764.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3765.                                   "upstream sent settings frame "
  3766.                                   "with too large initial window size: %ui",
  3767.                                   ctx->setting_value);
  3768.                     return NGX_ERROR;
  3769.                 }

  3771.                 window_update = ctx->setting_value
  3772.                                 - ctx->connection->init_window;
  3773.                 ctx->connection->init_window = ctx->setting_value;

  3775.                 if (ctx->send_window > 0
  3776.                     && window_update > (ssize_t) NGX_HTTP_V2_MAX_WINDOW
  3777.                                        - ctx->send_window)
  3778.                 {
  3779.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3780.                                   "upstream sent settings frame "
  3781.                                   "with too large initial window size: %ui",
  3782.                                   ctx->setting_value);
  3783.                     return NGX_ERROR;
  3784.                 }

  3786.                 ctx->send_window += window_update;
  3787.             }

  3789.             break;
  3790.         }
  3791.     }

  3793.     ctx->rest -= p - b->pos;
  3794.     ctx->frame_state = state;
  3795.     b->pos = p;

  3797.     if (ctx->rest > 0) {
  3798.         return NGX_AGAIN;
  3799.     }

  3801.     ctx->state = ngx_http_proxy_v2_st_start;

  3803.     return ngx_http_proxy_v2_send_settings_ack(r, ctx);
  3804. }


  3807. static ngx_int_t
  3808. ‌ngx_http_proxy_v2_parse_ping(ngx_http_request_t *r,
  3809.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3810. {
  3811.     u_char  ch, *p, *last;
  3812. ‌    enum {
  3813.         sw_start = 0,
  3814.         sw_data_2,
  3815.         sw_data_3,
  3816.         sw_data_4,
  3817.         sw_data_5,
  3818.         sw_data_6,
  3819.         sw_data_7,
  3820.         sw_data_8
  3821.     } state;

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

  3826.     } else {
  3827.         last = b->pos + ctx->rest;
  3828.     }

  3830.     state = ctx->frame_state;

  3832.     if (state == sw_start) {

  3834.         if (ctx->stream_id) {
  3835.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3836.                           "upstream sent ping frame "
  3837.                           "with non-zero stream id: %ui",
  3838.                           ctx->stream_id);
  3839.             return NGX_ERROR;
  3840.         }

  3842.         if (ctx->rest != 8) {
  3843.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3844.                           "upstream sent ping frame "
  3845.                           "with invalid length: %uz",
  3846.                           ctx->rest);
  3847.             return NGX_ERROR;
  3848.         }

  3850.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  3851.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3852.                           "upstream sent ping frame with ack flag");
  3853.             return NGX_ERROR;
  3854.         }

  3856.         if (ctx->free == NULL && ctx->pings++ > 1000) {
  3857.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3858.                           "upstream sent too many ping frames");
  3859.             return NGX_ERROR;
  3860.         }
  3861.     }

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

  3866. #if 0
  3867.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3868.                        "http proxy ping byte: %02Xd s:%d", ch, state);
  3869. #endif

  3871.         if (state < sw_data_8) {
  3872.             ctx->ping_data[state] = ch;
  3873.             state++;

  3875.         } else {
  3876.             ctx->ping_data[7] = ch;
  3877.             state = sw_start;

  3879.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3880.                            "http proxy ping");
  3881.         }
  3882.     }

  3884.     ctx->rest -= p - b->pos;
  3885.     ctx->frame_state = state;
  3886.     b->pos = p;

  3888.     if (ctx->rest > 0) {
  3889.         return NGX_AGAIN;
  3890.     }

  3892.     ctx->state = ngx_http_proxy_v2_st_start;

  3894.     return ngx_http_proxy_v2_send_ping_ack(r, ctx);
  3895. }


  3898. static ngx_int_t
  3899. ‌ngx_http_proxy_v2_send_settings_ack(ngx_http_request_t *r,
  3900.     ngx_http_proxy_v2_ctx_t *ctx)
  3901. {
  3902.     ngx_chain_t                *cl, **ll;
  3903.     ngx_http_proxy_v2_frame_t  *f;

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

  3908.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  3909.         ll = &cl->next;
  3910.     }

  3912.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  3913.     if (cl == NULL) {
  3914.         return NGX_ERROR;
  3915.     }

  3917.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  3918.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  3920.     f->length_0 = 0;
  3921.     f->length_1 = 0;
  3922.     f->length_2 = 0;
  3923.     f->type = NGX_HTTP_V2_SETTINGS_FRAME;
  3924.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  3925.     f->stream_id_0 = 0;
  3926.     f->stream_id_1 = 0;
  3927.     f->stream_id_2 = 0;
  3928.     f->stream_id_3 = 0;

  3930.     *ll = cl;

  3932.     return NGX_OK;
  3933. }


  3936. static ngx_int_t
  3937. ‌ngx_http_proxy_v2_send_ping_ack(ngx_http_request_t *r,
  3938.     ngx_http_proxy_v2_ctx_t *ctx)
  3939. {
  3940.     ngx_chain_t                *cl, **ll;
  3941.     ngx_http_proxy_v2_frame_t  *f;

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

  3946.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  3947.         ll = &cl->next;
  3948.     }

  3950.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  3951.     if (cl == NULL) {
  3952.         return NGX_ERROR;
  3953.     }

  3955.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  3956.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  3958.     f->length_0 = 0;
  3959.     f->length_1 = 0;
  3960.     f->length_2 = 8;
  3961.     f->type = NGX_HTTP_V2_PING_FRAME;
  3962.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  3963.     f->stream_id_0 = 0;
  3964.     f->stream_id_1 = 0;
  3965.     f->stream_id_2 = 0;
  3966.     f->stream_id_3 = 0;

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

  3970.     *ll = cl;

  3972.     return NGX_OK;
  3973. }


  3976. static ngx_int_t
  3977. ‌ngx_http_proxy_v2_send_window_update(ngx_http_request_t *r,
  3978.     ngx_http_proxy_v2_ctx_t *ctx)
  3979. {
  3980.     size_t                      n;
  3981.     ngx_chain_t                *cl, **ll;
  3982.     ngx_http_proxy_v2_frame_t  *f;

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

  3988.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  3989.         ll = &cl->next;
  3990.     }

  3992.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  3993.     if (cl == NULL) {
  3994.         return NGX_ERROR;
  3995.     }

  3997.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  3998.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  4000.     f->length_0 = 0;
  4001.     f->length_1 = 0;
  4002.     f->length_2 = 4;
  4003.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4004.     f->flags = 0;
  4005.     f->stream_id_0 = 0;
  4006.     f->stream_id_1 = 0;
  4007.     f->stream_id_2 = 0;
  4008.     f->stream_id_3 = 0;

  4010.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->connection->recv_window;
  4011.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4013.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4014.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4015.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4016.     *cl->buf->last++ = (u_char) (n & 0xff);

  4018.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4019.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  4021.     f->length_0 = 0;
  4022.     f->length_1 = 0;
  4023.     f->length_2 = 4;
  4024.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4025.     f->flags = 0;
  4026.     f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  4027.     f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  4028.     f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  4029.     f->stream_id_3 = (u_char) (ctx->id & 0xff);

  4031.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->recv_window;
  4032.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4034.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4035.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4036.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4037.     *cl->buf->last++ = (u_char) (n & 0xff);

  4039.     *ll = cl;

  4041.     return NGX_OK;
  4042. }


  4045. static ngx_chain_t *
  4046. ‌ngx_http_proxy_v2_get_buf(ngx_http_request_t *r, ngx_http_proxy_v2_ctx_t *ctx)
  4047. {
  4048.     u_char       *start;
  4049.     ngx_buf_t    *b;
  4050.     ngx_chain_t  *cl;

  4052.     cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  4053.     if (cl == NULL) {
  4054.         return NULL;
  4055.     }

  4057.     b = cl->buf;
  4058.     start = b->start;

  4060.     if (start == NULL) {

  4062.         /*
  4063.          * each buffer is large enough to hold two window update
  4064.          * frames in a row
  4065.          */

  4067.         start = ngx_palloc(r->pool, 2 * sizeof(ngx_http_proxy_v2_frame_t) + 8);
  4068.         if (start == NULL) {
  4069.             return NULL;
  4070.         }

  4072.     }

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

  4076.     b->start = start;
  4077.     b->pos = start;
  4078.     b->last = start;
  4079.     b->end = start + 2 * sizeof(ngx_http_proxy_v2_frame_t) + 8;

  4081.     b->tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter;
  4082.     b->temporary = 1;
  4083.     b->flush = 1;

  4085.     return cl;
  4086. }


  4089. static ngx_http_proxy_v2_ctx_t *
  4090. ‌ngx_http_proxy_v2_get_ctx(ngx_http_request_t *r)
  4091. {
  4092.     ngx_http_upstream_t      *u;
  4093.     ngx_http_proxy_v2_ctx_t  *ctx;

  4095.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  4097.     if (ctx->connection == NULL) {
  4098.         u = r->upstream;

  4100.         if (ngx_http_proxy_v2_get_connection_data(r, ctx, &u->peer) != NGX_OK) {
  4101.             return NULL;
  4102.         }
  4103.     }

  4105.     return ctx;
  4106. }


  4109. static ngx_int_t
  4110. ‌ngx_http_proxy_v2_get_connection_data(ngx_http_request_t *r,
  4111.     ngx_http_proxy_v2_ctx_t *ctx, ngx_peer_connection_t *pc)
  4112. {
  4113.     ngx_connection_t    *c;
  4114.     ngx_pool_cleanup_t  *cln;

  4116.     c = pc->connection;

  4118.     if (c == NULL) {
  4119.         ctx->connection = ngx_palloc(r->pool, sizeof(ngx_http_proxy_v2_conn_t));
  4120.         if (ctx->connection == NULL) {
  4121.             return NGX_ERROR;
  4122.         }

  4124.         ctx->id = 0;

  4126.         goto done;
  4127.     }

  4129.     if (pc->cached) {

  4131.         /*
  4132.          * for cached connections, connection data can be found
  4133.          * in the cleanup handler
  4134.          */

  4136.         for (cln = c->pool->cleanup; cln; cln = cln->next) {
  4137.             if (cln->handler == ngx_http_proxy_v2_cleanup) {
  4138.                 ctx->connection = cln->data;
  4139.                 break;
  4140.             }
  4141.         }

  4143.         if (ctx->connection == NULL) {
  4144.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  4145.                           "no connection data found for "
  4146.                           "keepalive http2 connection");
  4147.             return NGX_ERROR;
  4148.         }

  4150.         ctx->send_window = ctx->connection->init_window;
  4151.         ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4153.         ctx->connection->last_stream_id += 2;
  4154.         ctx->id = ctx->connection->last_stream_id;

  4156.         return NGX_OK;
  4157.     }

  4159.     cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_proxy_v2_conn_t));
  4160.     if (cln == NULL) {
  4161.         return NGX_ERROR;
  4162.     }

  4164.     cln->handler = ngx_http_proxy_v2_cleanup;
  4165.     ctx->connection = cln->data;

  4167.     ctx->id = 1;

  4169. done:

  4171.     ctx->connection->init_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4172.     ctx->connection->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4173.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4175.     ctx->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4176.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

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

  4180.     return NGX_OK;
  4181. }


  4184. static void
  4185. ‌ngx_http_proxy_v2_cleanup(void *data)
  4186. {
  4187. #if 0
  4188.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  4189.                    "http proxy cleanup");
  4190. #endif
  4191.     return;
  4192. }


  4195. static void
  4196. ‌ngx_http_proxy_v2_abort_request(ngx_http_request_t *r)
  4197. {
  4198.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4199.                    "abort proxy http2 request");
  4200.     return;
  4201. }


  4204. static void
  4205. ‌ngx_http_proxy_v2_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  4206. {
  4207.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4208.                    "finalize proxy http2 request");
  4209.     return;
  4210. }

One Level Up Top Level