One Level Up Top Level

src/http/modules/ngx_http_proxy_v2_module.c - nginx

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.         len += 1 + NGX_HTTP_V2_INT_OCTETS + method.len;
  383.         tmp_len = method.len;
  384.     }

  386.     /* :scheme header */

  388.     len += 1;

  390.     /* :path header */

  392.     escape = 0;
  393.     loc_len = 0;
  394.     unparsed_uri = 0;

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

  399.     } else if (ctx->ctx.vars.uri.len == 0 && r->valid_unparsed_uri) {
  400.         unparsed_uri = 1;
  401.         uri_len = r->unparsed_uri.len;

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

  407.         if (r->quoted_uri || r->internal) {
  408.             escape = 2 * ngx_escape_uri(NULL, r->uri.data + loc_len,
  409.                                         r->uri.len - loc_len, NGX_ESCAPE_URI);
  410.         }

  412.         uri_len = ctx->ctx.vars.uri.len + r->uri.len - loc_len + escape
  413.                   + sizeof("?") - 1 + r->args.len;
  414.     }

  416.     if (uri_len == 0) {
  417.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  418.                       "zero length URI to proxy");
  419.         return NGX_ERROR;
  420.     }

  422.     len += 1 + NGX_HTTP_V2_INT_OCTETS + uri_len;

  424.     if (tmp_len < uri_len) {
  425.         tmp_len = uri_len;
  426.     }

  428.     /* :authority header */

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

  432.     if (!plcf->host_set) {
  433.         len += 1 + NGX_HTTP_V2_INT_OCTETS + host->len;

  435.         if (tmp_len < host->len) {
  436.             tmp_len = host->len;
  437.         }
  438.     }

  440.     /* other headers */

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

  444.     ngx_http_script_flush_no_cacheable_variables(r, plcf->body_flushes);
  445.     ngx_http_script_flush_no_cacheable_variables(r, headers->flushes);

  447.     body_len = 0;

  449.     if (plcf->body_lengths) {
  450.         le.ip = plcf->body_lengths->elts;
  451.         le.request = r;
  452.         le.flushed = 1;

  454.         while (*(uintptr_t *) le.ip) {
  455.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  456.             body_len += lcode(&le);
  457.         }

  459.         ctx->ctx.internal_body_length = body_len;

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

  464.     } else {
  465.         ctx->ctx.internal_body_length = r->headers_in.content_length_n;
  466.     }

  468.     le.ip = headers->lengths->elts;
  469.     le.request = r;
  470.     le.flushed = 1;

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

  474.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  475.         key_len = lcode(&le);

  477.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  478.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  479.         }
  480.         le.ip += sizeof(uintptr_t);

  482.         if (val_len == 0) {
  483.             continue;
  484.         }

  486.         len += 1 + NGX_HTTP_V2_INT_OCTETS + key_len
  487.                  + NGX_HTTP_V2_INT_OCTETS + val_len;

  489.         if (tmp_len < key_len) {
  490.             tmp_len = key_len;
  491.         }

  493.         if (tmp_len < val_len) {
  494.             tmp_len = val_len;
  495.         }
  496.     }

  498.     if (plcf->upstream.pass_request_headers) {
  499.         part = &r->headers_in.headers.part;
  500.         header = part->elts;

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

  504.             if (i >= part->nelts) {
  505.                 if (part->next == NULL) {
  506.                     break;
  507.                 }

  509.                 part = part->next;
  510.                 header = part->elts;
  511.                 i = 0;
  512.             }

  514.             if (ngx_hash_find(&headers->hash, header[i].hash,
  515.                               header[i].lowcase_key, header[i].key.len))
  516.             {
  517.                 continue;
  518.             }

  520.             len += 1 + NGX_HTTP_V2_INT_OCTETS + header[i].key.len
  521.                      + NGX_HTTP_V2_INT_OCTETS + header[i].value.len;

  523.             if (tmp_len < header[i].key.len) {
  524.                 tmp_len = header[i].key.len;
  525.             }

  527.             if (tmp_len < header[i].value.len) {
  528.                 tmp_len = header[i].value.len;
  529.             }
  530.         }
  531.     }

  533.     /* continuation frames */

  535.     len += sizeof(ngx_http_proxy_v2_frame_t)
  536.            * (len / NGX_HTTP_V2_DEFAULT_FRAME_SIZE);


  539.     b = ngx_create_temp_buf(r->pool, len);
  540.     if (b == NULL) {
  541.         return NGX_ERROR;
  542.     }

  544.     cl = ngx_alloc_chain_link(r->pool);
  545.     if (cl == NULL) {
  546.         return NGX_ERROR;
  547.     }

  549.     cl->buf = b;
  550.     cl->next = NULL;

  552.     tmp = ngx_palloc(r->pool, tmp_len * 3);
  553.     if (tmp == NULL) {
  554.         return NGX_ERROR;
  555.     }

  557.     key_tmp = tmp + tmp_len;
  558.     val_tmp = tmp + 2 * tmp_len;

  560.     /* connection preface */

  562.     b->last = ngx_copy(b->last, ngx_http_proxy_v2_connection_start,
  563.                        sizeof(ngx_http_proxy_v2_connection_start) - 1);

  565.     /* headers frame */

  567.     headers_frame = b->last;

  569.     f = (ngx_http_proxy_v2_frame_t *) b->last;
  570.     b->last += sizeof(ngx_http_proxy_v2_frame_t);

  572.     f->length_0 = 0;
  573.     f->length_1 = 0;
  574.     f->length_2 = 0;
  575.     f->type = NGX_HTTP_V2_HEADERS_FRAME;
  576.     f->flags = 0;
  577.     f->stream_id_0 = 0;
  578.     f->stream_id_1 = 0;
  579.     f->stream_id_2 = 0;
  580.     f->stream_id_3 = 1;

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

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

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

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

  594.     } else {
  595.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_METHOD_INDEX);
  596.         b->last = ngx_http_v2_write_value(b->last, method.data,
  597.                                           method.len, tmp);

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

  603. #if (NGX_HTTP_SSL)
  604.     if (u->ssl) {
  605.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTPS_INDEX);

  607.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  608.                        "http proxy header: \":scheme: https\"");
  609.     } else
  610. #endif
  611.     {
  612.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTP_INDEX);

  614.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  615.                        "http proxy header: \":scheme: http\"");
  616.     }

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

  620.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  621.         b->last = ngx_http_v2_write_value(b->last, ctx->ctx.vars.uri.data,
  622.                                           ctx->ctx.vars.uri.len, tmp);

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

  627.     } else if (unparsed_uri) {

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

  632.         } else {
  633.             *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  634.             b->last = ngx_http_v2_write_value(b->last, r->unparsed_uri.data,
  635.                                               r->unparsed_uri.len, tmp);
  636.         }

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

  641.     } else {
  642.         p = val_tmp;

  644.         if (r->valid_location) {
  645.             p = ngx_copy(p, ctx->ctx.vars.uri.data, ctx->ctx.vars.uri.len);
  646.         }

  648.         if (escape) {
  649.             ngx_escape_uri(p, r->uri.data + loc_len,
  650.                            r->uri.len - loc_len, NGX_ESCAPE_URI);
  651.             p += r->uri.len - loc_len + escape;

  653.         } else {
  654.             p = ngx_copy(p, r->uri.data + loc_len, r->uri.len - loc_len);
  655.         }

  657.         if (r->args.len > 0) {
  658.             *p++ = '?';
  659.             p = ngx_copy(p, r->args.data, r->args.len);
  660.         }

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

  665.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  666.                        "http proxy header: \":path: %*s\"", p - val_tmp,
  667.                        val_tmp);
  668.     }

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

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

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

  680.     e.ip = headers->values->elts;
  681.     e.request = r;
  682.     e.flushed = 1;

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

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

  688.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  689.         key_len = lcode(&le);

  691.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  692.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  693.         }
  694.         le.ip += sizeof(uintptr_t);

  696.         if (val_len == 0) {
  697.             e.skip = 1;

  699.             while (*(uintptr_t *) e.ip) {
  700.                 code = *(ngx_http_script_code_pt *) e.ip;
  701.                 code((ngx_http_script_engine_t *) &e);
  702.             }
  703.             e.ip += sizeof(uintptr_t);

  705.             e.skip = 0;

  707.             continue;
  708.         }

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

  712.         e.pos = key_tmp;

  714.         code = *(ngx_http_script_code_pt *) e.ip;
  715.         code((ngx_http_script_engine_t *) &e);

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

  719.         e.pos = val_tmp;

  721.         while (*(uintptr_t *) e.ip) {
  722.             code = *(ngx_http_script_code_pt *) e.ip;
  723.             code((ngx_http_script_engine_t *) &e);
  724.         }
  725.         e.ip += sizeof(uintptr_t);

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

  729. #if (NGX_DEBUG)
  730.         if (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP) {
  731.             ngx_strlow(key_tmp, key_tmp, key_len);

  733.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  734.                            "http proxy header: \"%*s: %*s\"",
  735.                            key_len, key_tmp, val_len, val_tmp);
  736.         }
  737. #endif
  738.     }

  740.     if (plcf->upstream.pass_request_headers) {
  741.         part = &r->headers_in.headers.part;
  742.         header = part->elts;

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

  746.             if (i >= part->nelts) {
  747.                 if (part->next == NULL) {
  748.                     break;
  749.                 }

  751.                 part = part->next;
  752.                 header = part->elts;
  753.                 i = 0;
  754.             }

  756.             if (ngx_hash_find(&headers->hash, header[i].hash,
  757.                               header[i].lowcase_key, header[i].key.len))
  758.             {
  759.                 continue;
  760.             }

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

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

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

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

  774.                 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  775.                                "http proxy header: \"%*s: %V\"",
  776.                                header[i].key.len, tmp, &header[i].value);
  777.             }
  778. #endif
  779.         }
  780.     }

  782.     /* update headers frame length */

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

  786.     if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  787.         len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  788.         next = 1;

  790.     } else {
  791.         next = 0;
  792.     }

  794.     f = (ngx_http_proxy_v2_frame_t *) headers_frame;

  796.     f->length_0 = (u_char) ((len >> 16) & 0xff);
  797.     f->length_1 = (u_char) ((len >> 8) & 0xff);
  798.     f->length_2 = (u_char) (len & 0xff);

  800.     /* create additional continuation frames */

  802.     p = headers_frame;

  804.     while (next) {
  805.         p += sizeof(ngx_http_proxy_v2_frame_t) + NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  806.         len = b->last - p;

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

  811.         if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  812.             len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  813.             next = 1;

  815.         } else {
  816.             next = 0;
  817.         }

  819.         f = (ngx_http_proxy_v2_frame_t *) p;

  821.         f->length_0 = (u_char) ((len >> 16) & 0xff);
  822.         f->length_1 = (u_char) ((len >> 8) & 0xff);
  823.         f->length_2 = (u_char) (len & 0xff);
  824.         f->type = NGX_HTTP_V2_CONTINUATION_FRAME;
  825.         f->flags = 0;
  826.         f->stream_id_0 = 0;
  827.         f->stream_id_1 = 0;
  828.         f->stream_id_2 = 0;
  829.         f->stream_id_3 = 1;
  830.     }

  832.     f->flags |= NGX_HTTP_V2_END_HEADERS_FLAG;

  834.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  835.                    "http proxy header: %*xs%s, len: %uz",
  836.                    (size_t) ngx_min(b->last - b->pos, 256), b->pos,
  837.                    b->last - b->pos > 256 ? "..." : "",
  838.                    b->last - b->pos);

  840.     if (r->request_body_no_buffering) {

  842.         u->request_bufs = cl;

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

  846.         body = u->request_bufs;
  847.         u->request_bufs = cl;

  849.         if (body == NULL) {
  850.             f = (ngx_http_proxy_v2_frame_t *) headers_frame;
  851.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;
  852.         }

  854.         while (body) {
  855.             b = ngx_alloc_buf(r->pool);
  856.             if (b == NULL) {
  857.                 return NGX_ERROR;
  858.             }

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

  862.             cl->next = ngx_alloc_chain_link(r->pool);
  863.             if (cl->next == NULL) {
  864.                 return NGX_ERROR;
  865.             }

  867.             cl = cl->next;
  868.             cl->buf = b;

  870.             body = body->next;
  871.         }

  873.         b->last_buf = 1;

  875.     } else if (body_len) {

  877.         u->request_bufs = cl;

  879.         b = ngx_create_temp_buf(r->pool, body_len);
  880.         if (b == NULL) {
  881.             return NGX_ERROR;
  882.         }

  884.         cl->next = ngx_alloc_chain_link(r->pool);
  885.         if (cl->next == NULL) {
  886.             return NGX_ERROR;
  887.         }

  889.         cl = cl->next;
  890.         cl->buf = b;

  892.         e.ip = plcf->body_values->elts;
  893.         e.pos = b->last;
  894.         e.request = r;
  895.         e.flushed = 1;
  896.         e.skip = 0;

  898.         while (*(uintptr_t *) e.ip) {
  899.             code = *(ngx_http_script_code_pt *) e.ip;
  900.             code((ngx_http_script_engine_t *) &e);
  901.         }

  903.         b->last = e.pos;
  904.         b->last_buf = 1;

  906.     } else {
  907.         u->request_bufs = cl;

  909.         f = (ngx_http_proxy_v2_frame_t *) headers_frame;
  910.         f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  912.         b->last_buf = 1;
  913.     }

  915.     u->output.output_filter = ngx_http_proxy_v2_body_output_filter;
  916.     u->output.filter_ctx = r;

  918.     b->flush = 1;
  919.     cl->next = NULL;

  921.     return NGX_OK;
  922. }


  925. static ngx_int_t
  926. ‌ngx_http_proxy_v2_reinit_request(ngx_http_request_t *r)
  927. {
  928.     ngx_http_proxy_v2_ctx_t  *ctx;

  930.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  932.     if (ctx == NULL) {
  933.         return NGX_OK;
  934.     }

  936.     ctx->state = 0;
  937.     ctx->header_sent = 0;
  938.     ctx->output_closed = 0;
  939.     ctx->output_blocked = 0;
  940.     ctx->parsing_headers = 0;
  941.     ctx->end_stream = 0;
  942.     ctx->done = 0;
  943.     ctx->status = 0;
  944.     ctx->rst = 0;
  945.     ctx->goaway = 0;
  946.     ctx->connection = NULL;
  947.     ctx->in = NULL;
  948.     ctx->busy = NULL;
  949.     ctx->out = NULL;

  951.     return NGX_OK;
  952. }


  955. static ngx_int_t
  956. ‌ngx_http_proxy_v2_body_output_filter(void *data, ngx_chain_t *in)
  957. {
  958.     ngx_http_request_t  *r = data;

  960.     off_t                       file_pos;
  961.     u_char                     *p, *pos, *start;
  962.     size_t                      len, limit;
  963.     ngx_buf_t                  *b;
  964.     ngx_int_t                  rc;
  965.     ngx_uint_t                 next, last;
  966.     ngx_chain_t                *cl, *out, *ln, **ll;
  967.     ngx_http_upstream_t        *u;
  968.     ngx_http_proxy_v2_ctx_t    *ctx;
  969.     ngx_http_proxy_v2_frame_t  *f;

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

  974.     ctx = ngx_http_proxy_v2_get_ctx(r);

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

  980.     if (in) {
  981.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  982.             return NGX_ERROR;
  983.         }
  984.     }

  986.     out = NULL;
  987.     ll = &out;

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

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

  995.         ctx->header_sent = 1;

  997.         if (ctx->id != 1) {
  998.             /*
  999.              * keepalive connection: skip connection preface,
  1000.              * update stream identifiers
  1001.              */

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

  1006.             p = b->pos;

  1008.             while (p < b->last) {
  1009.                 f = (ngx_http_proxy_v2_frame_t *) p;
  1010.                 p += sizeof(ngx_http_proxy_v2_frame_t);

  1012.                 f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1013.                 f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1014.                 f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1015.                 f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1017.                 p += (f->length_0 << 16) + (f->length_1 << 8) + f->length_2;
  1018.             }
  1019.         }

  1021.         if (ctx->in->buf->last_buf) {
  1022.             ctx->output_closed = 1;
  1023.         }

  1025.         *ll = ctx->in;
  1026.         ll = &ctx->in->next;

  1028.         ctx->in = ctx->in->next;
  1029.     }

  1031.     if (ctx->out) {
  1032.         /* queued control frames */

  1034.         *ll = ctx->out;

  1036.         for (cl = ctx->out, ll = &cl->next; cl; cl = cl->next) {
  1037.             ll = &cl->next;
  1038.         }

  1040.         ctx->out = NULL;
  1041.     }

  1043.     f = NULL;
  1044.     last = 0;

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

  1048.     if (limit > ctx->connection->send_window) {
  1049.         limit = ctx->connection->send_window;
  1050.     }

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

  1056. #if (NGX_SUPPRESS_WARN)
  1057.     file_pos = 0;
  1058.     pos = NULL;
  1059.     cl = NULL;
  1060. #endif

  1062.     in = ctx->in;

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

  1066.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1067.                        "http proxy output in  l:%d f:%d %p, pos %p, size: %z "
  1068.                        "file: %O, size: %O",
  1069.                        in->buf->last_buf,
  1070.                        in->buf->in_file,
  1071.                        in->buf->start, in->buf->pos,
  1072.                        in->buf->last - in->buf->pos,
  1073.                        in->buf->file_pos,
  1074.                        in->buf->file_last - in->buf->file_pos);

  1076.         if (ngx_buf_special(in->buf)) {
  1077.             goto next;
  1078.         }

  1080.         if (in->buf->in_file) {
  1081.             file_pos = in->buf->file_pos;

  1083.         } else {
  1084.             pos = in->buf->pos;
  1085.         }

  1087.         next = 0;

  1089.         do {

  1091.             cl = ngx_http_proxy_v2_get_buf(r, ctx);
  1092.             if (cl == NULL) {
  1093.                 return NGX_ERROR;
  1094.             }

  1096.             b = cl->buf;

  1098.             f = (ngx_http_proxy_v2_frame_t *) b->last;
  1099.             b->last += sizeof(ngx_http_proxy_v2_frame_t);

  1101.             *ll = cl;
  1102.             ll = &cl->next;

  1104.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  1105.             if (cl == NULL) {
  1106.                 return NGX_ERROR;
  1107.             }

  1109.             b = cl->buf;
  1110.             start = b->start;

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

  1114.             /*
  1115.              * restore b->start to preserve memory allocated in the buffer,
  1116.              * to reuse it later for headers and control frames
  1117.              */

  1119.             b->start = start;

  1121.             if (in->buf->in_file) {
  1122.                 b->file_pos = file_pos;
  1123.                 file_pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1125.                 if (file_pos >= in->buf->file_last) {
  1126.                     file_pos = in->buf->file_last;
  1127.                     next = 1;
  1128.                 }

  1130.                 b->file_last = file_pos;
  1131.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1133.             } else {
  1134.                 b->pos = pos;
  1135.                 pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1137.                 if (pos >= in->buf->last) {
  1138.                     pos = in->buf->last;
  1139.                     next = 1;
  1140.                 }

  1142.                 b->last = pos;
  1143.                 len = (ngx_uint_t) (pos - b->pos);
  1144.             }

  1146.             b->tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter;
  1147.             b->shadow = in->buf;
  1148.             b->last_shadow = next;

  1150.             b->last_buf = 0;
  1151.             b->last_in_chain = 0;

  1153.             *ll = cl;
  1154.             ll = &cl->next;

  1156.             f->length_0 = (u_char) ((len >> 16) & 0xff);
  1157.             f->length_1 = (u_char) ((len >> 8) & 0xff);
  1158.             f->length_2 = (u_char) (len & 0xff);
  1159.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1160.             f->flags = 0;
  1161.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1162.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1163.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1164.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1166.             limit -= len;
  1167.             ctx->send_window -= len;
  1168.             ctx->connection->send_window -= len;

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

  1172.         if (!next) {
  1173.             /*
  1174.              * if the buffer wasn't fully sent due to flow control limits,
  1175.              * preserve position for future use
  1176.              */

  1178.             if (in->buf->in_file) {
  1179.                 in->buf->file_pos = file_pos;

  1181.             } else {
  1182.                 in->buf->pos = pos;
  1183.             }

  1185.             break;
  1186.         }

  1188.     next:

  1190.         if (in->buf->last_buf) {
  1191.             last = 1;
  1192.         }

  1194.         ln = in;
  1195.         in = in->next;

  1197.         ngx_free_chain(r->pool, ln);
  1198.     }

  1200.     ctx->in = in;

  1202.     if (last) {

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

  1207.         ctx->output_closed = 1;

  1209.         if (f) {
  1210.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1212.         } else {
  1213.             cl = ngx_http_proxy_v2_get_buf(r, ctx);
  1214.             if (cl == NULL) {
  1215.                 return NGX_ERROR;
  1216.             }

  1218.             b = cl->buf;

  1220.             f = (ngx_http_proxy_v2_frame_t *) b->last;
  1221.             b->last += sizeof(ngx_http_proxy_v2_frame_t);

  1223.             f->length_0 = 0;
  1224.             f->length_1 = 0;
  1225.             f->length_2 = 0;
  1226.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1227.             f->flags = NGX_HTTP_V2_END_STREAM_FLAG;
  1228.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1229.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1230.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1231.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1233.             *ll = cl;
  1234.             ll = &cl->next;
  1235.         }

  1237.         cl->buf->last_buf = 1;
  1238.     }

  1240.     *ll = NULL;

  1242. #if (NGX_DEBUG)

  1244.     for (cl = out; cl; cl = cl->next) {
  1245.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1246.                        "http proxy output out l:%d f:%d %p, pos %p, size: %z "
  1247.                        "file: %O, size: %O",
  1248.                        cl->buf->last_buf,
  1249.                        cl->buf->in_file,
  1250.                        cl->buf->start, cl->buf->pos,
  1251.                        cl->buf->last - cl->buf->pos,
  1252.                        cl->buf->file_pos,
  1253.                        cl->buf->file_last - cl->buf->file_pos);
  1254.     }

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

  1260. #endif

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

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

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

  1269.         /* mark original buffers as sent */

  1271.         if (cl->buf->shadow) {
  1272.             if (cl->buf->last_shadow) {
  1273.                 b = cl->buf->shadow;
  1274.                 b->pos = b->last;
  1275.             }

  1277.             cl->buf->shadow = NULL;
  1278.         }
  1279.     }

  1281.     if (rc == NGX_OK && ctx->in) {
  1282.         rc = NGX_AGAIN;
  1283.     }

  1285.     if (rc == NGX_AGAIN) {
  1286.         ctx->output_blocked = 1;

  1288.     } else {
  1289.         ctx->output_blocked = 0;
  1290.     }

  1292.     if (ctx->done) {

  1294.         /*
  1295.          * We have already got the response and were sending some additional
  1296.          * control frames.  Even if there is still something unsent, stop
  1297.          * here anyway.
  1298.          */

  1300.         u = r->upstream;
  1301.         u->length = 0;
  1302.         u->pipe->length = 0;

  1304.         if (ctx->in == NULL
  1305.             && ctx->out == NULL
  1306.             && ctx->output_closed
  1307.             && !ctx->output_blocked
  1308.             && !ctx->goaway
  1309.             && ctx->state == ngx_http_proxy_v2_st_start)
  1310.         {
  1311.             u->keepalive = 1;
  1312.         }

  1314.         ngx_post_event(u->peer.connection->read, &ngx_posted_events);
  1315.     }

  1317.     return rc;
  1318. }


  1321. static ngx_int_t
  1322. ‌ngx_http_proxy_v2_process_header(ngx_http_request_t *r)
  1323. {
  1324.     u_char                         *pos;
  1325.     ngx_str_t                      *status_line;
  1326.     ngx_int_t                       rc, status;
  1327.     ngx_buf_t                      *b;
  1328.     ngx_table_elt_t                *h;
  1329.     ngx_http_upstream_t            *u;
  1330.     ngx_http_proxy_v2_ctx_t        *ctx;
  1331.     ngx_http_upstream_header_t     *hh;
  1332.     ngx_http_upstream_main_conf_t  *umcf;

  1334.     u = r->upstream;
  1335.     b = &u->buffer;
  1336.     pos = b->pos;

  1338.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1339.                    "http proxy response: %*xs%s, len: %uz",
  1340.                    (size_t) ngx_min(b->last - b->pos, 256),
  1341.                    b->pos, b->last - b->pos > 256 ? "..." : "",
  1342.                    b->last - b->pos);

  1344.     ctx = ngx_http_proxy_v2_get_ctx(r);

  1346.     if (ctx == NULL) {
  1347.         return NGX_ERROR;
  1348.     }

  1350.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1352.     for ( ;; ) {

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

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

  1358.             if (rc == NGX_AGAIN) {

  1360.                 /*
  1361.                  * there can be a lot of window update frames,
  1362.                  * so we reset buffer if it is empty and we haven't
  1363.                  * started parsing headers yet
  1364.                  */

  1366.                 if (!ctx->parsing_headers) {
  1367.                     b->pos = pos;
  1368.                     b->last = b->pos;
  1369.                 }

  1371.                 return NGX_AGAIN;
  1372.             }

  1374.             if (rc == NGX_ERROR) {
  1375.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1376.             }

  1378.             /*
  1379.              * RFC 7540 says that implementations MUST discard frames
  1380.              * that have unknown or unsupported types.  However, extension
  1381.              * frames that appear in the middle of a header block are
  1382.              * not permitted.  Also, for obvious reasons CONTINUATION frames
  1383.              * cannot appear before headers, and DATA frames are not expected
  1384.              * to appear before all headers are parsed.
  1385.              */

  1387.             if (ctx->type == NGX_HTTP_V2_DATA_FRAME
  1388.                 || (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  1389.                     && !ctx->parsing_headers)
  1390.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  1391.                     && ctx->parsing_headers))
  1392.             {
  1393.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1394.                               "upstream sent unexpected http2 frame: %d",
  1395.                               ctx->type);
  1396.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1397.             }

  1399.             if (ctx->id && ctx->stream_id && ctx->stream_id != ctx->id) {
  1400.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1401.                               "upstream sent frame for unknown stream %ui",
  1402.                               ctx->stream_id);
  1403.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1404.             }
  1405.         }

  1407.         /* frame payload */

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

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

  1414.                 if (rc == NGX_AGAIN) {
  1415.                     return NGX_AGAIN;
  1416.                 }

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

  1422.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1423.                               "upstream rejected request with error %ui",
  1424.                               ctx->error);

  1426.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1427.             }

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

  1431.             if (rc == NGX_AGAIN) {
  1432.                 return NGX_AGAIN;
  1433.             }

  1435.             if (rc == NGX_ERROR) {
  1436.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1437.             }

  1439.             if (rc == NGX_OK) {
  1440.                 continue;
  1441.             }
  1442.         }

  1444.         if (ctx->type != NGX_HTTP_V2_HEADERS_FRAME
  1445.             && ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME)
  1446.         {
  1447.             /* priority, unknown frames */

  1449.             rc = ngx_http_proxy_v2_skip_frame(ctx, b);

  1451.             if (rc == NGX_AGAIN) {
  1452.                 return NGX_AGAIN;
  1453.             }

  1455.             continue;
  1456.         }

  1458.         /* headers */

  1460.         for ( ;; ) {

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

  1464.             if (rc == NGX_AGAIN) {
  1465.                 break;
  1466.             }

  1468.             if (rc == NGX_OK) {

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

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

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

  1478.                     if (ctx->name.len != sizeof(":status") - 1
  1479.                         || ngx_strncmp(ctx->name.data, ":status",
  1480.                                        sizeof(":status") - 1)
  1481.                            != 0)
  1482.                     {
  1483.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1484.                                       "upstream sent invalid header \"%V: %V\"",
  1485.                                       &ctx->name, &ctx->value);
  1486.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1487.                     }

  1489.                     if (ctx->status) {
  1490.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1491.                                       "upstream sent duplicate :status header");
  1492.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1493.                     }

  1495.                     status_line = &ctx->value;

  1497.                     if (status_line->len != 3) {
  1498.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1499.                                       "upstream sent invalid :status \"%V\"",
  1500.                                       status_line);
  1501.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1502.                     }

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

  1506.                     if (status == NGX_ERROR) {
  1507.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1508.                                       "upstream sent invalid :status \"%V\"",
  1509.                                       status_line);
  1510.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1511.                     }

  1513.                     if (status < NGX_HTTP_OK && status != NGX_HTTP_EARLY_HINTS)
  1514.                     {
  1515.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1516.                                       "upstream sent unexpected :status \"%V\"",
  1517.                                       status_line);
  1518.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1519.                     }

  1521.                     u->headers_in.status_n = status;

  1523.                     if (u->state && u->state->status == 0) {
  1524.                         u->state->status = status;
  1525.                     }

  1527.                     ctx->status = 1;

  1529.                     continue;

  1531.                 } else if (!ctx->status) {
  1532.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1533.                                   "upstream sent no :status header");
  1534.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1535.                 }

  1537.                 h = ngx_list_push(&u->headers_in.headers);
  1538.                 if (h == NULL) {
  1539.                     return NGX_ERROR;
  1540.                 }

  1542.                 h->key = ctx->name;
  1543.                 h->value = ctx->value;
  1544.                 h->lowcase_key = h->key.data;
  1545.                 h->hash = ngx_hash_key(h->key.data, h->key.len);

  1547.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1548.                     continue;
  1549.                 }

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

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

  1557.                     if (rc != NGX_OK) {
  1558.                         return rc;
  1559.                     }
  1560.                 }

  1562.                 continue;
  1563.             }

  1565.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1572.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1573.                     if (ctx->end_stream) {
  1574.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1575.                                       "upstream prematurely closed stream");
  1576.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1577.                     }

  1579.                     ctx->status = 0;
  1580.                     return NGX_HTTP_UPSTREAM_EARLY_HINTS;
  1581.                 }

  1583.                 if (ctx->end_stream
  1584.                     && ctx->in == NULL
  1585.                     && ctx->out == NULL
  1586.                     && ctx->output_closed
  1587.                     && !ctx->output_blocked
  1588.                     && !ctx->goaway
  1589.                     && b->last == b->pos)
  1590.                 {
  1591.                     u->keepalive = 1;
  1592.                 }

  1594.                 return NGX_OK;
  1595.             }

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

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

  1602.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1603.         }

  1605.         /* rc == NGX_AGAIN */

  1607.         if (ctx->rest == 0) {
  1608.             ctx->state = ngx_http_proxy_v2_st_start;
  1609.             continue;
  1610.         }

  1612.         return NGX_AGAIN;
  1613.     }
  1614. }


  1617. static ngx_int_t
  1618. ‌ngx_http_proxy_v2_filter_init(void *data)
  1619. {
  1620.     ngx_http_request_t       *r = data;
  1621.     ngx_http_upstream_t      *u;
  1622.     ngx_http_proxy_v2_ctx_t  *ctx;

  1624.     u = r->upstream;
  1625.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1627.     if (ctx == NULL) {
  1628.         return NGX_ERROR;
  1629.     }

  1631.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1632.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED
  1633.         || ctx->ctx.head)
  1634.     {
  1635.         ctx->length = 0;

  1637.     } else {
  1638.         ctx->length = u->headers_in.content_length_n;
  1639.     }

  1641.     if (ctx->end_stream) {

  1643.         if (ctx->length > 0) {
  1644.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1645.                           "upstream prematurely closed stream");
  1646.             return NGX_ERROR;
  1647.         }

  1649.         u->length = 0;
  1650.         u->pipe->length = 0;
  1651.         ctx->done = 1;

  1653.     } else {
  1654.         u->length = 1;
  1655.         u->pipe->length = 1;
  1656.     }

  1658.     return NGX_OK;
  1659. }


  1662. static ngx_int_t
  1663. ‌ngx_http_proxy_v2_non_buffered_filter(void *data, ssize_t bytes)
  1664. {
  1665.     ngx_http_request_t   *r = data;

  1667.     ngx_int_t                 rc;
  1668.     ngx_buf_t                *b, *buf;
  1669.     ngx_chain_t              *cl, **ll;
  1670.     ngx_http_upstream_t      *u;
  1671.     ngx_http_proxy_v2_ctx_t  *ctx;

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

  1676.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1678.     if (ctx == NULL) {
  1679.         return NGX_ERROR;
  1680.     }

  1682.     u = r->upstream;
  1683.     b = &u->buffer;

  1685.     b->pos = b->last;
  1686.     b->last += bytes;

  1688.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  1689.         ll = &cl->next;
  1690.     }

  1692.     for ( ;; ) {

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

  1696.         if (rc == NGX_OK) {

  1698.             cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  1699.             if (cl == NULL) {
  1700.                 return NGX_ERROR;
  1701.             }

  1703.             *ll = cl;
  1704.             ll = &cl->next;

  1706.             buf = cl->buf;

  1708.             buf->flush = 1;
  1709.             buf->memory = 1;

  1711.             buf->pos = b->pos;
  1712.             buf->tag = u->output.tag;

  1714.             if (b->last - b->pos >= (ssize_t) ctx->rest - ctx->padding) {
  1715.                 b->pos += ctx->rest - ctx->padding;
  1716.                 buf->last = b->pos;
  1717.                 ctx->rest = ctx->padding;

  1719.             } else {
  1720.                 ctx->rest -= b->last - b->pos;
  1721.                 b->pos = b->last;
  1722.                 buf->last = b->pos;
  1723.             }

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

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

  1730.                 if (buf->last - buf->pos > ctx->length) {
  1731.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1732.                                   "upstream sent response body larger "
  1733.                                   "than indicated content length");
  1734.                     return NGX_ERROR;
  1735.                 }

  1737.                 ctx->length -= buf->last - buf->pos;
  1738.             }

  1740.             continue;
  1741.         }

  1743.         if (rc == NGX_DONE) {
  1744.             u->length = 0;
  1745.             break;
  1746.         }

  1748.         if (rc == NGX_AGAIN) {
  1749.             return NGX_AGAIN;
  1750.         }

  1752.         /* invalid response */

  1754.         return NGX_ERROR;
  1755.     }

  1757.     return NGX_OK;
  1758. }


  1761. static ngx_int_t
  1762. ‌ngx_http_proxy_v2_body_filter(ngx_event_pipe_t *p, ngx_buf_t *b)
  1763. {
  1764.     ngx_int_t                 rc;
  1765.     ngx_buf_t                *buf, **prev;
  1766.     ngx_chain_t              *cl;
  1767.     ngx_http_request_t       *r;
  1768.     ngx_http_proxy_v2_ctx_t  *ctx;

  1770.     if (b->pos == b->last) {
  1771.         return NGX_OK;
  1772.     }

  1774.     r = p->input_ctx;
  1775.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1777.     if (ctx == NULL) {
  1778.         return NGX_ERROR;
  1779.     }

  1781.     buf = NULL;
  1782.     prev = &b->shadow;

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

  1787.     for ( ;; ) {

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

  1791.         if (rc == NGX_OK) {

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

  1795.             cl = ngx_chain_get_free_buf(p->pool, &p->free);
  1796.             if (cl == NULL) {
  1797.                 return NGX_ERROR;
  1798.             }

  1800.             buf = cl->buf;

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

  1804.             buf->pos = b->pos;
  1805.             buf->start = b->start;
  1806.             buf->end = b->end;
  1807.             buf->tag = p->tag;
  1808.             buf->temporary = 1;
  1809.             buf->recycled = 1;

  1811.             *prev = buf;
  1812.             prev = &buf->shadow;

  1814.             if (p->in) {
  1815.                 *p->last_in = cl;

  1817.             } else {
  1818.                 p->in = cl;
  1819.             }

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

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

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

  1828.             if (b->last - b->pos >= (ssize_t) ctx->rest - ctx->padding) {
  1829.                 b->pos += ctx->rest - ctx->padding;
  1830.                 buf->last = b->pos;
  1831.                 ctx->rest = ctx->padding;

  1833.             } else {
  1834.                 ctx->rest -= b->last - b->pos;
  1835.                 b->pos = b->last;
  1836.                 buf->last = b->pos;
  1837.             }

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

  1841.                 if (buf->last - buf->pos > ctx->length) {
  1842.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1843.                                   "upstream sent response body larger "
  1844.                                   "than indicated content length");
  1845.                     return NGX_ERROR;
  1846.                 }

  1848.                 ctx->length -= buf->last - buf->pos;
  1849.             }

  1851.             continue;
  1852.         }

  1854.         if (rc == NGX_DONE) {
  1855.             p->length = 0;
  1856.             break;
  1857.         }

  1859.         if (rc == NGX_AGAIN) {
  1860.             break;
  1861.         }

  1863.         /* invalid response */

  1865.         return NGX_ERROR;
  1866.     }

  1868.     if (buf) {
  1869.         buf->shadow = b;
  1870.         buf->last_shadow = 1;

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

  1875.         return NGX_OK;
  1876.     }

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

  1880.     if (ngx_event_pipe_add_free_buf(p, b) != NGX_OK) {
  1881.         return NGX_ERROR;
  1882.     }

  1884.     return NGX_OK;
  1885. }


  1888. static ngx_int_t
  1889. ‌ngx_http_proxy_v2_process_control_frame(ngx_http_request_t *r,
  1890.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  1891. {
  1892.     ngx_int_t             rc;
  1893.     ngx_http_upstream_t  *u;

  1895.     u = r->upstream;

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

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

  1901.         if (rc == NGX_AGAIN) {
  1902.             return NGX_AGAIN;
  1903.         }

  1905.         if (rc == NGX_ERROR) {
  1906.             return NGX_ERROR;
  1907.         }

  1909.         /*
  1910.          * If stream_id is lower than one we use, our
  1911.          * request won't be processed and needs to be retried.
  1912.          * If stream_id is greater or equal to the one we use,
  1913.          * we can continue normally (except we can't use this
  1914.          * connection for additional requests).  If there is
  1915.          * a real error, the connection will be closed.
  1916.          */

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

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

  1922.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1923.                           "upstream sent goaway with error %ui",
  1924.                           ctx->error);

  1926.             return NGX_ERROR;
  1927.         }

  1929.         ctx->goaway = 1;

  1931.         return NGX_OK;
  1932.     }

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

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

  1938.         if (rc == NGX_AGAIN) {
  1939.             return NGX_AGAIN;
  1940.         }

  1942.         if (rc == NGX_ERROR) {
  1943.             return NGX_ERROR;
  1944.         }

  1946.         if (ctx->in) {
  1947.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1948.         }

  1950.         return NGX_OK;
  1951.     }

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

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

  1957.         if (rc == NGX_AGAIN) {
  1958.             return NGX_AGAIN;
  1959.         }

  1961.         if (rc == NGX_ERROR) {
  1962.             return NGX_ERROR;
  1963.         }

  1965.         if (ctx->in) {
  1966.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1967.         }

  1969.         return NGX_OK;
  1970.     }

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

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

  1976.         if (rc == NGX_AGAIN) {
  1977.             return NGX_AGAIN;
  1978.         }

  1980.         if (rc == NGX_ERROR) {
  1981.             return NGX_ERROR;
  1982.         }

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

  1986.         return NGX_OK;
  1987.     }

  1989.     if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  1990.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1991.                       "upstream sent unexpected push promise frame");
  1992.         return NGX_ERROR;
  1993.     }

  1995.     return NGX_DECLINED;
  1996. }


  1999. static ngx_int_t
  2000. ‌ngx_http_proxy_v2_skip_frame(ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2001. {
  2002.     if (b->last - b->pos < (ssize_t) ctx->rest) {
  2003.         ctx->rest -= b->last - b->pos;
  2004.         b->pos = b->last;
  2005.         return NGX_AGAIN;
  2006.     }

  2008.     b->pos += ctx->rest;
  2009.     ctx->rest = 0;
  2010.     ctx->state = ngx_http_proxy_v2_st_start;

  2012.     return NGX_OK;
  2013. }


  2016. static ngx_int_t
  2017. ‌ngx_http_proxy_v2_process_frames(ngx_http_request_t *r,
  2018.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2019. {
  2020.     ngx_int_t             rc;
  2021.     ngx_table_elt_t      *h;
  2022.     ngx_http_upstream_t  *u;

  2024.     u = r->upstream;

  2026.     for ( ;; ) {

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

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

  2032.             if (rc == NGX_AGAIN) {

  2034.                 if (ctx->done) {

  2036.                     if (ctx->length > 0) {
  2037.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2038.                                       "upstream prematurely closed stream");
  2039.                         return NGX_ERROR;
  2040.                     }

  2042.                     /*
  2043.                      * We have finished parsing the response and the
  2044.                      * remaining control frames.  If there are unsent
  2045.                      * control frames, post a write event to send them.
  2046.                      */

  2048.                     if (ctx->out) {
  2049.                         ngx_post_event(u->peer.connection->write,
  2050.                                        &ngx_posted_events);
  2051.                         return NGX_AGAIN;
  2052.                     }

  2054.                     if (ctx->in == NULL
  2055.                         && ctx->output_closed
  2056.                         && !ctx->output_blocked
  2057.                         && !ctx->goaway
  2058.                         && ctx->state == ngx_http_proxy_v2_st_start)
  2059.                     {
  2060.                         u->keepalive = 1;
  2061.                     }

  2063.                     return NGX_DONE;
  2064.                 }

  2066.                 return NGX_AGAIN;
  2067.             }

  2069.             if (rc == NGX_ERROR) {
  2070.                 return NGX_ERROR;
  2071.             }

  2073.             if ((ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  2074.                  && !ctx->parsing_headers)
  2075.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  2076.                     && ctx->parsing_headers))
  2077.             {
  2078.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2079.                               "upstream sent unexpected http2 frame: %d",
  2080.                               ctx->type);
  2081.                 return NGX_ERROR;
  2082.             }

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

  2086.                 if (ctx->stream_id != ctx->id) {
  2087.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2088.                                   "upstream sent data frame "
  2089.                                   "for unknown stream %ui",
  2090.                                   ctx->stream_id);
  2091.                     return NGX_ERROR;
  2092.                 }

  2094.                 if (ctx->rest > ctx->recv_window) {
  2095.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2096.                                   "upstream violated stream flow control, "
  2097.                                   "received %uz data frame with window %uz",
  2098.                                   ctx->rest, ctx->recv_window);
  2099.                     return NGX_ERROR;
  2100.                 }

  2102.                 if (ctx->rest > ctx->connection->recv_window) {
  2103.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2104.                                   "upstream violated connection flow control, "
  2105.                                   "received %uz data frame with window %uz",
  2106.                                   ctx->rest, ctx->connection->recv_window);
  2107.                     return NGX_ERROR;
  2108.                 }

  2110.                 ctx->recv_window -= ctx->rest;
  2111.                 ctx->connection->recv_window -= ctx->rest;

  2113.                 if (ctx->connection->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4
  2114.                     || ctx->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4)
  2115.                 {
  2116.                     if (ngx_http_proxy_v2_send_window_update(r, ctx)
  2117.                         != NGX_OK)
  2118.                     {
  2119.                         return NGX_ERROR;
  2120.                     }

  2122.                     ngx_post_event(u->peer.connection->write,
  2123.                                    &ngx_posted_events);
  2124.                 }
  2125.             }

  2127.             if (ctx->stream_id && ctx->stream_id != ctx->id) {
  2128.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2129.                               "upstream sent frame for unknown stream %ui",
  2130.                               ctx->stream_id);
  2131.                 return NGX_ERROR;
  2132.             }

  2134.             if (ctx->stream_id && ctx->done
  2135.                 && ctx->type != NGX_HTTP_V2_RST_STREAM_FRAME
  2136.                 && ctx->type != NGX_HTTP_V2_WINDOW_UPDATE_FRAME)
  2137.             {
  2138.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2139.                               "upstream sent frame for closed stream %ui",
  2140.                               ctx->stream_id);
  2141.                 return NGX_ERROR;
  2142.             }

  2144.             ctx->padding = 0;
  2145.         }

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

  2149.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2150.                 ctx->rest -= b->last - b->pos;
  2151.                 b->pos = b->last;
  2152.                 return NGX_AGAIN;
  2153.             }

  2155.             b->pos += ctx->rest;
  2156.             ctx->rest = 0;
  2157.             ctx->state = ngx_http_proxy_v2_st_start;

  2159.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2160.                 ctx->done = 1;
  2161.             }

  2163.             continue;
  2164.         }

  2166.         /* frame payload */

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

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

  2172.             if (rc == NGX_AGAIN) {
  2173.                 return NGX_AGAIN;
  2174.             }

  2176.             if (rc == NGX_ERROR) {
  2177.                 return NGX_ERROR;
  2178.             }

  2180.             if (ctx->error || !ctx->done) {
  2181.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2182.                               "upstream rejected request with error %ui",
  2183.                               ctx->error);
  2184.                 return NGX_ERROR;
  2185.             }

  2187.             if (ctx->rst) {
  2188.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2189.                               "upstream sent frame for closed stream %ui",
  2190.                               ctx->stream_id);
  2191.                 return NGX_ERROR;
  2192.             }

  2194.             ctx->rst = 1;

  2196.             continue;
  2197.         }

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

  2201.         if (rc == NGX_AGAIN) {
  2202.             return NGX_AGAIN;
  2203.         }

  2205.         if (rc == NGX_ERROR) {
  2206.             return NGX_ERROR;
  2207.         }

  2209.         if (rc == NGX_OK) {
  2210.             continue;
  2211.         }

  2213.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME
  2214.             || ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME)
  2215.         {
  2216.             for ( ;; ) {

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

  2220.                 if (rc == NGX_AGAIN) {
  2221.                     break;
  2222.                 }

  2224.                 if (rc == NGX_OK) {

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

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

  2232.                     if (ctx->name.len && ctx->name.data[0] == ':') {
  2233.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2234.                                       "upstream sent invalid "
  2235.                                       "trailer \"%V: %V\"",
  2236.                                       &ctx->name, &ctx->value);
  2237.                         return NGX_ERROR;
  2238.                     }

  2240.                     h = ngx_list_push(&u->headers_in.trailers);
  2241.                     if (h == NULL) {
  2242.                         return NGX_ERROR;
  2243.                     }

  2245.                     h->key = ctx->name;
  2246.                     h->value = ctx->value;
  2247.                     h->lowcase_key = h->key.data;
  2248.                     h->hash = ngx_hash_key(h->key.data, h->key.len);

  2250.                     continue;
  2251.                 }

  2253.                 if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2260.                     if (ctx->end_stream) {
  2261.                         ctx->done = 1;
  2262.                         break;
  2263.                     }

  2265.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2266.                                   "upstream sent trailer without "
  2267.                                   "end stream flag");
  2268.                     return NGX_ERROR;
  2269.                 }

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

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

  2276.                 return NGX_ERROR;
  2277.             }

  2279.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2280.                 continue;
  2281.             }

  2283.             /* rc == NGX_AGAIN */

  2285.             if (ctx->rest == 0) {
  2286.                 ctx->state = ngx_http_proxy_v2_st_start;
  2287.                 continue;
  2288.             }

  2290.             return NGX_AGAIN;
  2291.         }

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

  2295.             /* priority, unknown frames */

  2297.             rc = ngx_http_proxy_v2_skip_frame(ctx, b);

  2299.             if (rc == NGX_AGAIN) {
  2300.                 return NGX_AGAIN;
  2301.             }

  2303.             continue;
  2304.         }

  2306.         /*
  2307.          * data frame:
  2308.          *
  2309.          * +---------------+
  2310.          * |Pad Length? (8)|
  2311.          * +---------------+-----------------------------------------------+
  2312.          * |                            Data (*)                         ...
  2313.          * +---------------------------------------------------------------+
  2314.          * |                           Padding (*)                       ...
  2315.          * +---------------------------------------------------------------+
  2316.          */

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

  2320.             if (ctx->rest == 0) {
  2321.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2322.                               "upstream sent too short http2 frame");
  2323.                 return NGX_ERROR;
  2324.             }

  2326.             if (b->pos == b->last) {
  2327.                 return NGX_AGAIN;
  2328.             }

  2330.             ctx->flags &= ~NGX_HTTP_V2_PADDED_FLAG;
  2331.             ctx->padding = *b->pos++;
  2332.             ctx->rest -= 1;

  2334.             if (ctx->padding > ctx->rest) {
  2335.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2336.                               "upstream sent http2 frame with too long "
  2337.                               "padding: %d in frame %uz",
  2338.                               ctx->padding, ctx->rest);
  2339.                 return NGX_ERROR;
  2340.             }

  2342.             continue;
  2343.         }

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

  2347.             if (ctx->padding) {
  2348.                 ctx->state = ngx_http_proxy_v2_st_padding;

  2350.             } else {
  2351.                 ctx->state = ngx_http_proxy_v2_st_start;

  2353.                 if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2354.                     ctx->done = 1;
  2355.                 }
  2356.             }

  2358.             continue;
  2359.         }

  2361.         if (b->pos == b->last) {
  2362.             return NGX_AGAIN;
  2363.         }

  2365.         return NGX_OK;
  2366.     }
  2367. }


  2370. static ngx_int_t
  2371. ‌ngx_http_proxy_v2_parse_frame(ngx_http_request_t *r,
  2372.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2373. {
  2374.     u_char                     ch, *p;
  2375.     ngx_http_proxy_v2_state_e  state;

  2377.     state = ctx->state;

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

  2382. #if 0
  2383.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2384.                        "http proxy frame byte: %02Xd, s:%d", ch, state);
  2385. #endif

  2387.         switch (state) {

  2389.         case ngx_http_proxy_v2_st_start:
  2390.             ctx->rest = ch << 16;
  2391.             state = ngx_http_proxy_v2_st_length_2;
  2392.             break;

  2394.         case ngx_http_proxy_v2_st_length_2:
  2395.             ctx->rest |= ch << 8;
  2396.             state = ngx_http_proxy_v2_st_length_3;
  2397.             break;

  2399.         case ngx_http_proxy_v2_st_length_3:
  2400.             ctx->rest |= ch;

  2402.             if (ctx->rest > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  2403.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2404.                               "upstream sent too large http2 frame: %uz",
  2405.                               ctx->rest);
  2406.                 return NGX_ERROR;
  2407.             }

  2409.             state = ngx_http_proxy_v2_st_type;
  2410.             break;

  2412.         case ngx_http_proxy_v2_st_type:
  2413.             ctx->type = ch;
  2414.             state = ngx_http_proxy_v2_st_flags;
  2415.             break;

  2417.         case ngx_http_proxy_v2_st_flags:
  2418.             ctx->flags = ch;
  2419.             state = ngx_http_proxy_v2_st_stream_id;
  2420.             break;

  2422.         case ngx_http_proxy_v2_st_stream_id:
  2423.             ctx->stream_id = (ch & 0x7f) << 24;
  2424.             state = ngx_http_proxy_v2_st_stream_id_2;
  2425.             break;

  2427.         case ngx_http_proxy_v2_st_stream_id_2:
  2428.             ctx->stream_id |= ch << 16;
  2429.             state = ngx_http_proxy_v2_st_stream_id_3;
  2430.             break;

  2432.         case ngx_http_proxy_v2_st_stream_id_3:
  2433.             ctx->stream_id |= ch << 8;
  2434.             state = ngx_http_proxy_v2_st_stream_id_4;
  2435.             break;

  2437.         case ngx_http_proxy_v2_st_stream_id_4:
  2438.             ctx->stream_id |= ch;

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

  2444.             b->pos = p + 1;

  2446.             ctx->state = ngx_http_proxy_v2_st_payload;
  2447.             ctx->frame_state = 0;

  2449.             return NGX_OK;

  2451.         /* suppress warning */
  2452.         case ngx_http_proxy_v2_st_payload:
  2453.         case ngx_http_proxy_v2_st_padding:
  2454.             break;
  2455.         }
  2456.     }

  2458.     b->pos = p;
  2459.     ctx->state = state;

  2461.     return NGX_AGAIN;
  2462. }


  2465. static ngx_int_t
  2466. ‌ngx_http_proxy_v2_parse_header(ngx_http_request_t *r,
  2467.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2468. {
  2469.     u_char     ch, *p, *last;
  2470.     size_t     min;
  2471.     ngx_int_t  rc;
  2472. ‌    enum {
  2473.         sw_start = 0,
  2474.         sw_padding_length,
  2475.         sw_dependency,
  2476.         sw_dependency_2,
  2477.         sw_dependency_3,
  2478.         sw_dependency_4,
  2479.         sw_weight,
  2480.         sw_fragment,
  2481.         sw_padding
  2482.     } state;

  2484.     state = ctx->frame_state;

  2486.     if (state == sw_start) {

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

  2491.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME) {
  2492.             ctx->parsing_headers = 1;
  2493.             ctx->fragment_state = 0;

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

  2498.             if (ctx->rest < min) {
  2499.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2500.                               "upstream sent headers frame "
  2501.                               "with invalid length: %uz",
  2502.                               ctx->rest);
  2503.                 return NGX_ERROR;
  2504.             }

  2506.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2507.                 ctx->end_stream = 1;
  2508.             }

  2510.             if (ctx->flags & NGX_HTTP_V2_PADDED_FLAG) {
  2511.                 state = sw_padding_length;

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

  2516.             } else {
  2517.                 state = sw_fragment;
  2518.             }

  2520.         } else if (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME) {
  2521.             state = sw_fragment;
  2522.         }

  2524.         ctx->padding = 0;
  2525.         ctx->frame_state = state;
  2526.     }

  2528.     if (state < sw_fragment) {

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

  2533.         } else {
  2534.             last = b->pos + ctx->rest;
  2535.         }

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

  2540. #if 0
  2541.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2542.                            "http proxy header byte: %02Xd s:%d", ch, state);
  2543. #endif

  2545.             /*
  2546.              * headers frame:
  2547.              *
  2548.              * +---------------+
  2549.              * |Pad Length? (8)|
  2550.              * +-+-------------+----------------------------------------------+
  2551.              * |E|                 Stream Dependency? (31)                    |
  2552.              * +-+-------------+----------------------------------------------+
  2553.              * |  Weight? (8)  |
  2554.              * +-+-------------+----------------------------------------------+
  2555.              * |                   Header Block Fragment (*)                ...
  2556.              * +--------------------------------------------------------------+
  2557.              * |                           Padding (*)                      ...
  2558.              * +--------------------------------------------------------------+
  2559.              */

  2561.             switch (state) {

  2563.             case sw_padding_length:

  2565.                 ctx->padding = ch;

  2567.                 if (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG) {
  2568.                     state = sw_dependency;
  2569.                     break;
  2570.                 }

  2572.                 goto fragment;

  2574.             case sw_dependency:
  2575.                 state = sw_dependency_2;
  2576.                 break;

  2578.             case sw_dependency_2:
  2579.                 state = sw_dependency_3;
  2580.                 break;

  2582.             case sw_dependency_3:
  2583.                 state = sw_dependency_4;
  2584.                 break;

  2586.             case sw_dependency_4:
  2587.                 state = sw_weight;
  2588.                 break;

  2590.             case sw_weight:
  2591.                 goto fragment;

  2593.             /* suppress warning */
  2594.             case sw_start:
  2595.             case sw_fragment:
  2596.             case sw_padding:
  2597.                 break;
  2598.             }
  2599.         }

  2601.         ctx->rest -= p - b->pos;
  2602.         b->pos = p;

  2604.         ctx->frame_state = state;
  2605.         return NGX_AGAIN;

  2607.     fragment:

  2609.         p++;
  2610.         ctx->rest -= p - b->pos;
  2611.         b->pos = p;

  2613.         if (ctx->padding > ctx->rest) {
  2614.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2615.                           "upstream sent http2 frame with too long "
  2616.                           "padding: %d in frame %uz",
  2617.                           ctx->padding, ctx->rest);
  2618.             return NGX_ERROR;
  2619.         }

  2621.         state = sw_fragment;
  2622.         ctx->frame_state = state;
  2623.     }

  2625.     if (state == sw_fragment) {

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

  2629.         if (rc == NGX_AGAIN) {
  2630.             return NGX_AGAIN;
  2631.         }

  2633.         if (rc == NGX_ERROR) {
  2634.             return NGX_ERROR;
  2635.         }

  2637.         if (rc == NGX_OK) {
  2638.             return NGX_OK;
  2639.         }

  2641.         /* rc == NGX_DONE */

  2643.         state = sw_padding;
  2644.         ctx->frame_state = state;
  2645.     }

  2647.     if (state == sw_padding) {

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

  2651.             ctx->rest -= b->last - b->pos;
  2652.             b->pos = b->last;

  2654.             return NGX_AGAIN;
  2655.         }

  2657.         b->pos += ctx->rest;
  2658.         ctx->rest = 0;

  2660.         ctx->state = ngx_http_proxy_v2_st_start;

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

  2664.             if (ctx->fragment_state) {
  2665.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2666.                               "upstream sent truncated http2 header");
  2667.                 return NGX_ERROR;
  2668.             }

  2670.             ctx->parsing_headers = 0;

  2672.             return NGX_HTTP_PARSE_HEADER_DONE;
  2673.         }

  2675.         return NGX_AGAIN;
  2676.     }

  2678.     /* unreachable */

  2680.     return NGX_ERROR;
  2681. }


  2684. static ngx_int_t
  2685. ‌ngx_http_proxy_v2_parse_fragment(ngx_http_request_t *r,
  2686.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  2687. {
  2688.     u_char      ch, *p, *last;
  2689.     size_t      size;
  2690.     ngx_uint_t  index, size_update;
  2691. ‌    enum {
  2692.         sw_start = 0,
  2693.         sw_index,
  2694.         sw_name_length,
  2695.         sw_name_length_2,
  2696.         sw_name_length_3,
  2697.         sw_name_length_4,
  2698.         sw_name,
  2699.         sw_name_bytes,
  2700.         sw_value_length,
  2701.         sw_value_length_2,
  2702.         sw_value_length_3,
  2703.         sw_value_length_4,
  2704.         sw_value,
  2705.         sw_value_bytes
  2706.     } state;

  2708.     /* header block fragment */

  2710. #if 0
  2711.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2712.                    "http proxy header fragment %p:%p rest:%uz",
  2713.                    b->pos, b->last, ctx->rest);
  2714. #endif

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

  2719.     } else {
  2720.         last = b->pos + ctx->rest - ctx->padding;
  2721.     }

  2723.     state = ctx->fragment_state;

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

  2728. #if 0
  2729.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2730.                        "http proxy header byte: %02Xd s:%d", ch, state);
  2731. #endif

  2733.         switch (state) {

  2735.         case sw_start:
  2736.             ctx->index = 0;

  2738.             if ((ch & 0x80) == 0x80) {
  2739.                 /*
  2740.                  * indexed header:
  2741.                  *
  2742.                  *   0   1   2   3   4   5   6   7
  2743.                  * +---+---+---+---+---+---+---+---+
  2744.                  * | 1 |        Index (7+)         |
  2745.                  * +---+---------------------------+
  2746.                  */

  2748.                 index = ch & ~0x80;

  2750.                 if (index == 0 || index > 61) {
  2751.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2752.                                   "upstream sent invalid http2 "
  2753.                                   "table index: %ui", index);
  2754.                     return NGX_ERROR;
  2755.                 }

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

  2760.                 ctx->index = index;
  2761.                 ctx->literal = 0;

  2763.                 goto done;

  2765.             } else if ((ch & 0xc0) == 0x40) {
  2766.                 /*
  2767.                  * literal header with incremental indexing:
  2768.                  *
  2769.                  *   0   1   2   3   4   5   6   7
  2770.                  * +---+---+---+---+---+---+---+---+
  2771.                  * | 0 | 1 |      Index (6+)       |
  2772.                  * +---+---+-----------------------+
  2773.                  * | H |     Value Length (7+)     |
  2774.                  * +---+---------------------------+
  2775.                  * | Value String (Length octets)  |
  2776.                  * +-------------------------------+
  2777.                  *
  2778.                  *   0   1   2   3   4   5   6   7
  2779.                  * +---+---+---+---+---+---+---+---+
  2780.                  * | 0 | 1 |           0           |
  2781.                  * +---+---+-----------------------+
  2782.                  * | H |     Name Length (7+)      |
  2783.                  * +---+---------------------------+
  2784.                  * |  Name String (Length octets)  |
  2785.                  * +---+---------------------------+
  2786.                  * | H |     Value Length (7+)     |
  2787.                  * +---+---------------------------+
  2788.                  * | Value String (Length octets)  |
  2789.                  * +-------------------------------+
  2790.                  */

  2792.                 index = ch & ~0xc0;

  2794.                 if (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 literal header: %ui", index);

  2804.                 if (index == 0) {
  2805.                     state = sw_name_length;
  2806.                     break;
  2807.                 }

  2809.                 ctx->index = index;
  2810.                 ctx->literal = 1;

  2812.                 state = sw_value_length;
  2813.                 break;

  2815.             } else if ((ch & 0xe0) == 0x20) {
  2816.                 /*
  2817.                  * dynamic table size update:
  2818.                  *
  2819.                  *   0   1   2   3   4   5   6   7
  2820.                  * +---+---+---+---+---+---+---+---+
  2821.                  * | 0 | 0 | 1 |   Max size (5+)   |
  2822.                  * +---+---------------------------+
  2823.                  */

  2825.                 size_update = ch & ~0xe0;

  2827.                 if (size_update > 0) {
  2828.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2829.                                   "upstream sent invalid http2 "
  2830.                                   "dynamic table size update: %ui",
  2831.                                   size_update);
  2832.                     return NGX_ERROR;
  2833.                 }

  2835.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2836.                                "http proxy table size update: %ui",
  2837.                                size_update);

  2839.                 break;

  2841.             } else if ((ch & 0xf0) == 0x10) {
  2842.                 /*
  2843.                  *  literal header field never indexed:
  2844.                  *
  2845.                  *   0   1   2   3   4   5   6   7
  2846.                  * +---+---+---+---+---+---+---+---+
  2847.                  * | 0 | 0 | 0 | 1 |  Index (4+)   |
  2848.                  * +---+---+-----------------------+
  2849.                  * | H |     Value Length (7+)     |
  2850.                  * +---+---------------------------+
  2851.                  * | Value String (Length octets)  |
  2852.                  * +-------------------------------+
  2853.                  *
  2854.                  *   0   1   2   3   4   5   6   7
  2855.                  * +---+---+---+---+---+---+---+---+
  2856.                  * | 0 | 0 | 0 | 1 |       0       |
  2857.                  * +---+---+-----------------------+
  2858.                  * | H |     Name Length (7+)      |
  2859.                  * +---+---------------------------+
  2860.                  * |  Name String (Length octets)  |
  2861.                  * +---+---------------------------+
  2862.                  * | H |     Value Length (7+)     |
  2863.                  * +---+---------------------------+
  2864.                  * | Value String (Length octets)  |
  2865.                  * +-------------------------------+
  2866.                  */

  2868.                 index = ch & ~0xf0;

  2870.                 if (index == 0x0f) {
  2871.                     ctx->index = index;
  2872.                     ctx->literal = 1;
  2873.                     state = sw_index;
  2874.                     break;
  2875.                 }

  2877.                 if (index == 0) {
  2878.                     state = sw_name_length;
  2879.                     break;
  2880.                 }

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

  2886.                 ctx->index = index;
  2887.                 ctx->literal = 1;

  2889.                 state = sw_value_length;
  2890.                 break;

  2892.             } else if ((ch & 0xf0) == 0x00) {
  2893.                 /*
  2894.                  * literal header field without indexing:
  2895.                  *
  2896.                  *   0   1   2   3   4   5   6   7
  2897.                  * +---+---+---+---+---+---+---+---+
  2898.                  * | 0 | 0 | 0 | 0 |  Index (4+)   |
  2899.                  * +---+---+-----------------------+
  2900.                  * | H |     Value Length (7+)     |
  2901.                  * +---+---------------------------+
  2902.                  * | Value String (Length octets)  |
  2903.                  * +-------------------------------+
  2904.                  *
  2905.                  *   0   1   2   3   4   5   6   7
  2906.                  * +---+---+---+---+---+---+---+---+
  2907.                  * | 0 | 0 | 0 | 0 |       0       |
  2908.                  * +---+---+-----------------------+
  2909.                  * | H |     Name Length (7+)      |
  2910.                  * +---+---------------------------+
  2911.                  * |  Name String (Length octets)  |
  2912.                  * +---+---------------------------+
  2913.                  * | H |     Value Length (7+)     |
  2914.                  * +---+---------------------------+
  2915.                  * | Value String (Length octets)  |
  2916.                  * +-------------------------------+
  2917.                  */

  2919.                 index = ch & ~0xf0;

  2921.                 if (index == 0x0f) {
  2922.                     ctx->index = index;
  2923.                     ctx->literal = 1;
  2924.                     state = sw_index;
  2925.                     break;
  2926.                 }

  2928.                 if (index == 0) {
  2929.                     state = sw_name_length;
  2930.                     break;
  2931.                 }

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

  2937.                 ctx->index = index;
  2938.                 ctx->literal = 1;

  2940.                 state = sw_value_length;
  2941.                 break;
  2942.             }

  2944.             /* not reached */

  2946.             return NGX_ERROR;

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

  2951.             if (ch & 0x80) {
  2952.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2953.                               "upstream sent http2 table index "
  2954.                               "with continuation flag");
  2955.                 return NGX_ERROR;
  2956.             }

  2958.             if (ctx->index > 61) {
  2959.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2960.                               "upstream sent invalid http2 "
  2961.                               "table index: %ui", ctx->index);
  2962.                 return NGX_ERROR;
  2963.             }

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

  2968.             state = sw_value_length;
  2969.             break;

  2971.         case sw_name_length:
  2972.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  2973.             ctx->field_length = ch & ~0x80;

  2975.             if (ctx->field_length == 0x7f) {
  2976.                 state = sw_name_length_2;
  2977.                 break;
  2978.             }

  2980.             if (ctx->field_length == 0) {
  2981.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2982.                               "upstream sent zero http2 "
  2983.                               "header name length");
  2984.                 return NGX_ERROR;
  2985.             }

  2987.             state = sw_name;
  2988.             break;

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

  2993.             if (ch & 0x80) {
  2994.                 state = sw_name_length_3;
  2995.                 break;
  2996.             }

  2998.             state = sw_name;
  2999.             break;

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

  3004.             if (ch & 0x80) {
  3005.                 state = sw_name_length_4;
  3006.                 break;
  3007.             }

  3009.             state = sw_name;
  3010.             break;

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

  3015.             if (ch & 0x80) {
  3016.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3017.                               "upstream sent too large http2 "
  3018.                               "header name length");
  3019.                 return NGX_ERROR;
  3020.             }

  3022.             state = sw_name;
  3023.             break;

  3025.         case sw_name:
  3026.             ctx->name.len = ctx->field_huffman ?
  3027.                             ctx->field_length * 8 / 5 : ctx->field_length;

  3029.             ctx->name.data = ngx_pnalloc(r->pool, ctx->name.len + 1);
  3030.             if (ctx->name.data == NULL) {
  3031.                 return NGX_ERROR;
  3032.             }

  3034.             ctx->field_end = ctx->name.data;
  3035.             ctx->field_rest = ctx->field_length;
  3036.             ctx->field_state = 0;

  3038.             state = sw_name_bytes;

  3040.             /* fall through */

  3042.         case sw_name_bytes:

  3044.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3045.                            "http proxy name: len:%uz h:%d last:%uz, rest:%uz",
  3046.                            ctx->field_length,
  3047.                            ctx->field_huffman,
  3048.                            last - p,
  3049.                            ctx->rest - (p - b->pos));

  3051.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3052.             ctx->field_rest -= size;

  3054.             if (ctx->field_huffman) {
  3055.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3056.                                          &ctx->field_end,
  3057.                                          ctx->field_rest == 0,
  3058.                                          r->connection->log)
  3059.                     != NGX_OK)
  3060.                 {
  3061.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3062.                                   "upstream sent invalid encoded header");
  3063.                     return NGX_ERROR;
  3064.                 }

  3066.                 ctx->name.len = ctx->field_end - ctx->name.data;
  3067.                 ctx->name.data[ctx->name.len] = '\0';

  3069.             } else {
  3070.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3071.                 ctx->name.data[ctx->name.len] = '\0';
  3072.             }

  3074.             p += size - 1;

  3076.             if (ctx->field_rest == 0) {
  3077.                 state = sw_value_length;
  3078.             }

  3080.             break;

  3082.         case sw_value_length:
  3083.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3084.             ctx->field_length = ch & ~0x80;

  3086.             if (ctx->field_length == 0x7f) {
  3087.                 state = sw_value_length_2;
  3088.                 break;
  3089.             }

  3091.             if (ctx->field_length == 0) {
  3092.                 ngx_str_set(&ctx->value, "");
  3093.                 goto done;
  3094.             }

  3096.             state = sw_value;
  3097.             break;

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

  3102.             if (ch & 0x80) {
  3103.                 state = sw_value_length_3;
  3104.                 break;
  3105.             }

  3107.             state = sw_value;
  3108.             break;

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

  3113.             if (ch & 0x80) {
  3114.                 state = sw_value_length_4;
  3115.                 break;
  3116.             }

  3118.             state = sw_value;
  3119.             break;

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

  3124.             if (ch & 0x80) {
  3125.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3126.                               "upstream sent too large http2 "
  3127.                               "header value length");
  3128.                 return NGX_ERROR;
  3129.             }

  3131.             state = sw_value;
  3132.             break;

  3134.         case sw_value:
  3135.             ctx->value.len = ctx->field_huffman ?
  3136.                              ctx->field_length * 8 / 5 : ctx->field_length;

  3138.             ctx->value.data = ngx_pnalloc(r->pool, ctx->value.len + 1);
  3139.             if (ctx->value.data == NULL) {
  3140.                 return NGX_ERROR;
  3141.             }

  3143.             ctx->field_end = ctx->value.data;
  3144.             ctx->field_rest = ctx->field_length;
  3145.             ctx->field_state = 0;

  3147.             state = sw_value_bytes;

  3149.             /* fall through */

  3151.         case sw_value_bytes:

  3153.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3154.                            "http proxy value: len:%uz h:%d last:%uz, rest:%uz",
  3155.                            ctx->field_length,
  3156.                            ctx->field_huffman,
  3157.                            last - p,
  3158.                            ctx->rest - (p - b->pos));

  3160.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3161.             ctx->field_rest -= size;

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

  3175.                 ctx->value.len = ctx->field_end - ctx->value.data;
  3176.                 ctx->value.data[ctx->value.len] = '\0';

  3178.             } else {
  3179.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3180.                 ctx->value.data[ctx->value.len] = '\0';
  3181.             }

  3183.             p += size - 1;

  3185.             if (ctx->field_rest == 0) {
  3186.                 goto done;
  3187.             }

  3189.             break;
  3190.         }

  3192.         continue;

  3194.     done:

  3196.         p++;
  3197.         ctx->rest -= p - b->pos;
  3198.         ctx->fragment_state = sw_start;
  3199.         b->pos = p;

  3201.         if (ctx->index) {
  3202.             ctx->name = *ngx_http_v2_get_static_name(ctx->index);
  3203.         }

  3205.         if (ctx->index && !ctx->literal) {
  3206.             ctx->value = *ngx_http_v2_get_static_value(ctx->index);
  3207.         }

  3209.         if (!ctx->index) {
  3210.             if (ngx_http_proxy_v2_validate_header_name(r, &ctx->name)
  3211.                 != NGX_OK)
  3212.             {
  3213.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3214.                               "upstream sent invalid header: \"%V: %V\"",
  3215.                               &ctx->name, &ctx->value);
  3216.                 return NGX_ERROR;
  3217.             }
  3218.         }

  3220.         if (!ctx->index || ctx->literal) {
  3221.             if (ngx_http_proxy_v2_validate_header_value(r, &ctx->value)
  3222.                 != NGX_OK)
  3223.             {
  3224.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3225.                               "upstream sent invalid header: \"%V: %V\"",
  3226.                               &ctx->name, &ctx->value);
  3227.                 return NGX_ERROR;
  3228.             }
  3229.         }

  3231.         return NGX_OK;
  3232.     }

  3234.     ctx->rest -= p - b->pos;
  3235.     ctx->fragment_state = state;
  3236.     b->pos = p;

  3238.     if (ctx->rest > ctx->padding) {
  3239.         return NGX_AGAIN;
  3240.     }

  3242.     return NGX_DONE;
  3243. }


  3246. static ngx_int_t
  3247. ‌ngx_http_proxy_v2_validate_header_name(ngx_http_request_t *r, ngx_str_t *s)
  3248. {
  3249.     u_char      ch;
  3250.     ngx_uint_t  i;

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

  3255.         if (ch == ':' && i > 0) {
  3256.             return NGX_ERROR;
  3257.         }

  3259.         if (ch >= 'A' && ch <= 'Z') {
  3260.             return NGX_ERROR;
  3261.         }

  3263.         if (ch <= 0x20 || ch == 0x7f) {
  3264.             return NGX_ERROR;
  3265.         }
  3266.     }

  3268.     return NGX_OK;
  3269. }


  3272. static ngx_int_t
  3273. ‌ngx_http_proxy_v2_validate_header_value(ngx_http_request_t *r, ngx_str_t *s)
  3274. {
  3275.     u_char      ch;
  3276.     ngx_uint_t  i;

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

  3281.         if (ch == '\0' || ch == CR || ch == LF) {
  3282.             return NGX_ERROR;
  3283.         }
  3284.     }

  3286.     return NGX_OK;
  3287. }


  3290. static ngx_int_t
  3291. ‌ngx_http_proxy_v2_parse_rst_stream(ngx_http_request_t *r,
  3292.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3293. {
  3294.     u_char  ch, *p, *last;
  3295. ‌    enum {
  3296.         sw_start = 0,
  3297.         sw_error_2,
  3298.         sw_error_3,
  3299.         sw_error_4
  3300.     } state;

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

  3305.     } else {
  3306.         last = b->pos + ctx->rest;
  3307.     }

  3309.     state = ctx->frame_state;

  3311.     if (state == sw_start) {
  3312.         if (ctx->rest != 4) {
  3313.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3314.                           "upstream sent rst stream frame "
  3315.                           "with invalid length: %uz",
  3316.                           ctx->rest);
  3317.             return NGX_ERROR;
  3318.         }
  3319.     }

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

  3324. #if 0
  3325.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3326.                        "http proxy rst byte: %02Xd s:%d", ch, state);
  3327. #endif

  3329.         switch (state) {

  3331.         case sw_start:
  3332.             ctx->error = (ngx_uint_t) ch << 24;
  3333.             state = sw_error_2;
  3334.             break;

  3336.         case sw_error_2:
  3337.             ctx->error |= ch << 16;
  3338.             state = sw_error_3;
  3339.             break;

  3341.         case sw_error_3:
  3342.             ctx->error |= ch << 8;
  3343.             state = sw_error_4;
  3344.             break;

  3346.         case sw_error_4:
  3347.             ctx->error |= ch;
  3348.             state = sw_start;

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

  3353.             break;
  3354.         }
  3355.     }

  3357.     ctx->rest -= p - b->pos;
  3358.     ctx->frame_state = state;
  3359.     b->pos = p;

  3361.     if (ctx->rest > 0) {
  3362.         return NGX_AGAIN;
  3363.     }

  3365.     ctx->state = ngx_http_proxy_v2_st_start;

  3367.     return NGX_OK;
  3368. }


  3371. static ngx_int_t
  3372. ‌ngx_http_proxy_v2_parse_goaway(ngx_http_request_t *r,
  3373.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3374. {
  3375.     u_char  ch, *p, *last;
  3376. ‌    enum {
  3377.         sw_start = 0,
  3378.         sw_last_stream_id_2,
  3379.         sw_last_stream_id_3,
  3380.         sw_last_stream_id_4,
  3381.         sw_error,
  3382.         sw_error_2,
  3383.         sw_error_3,
  3384.         sw_error_4,
  3385.         sw_debug
  3386.     } state;

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

  3391.     } else {
  3392.         last = b->pos + ctx->rest;
  3393.     }

  3395.     state = ctx->frame_state;

  3397.     if (state == sw_start) {

  3399.         if (ctx->stream_id) {
  3400.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3401.                           "upstream sent goaway frame "
  3402.                           "with non-zero stream id: %ui",
  3403.                           ctx->stream_id);
  3404.             return NGX_ERROR;
  3405.         }

  3407.         if (ctx->rest < 8) {
  3408.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3409.                           "upstream sent goaway frame "
  3410.                           "with invalid length: %uz",
  3411.                           ctx->rest);
  3412.             return NGX_ERROR;
  3413.         }
  3414.     }

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

  3419. #if 0
  3420.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3421.                        "http proxy goaway byte: %02Xd s:%d", ch, state);
  3422. #endif

  3424.         switch (state) {

  3426.         case sw_start:
  3427.             ctx->stream_id = (ch & 0x7f) << 24;
  3428.             state = sw_last_stream_id_2;
  3429.             break;

  3431.         case sw_last_stream_id_2:
  3432.             ctx->stream_id |= ch << 16;
  3433.             state = sw_last_stream_id_3;
  3434.             break;

  3436.         case sw_last_stream_id_3:
  3437.             ctx->stream_id |= ch << 8;
  3438.             state = sw_last_stream_id_4;
  3439.             break;

  3441.         case sw_last_stream_id_4:
  3442.             ctx->stream_id |= ch;
  3443.             state = sw_error;
  3444.             break;

  3446.         case sw_error:
  3447.             ctx->error = (ngx_uint_t) ch << 24;
  3448.             state = sw_error_2;
  3449.             break;

  3451.         case sw_error_2:
  3452.             ctx->error |= ch << 16;
  3453.             state = sw_error_3;
  3454.             break;

  3456.         case sw_error_3:
  3457.             ctx->error |= ch << 8;
  3458.             state = sw_error_4;
  3459.             break;

  3461.         case sw_error_4:
  3462.             ctx->error |= ch;
  3463.             state = sw_debug;
  3464.             break;

  3466.         case sw_debug:
  3467.             break;
  3468.         }
  3469.     }

  3471.     ctx->rest -= p - b->pos;
  3472.     ctx->frame_state = state;
  3473.     b->pos = p;

  3475.     if (ctx->rest > 0) {
  3476.         return NGX_AGAIN;
  3477.     }

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

  3483.     ctx->state = ngx_http_proxy_v2_st_start;

  3485.     return NGX_OK;
  3486. }


  3489. static ngx_int_t
  3490. ‌ngx_http_proxy_v2_parse_window_update(ngx_http_request_t *r,
  3491.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3492. {
  3493.     u_char  ch, *p, *last;
  3494. ‌    enum {
  3495.         sw_start = 0,
  3496.         sw_size_2,
  3497.         sw_size_3,
  3498.         sw_size_4
  3499.     } state;

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

  3504.     } else {
  3505.         last = b->pos + ctx->rest;
  3506.     }

  3508.     state = ctx->frame_state;

  3510.     if (state == sw_start) {
  3511.         if (ctx->rest != 4) {
  3512.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3513.                           "upstream sent window update frame "
  3514.                           "with invalid length: %uz",
  3515.                           ctx->rest);
  3516.             return NGX_ERROR;
  3517.         }
  3518.     }

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

  3523. #if 0
  3524.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3525.                        "http proxy window update byte: %02Xd s:%d", ch, state);
  3526. #endif

  3528.         switch (state) {

  3530.         case sw_start:
  3531.             ctx->window_update = (ch & 0x7f) << 24;
  3532.             state = sw_size_2;
  3533.             break;

  3535.         case sw_size_2:
  3536.             ctx->window_update |= ch << 16;
  3537.             state = sw_size_3;
  3538.             break;

  3540.         case sw_size_3:
  3541.             ctx->window_update |= ch << 8;
  3542.             state = sw_size_4;
  3543.             break;

  3545.         case sw_size_4:
  3546.             ctx->window_update |= ch;
  3547.             state = sw_start;
  3548.             break;
  3549.         }
  3550.     }

  3552.     ctx->rest -= p - b->pos;
  3553.     ctx->frame_state = state;
  3554.     b->pos = p;

  3556.     if (ctx->rest > 0) {
  3557.         return NGX_AGAIN;
  3558.     }

  3560.     ctx->state = ngx_http_proxy_v2_st_start;

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

  3565.     if (ctx->stream_id) {

  3567.         if (ctx->window_update > (size_t) NGX_HTTP_V2_MAX_WINDOW
  3568.                                  - ctx->send_window)
  3569.         {
  3570.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3571.                           "upstream sent too large window update");
  3572.             return NGX_ERROR;
  3573.         }

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

  3577.     } else {

  3579.         if (ctx->window_update > NGX_HTTP_V2_MAX_WINDOW
  3580.                                  - ctx->connection->send_window)
  3581.         {
  3582.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3583.                           "upstream sent too large window update");
  3584.             return NGX_ERROR;
  3585.         }

  3587.         ctx->connection->send_window += ctx->window_update;
  3588.     }

  3590.     return NGX_OK;
  3591. }


  3594. static ngx_int_t
  3595. ‌ngx_http_proxy_v2_parse_settings(ngx_http_request_t *r,
  3596.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3597. {
  3598.     u_char   ch, *p, *last;
  3599.     ssize_t  window_update;
  3600. ‌    enum {
  3601.         sw_start = 0,
  3602.         sw_id,
  3603.         sw_id_2,
  3604.         sw_value,
  3605.         sw_value_2,
  3606.         sw_value_3,
  3607.         sw_value_4
  3608.     } state;

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

  3613.     } else {
  3614.         last = b->pos + ctx->rest;
  3615.     }

  3617.     state = ctx->frame_state;

  3619.     if (state == sw_start) {

  3621.         if (ctx->stream_id) {
  3622.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3623.                           "upstream sent settings frame "
  3624.                           "with non-zero stream id: %ui",
  3625.                           ctx->stream_id);
  3626.             return NGX_ERROR;
  3627.         }

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

  3633.             if (ctx->rest != 0) {
  3634.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3635.                               "upstream sent settings frame "
  3636.                               "with ack flag and non-zero length: %uz",
  3637.                               ctx->rest);
  3638.                 return NGX_ERROR;
  3639.             }

  3641.             ctx->state = ngx_http_proxy_v2_st_start;

  3643.             return NGX_OK;
  3644.         }

  3646.         if (ctx->rest % 6 != 0) {
  3647.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3648.                           "upstream sent settings frame "
  3649.                           "with invalid length: %uz",
  3650.                           ctx->rest);
  3651.             return NGX_ERROR;
  3652.         }

  3654.         if (ctx->free == NULL && ctx->settings++ > 1000) {
  3655.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3656.                           "upstream sent too many settings frames");
  3657.             return NGX_ERROR;
  3658.         }
  3659.     }

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

  3664. #if 0
  3665.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3666.                        "http proxy settings byte: %02Xd s:%d", ch, state);
  3667. #endif

  3669.         switch (state) {

  3671.         case sw_start:
  3672.         case sw_id:
  3673.             ctx->setting_id = ch << 8;
  3674.             state = sw_id_2;
  3675.             break;

  3677.         case sw_id_2:
  3678.             ctx->setting_id |= ch;
  3679.             state = sw_value;
  3680.             break;

  3682.         case sw_value:
  3683.             ctx->setting_value = (ngx_uint_t) ch << 24;
  3684.             state = sw_value_2;
  3685.             break;

  3687.         case sw_value_2:
  3688.             ctx->setting_value |= ch << 16;
  3689.             state = sw_value_3;
  3690.             break;

  3692.         case sw_value_3:
  3693.             ctx->setting_value |= ch << 8;
  3694.             state = sw_value_4;
  3695.             break;

  3697.         case sw_value_4:
  3698.             ctx->setting_value |= ch;
  3699.             state = sw_id;

  3701.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3702.                            "http proxy setting: %ui %ui",
  3703.                            ctx->setting_id, ctx->setting_value);

  3705.             /*
  3706.              * The following settings are defined by the protocol:
  3707.              *
  3708.              * SETTINGS_HEADER_TABLE_SIZE, SETTINGS_ENABLE_PUSH,
  3709.              * SETTINGS_MAX_CONCURRENT_STREAMS, SETTINGS_INITIAL_WINDOW_SIZE,
  3710.              * SETTINGS_MAX_FRAME_SIZE, SETTINGS_MAX_HEADER_LIST_SIZE
  3711.              *
  3712.              * Only SETTINGS_INITIAL_WINDOW_SIZE seems to be needed in
  3713.              * a simple client.
  3714.              */

  3716.             if (ctx->setting_id == 0x04) {
  3717.                 /* SETTINGS_INITIAL_WINDOW_SIZE */

  3719.                 if (ctx->setting_value > NGX_HTTP_V2_MAX_WINDOW) {
  3720.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3721.                                   "upstream sent settings frame "
  3722.                                   "with too large initial window size: %ui",
  3723.                                   ctx->setting_value);
  3724.                     return NGX_ERROR;
  3725.                 }

  3727.                 window_update = ctx->setting_value
  3728.                                 - ctx->connection->init_window;
  3729.                 ctx->connection->init_window = ctx->setting_value;

  3731.                 if (ctx->send_window > 0
  3732.                     && window_update > (ssize_t) NGX_HTTP_V2_MAX_WINDOW
  3733.                                        - ctx->send_window)
  3734.                 {
  3735.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3736.                                   "upstream sent settings frame "
  3737.                                   "with too large initial window size: %ui",
  3738.                                   ctx->setting_value);
  3739.                     return NGX_ERROR;
  3740.                 }

  3742.                 ctx->send_window += window_update;
  3743.             }

  3745.             break;
  3746.         }
  3747.     }

  3749.     ctx->rest -= p - b->pos;
  3750.     ctx->frame_state = state;
  3751.     b->pos = p;

  3753.     if (ctx->rest > 0) {
  3754.         return NGX_AGAIN;
  3755.     }

  3757.     ctx->state = ngx_http_proxy_v2_st_start;

  3759.     return ngx_http_proxy_v2_send_settings_ack(r, ctx);
  3760. }


  3763. static ngx_int_t
  3764. ‌ngx_http_proxy_v2_parse_ping(ngx_http_request_t *r,
  3765.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  3766. {
  3767.     u_char  ch, *p, *last;
  3768. ‌    enum {
  3769.         sw_start = 0,
  3770.         sw_data_2,
  3771.         sw_data_3,
  3772.         sw_data_4,
  3773.         sw_data_5,
  3774.         sw_data_6,
  3775.         sw_data_7,
  3776.         sw_data_8
  3777.     } state;

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

  3782.     } else {
  3783.         last = b->pos + ctx->rest;
  3784.     }

  3786.     state = ctx->frame_state;

  3788.     if (state == sw_start) {

  3790.         if (ctx->stream_id) {
  3791.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3792.                           "upstream sent ping frame "
  3793.                           "with non-zero stream id: %ui",
  3794.                           ctx->stream_id);
  3795.             return NGX_ERROR;
  3796.         }

  3798.         if (ctx->rest != 8) {
  3799.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3800.                           "upstream sent ping frame "
  3801.                           "with invalid length: %uz",
  3802.                           ctx->rest);
  3803.             return NGX_ERROR;
  3804.         }

  3806.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  3807.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3808.                           "upstream sent ping frame with ack flag");
  3809.             return NGX_ERROR;
  3810.         }

  3812.         if (ctx->free == NULL && ctx->pings++ > 1000) {
  3813.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3814.                           "upstream sent too many ping frames");
  3815.             return NGX_ERROR;
  3816.         }
  3817.     }

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

  3822. #if 0
  3823.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3824.                        "http proxy ping byte: %02Xd s:%d", ch, state);
  3825. #endif

  3827.         if (state < sw_data_8) {
  3828.             ctx->ping_data[state] = ch;
  3829.             state++;

  3831.         } else {
  3832.             ctx->ping_data[7] = ch;
  3833.             state = sw_start;

  3835.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3836.                            "http proxy ping");
  3837.         }
  3838.     }

  3840.     ctx->rest -= p - b->pos;
  3841.     ctx->frame_state = state;
  3842.     b->pos = p;

  3844.     if (ctx->rest > 0) {
  3845.         return NGX_AGAIN;
  3846.     }

  3848.     ctx->state = ngx_http_proxy_v2_st_start;

  3850.     return ngx_http_proxy_v2_send_ping_ack(r, ctx);
  3851. }


  3854. static ngx_int_t
  3855. ‌ngx_http_proxy_v2_send_settings_ack(ngx_http_request_t *r,
  3856.     ngx_http_proxy_v2_ctx_t *ctx)
  3857. {
  3858.     ngx_chain_t                *cl, **ll;
  3859.     ngx_http_proxy_v2_frame_t  *f;

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

  3864.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  3865.         ll = &cl->next;
  3866.     }

  3868.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  3869.     if (cl == NULL) {
  3870.         return NGX_ERROR;
  3871.     }

  3873.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  3874.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  3876.     f->length_0 = 0;
  3877.     f->length_1 = 0;
  3878.     f->length_2 = 0;
  3879.     f->type = NGX_HTTP_V2_SETTINGS_FRAME;
  3880.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  3881.     f->stream_id_0 = 0;
  3882.     f->stream_id_1 = 0;
  3883.     f->stream_id_2 = 0;
  3884.     f->stream_id_3 = 0;

  3886.     *ll = cl;

  3888.     return NGX_OK;
  3889. }


  3892. static ngx_int_t
  3893. ‌ngx_http_proxy_v2_send_ping_ack(ngx_http_request_t *r,
  3894.     ngx_http_proxy_v2_ctx_t *ctx)
  3895. {
  3896.     ngx_chain_t                *cl, **ll;
  3897.     ngx_http_proxy_v2_frame_t  *f;

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

  3902.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  3903.         ll = &cl->next;
  3904.     }

  3906.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  3907.     if (cl == NULL) {
  3908.         return NGX_ERROR;
  3909.     }

  3911.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  3912.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  3914.     f->length_0 = 0;
  3915.     f->length_1 = 0;
  3916.     f->length_2 = 8;
  3917.     f->type = NGX_HTTP_V2_PING_FRAME;
  3918.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  3919.     f->stream_id_0 = 0;
  3920.     f->stream_id_1 = 0;
  3921.     f->stream_id_2 = 0;
  3922.     f->stream_id_3 = 0;

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

  3926.     *ll = cl;

  3928.     return NGX_OK;
  3929. }


  3932. static ngx_int_t
  3933. ‌ngx_http_proxy_v2_send_window_update(ngx_http_request_t *r,
  3934.     ngx_http_proxy_v2_ctx_t *ctx)
  3935. {
  3936.     size_t                      n;
  3937.     ngx_chain_t                *cl, **ll;
  3938.     ngx_http_proxy_v2_frame_t  *f;

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

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

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

  3953.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  3954.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  3956.     f->length_0 = 0;
  3957.     f->length_1 = 0;
  3958.     f->length_2 = 4;
  3959.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  3960.     f->flags = 0;
  3961.     f->stream_id_0 = 0;
  3962.     f->stream_id_1 = 0;
  3963.     f->stream_id_2 = 0;
  3964.     f->stream_id_3 = 0;

  3966.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->connection->recv_window;
  3967.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  3969.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  3970.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  3971.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  3972.     *cl->buf->last++ = (u_char) (n & 0xff);

  3974.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  3975.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

  3977.     f->length_0 = 0;
  3978.     f->length_1 = 0;
  3979.     f->length_2 = 4;
  3980.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  3981.     f->flags = 0;
  3982.     f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  3983.     f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  3984.     f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  3985.     f->stream_id_3 = (u_char) (ctx->id & 0xff);

  3987.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->recv_window;
  3988.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  3990.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  3991.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  3992.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  3993.     *cl->buf->last++ = (u_char) (n & 0xff);

  3995.     *ll = cl;

  3997.     return NGX_OK;
  3998. }


  4001. static ngx_chain_t *
  4002. ‌ngx_http_proxy_v2_get_buf(ngx_http_request_t *r, ngx_http_proxy_v2_ctx_t *ctx)
  4003. {
  4004.     u_char       *start;
  4005.     ngx_buf_t    *b;
  4006.     ngx_chain_t  *cl;

  4008.     cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  4009.     if (cl == NULL) {
  4010.         return NULL;
  4011.     }

  4013.     b = cl->buf;
  4014.     start = b->start;

  4016.     if (start == NULL) {

  4018.         /*
  4019.          * each buffer is large enough to hold two window update
  4020.          * frames in a row
  4021.          */

  4023.         start = ngx_palloc(r->pool, 2 * sizeof(ngx_http_proxy_v2_frame_t) + 8);
  4024.         if (start == NULL) {
  4025.             return NULL;
  4026.         }

  4028.     }

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

  4032.     b->start = start;
  4033.     b->pos = start;
  4034.     b->last = start;
  4035.     b->end = start + 2 * sizeof(ngx_http_proxy_v2_frame_t) + 8;

  4037.     b->tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter;
  4038.     b->temporary = 1;
  4039.     b->flush = 1;

  4041.     return cl;
  4042. }


  4045. static ngx_http_proxy_v2_ctx_t *
  4046. ‌ngx_http_proxy_v2_get_ctx(ngx_http_request_t *r)
  4047. {
  4048.     ngx_http_upstream_t      *u;
  4049.     ngx_http_proxy_v2_ctx_t  *ctx;

  4051.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  4053.     if (ctx->connection == NULL) {
  4054.         u = r->upstream;

  4056.         if (ngx_http_proxy_v2_get_connection_data(r, ctx, &u->peer) != NGX_OK) {
  4057.             return NULL;
  4058.         }
  4059.     }

  4061.     return ctx;
  4062. }


  4065. static ngx_int_t
  4066. ‌ngx_http_proxy_v2_get_connection_data(ngx_http_request_t *r,
  4067.     ngx_http_proxy_v2_ctx_t *ctx, ngx_peer_connection_t *pc)
  4068. {
  4069.     ngx_connection_t    *c;
  4070.     ngx_pool_cleanup_t  *cln;

  4072.     c = pc->connection;

  4074.     if (c == NULL) {
  4075.         ctx->connection = ngx_palloc(r->pool, sizeof(ngx_http_proxy_v2_conn_t));
  4076.         if (ctx->connection == NULL) {
  4077.             return NGX_ERROR;
  4078.         }

  4080.         ctx->id = 0;

  4082.         goto done;
  4083.     }

  4085.     if (pc->cached) {

  4087.         /*
  4088.          * for cached connections, connection data can be found
  4089.          * in the cleanup handler
  4090.          */

  4092.         for (cln = c->pool->cleanup; cln; cln = cln->next) {
  4093.             if (cln->handler == ngx_http_proxy_v2_cleanup) {
  4094.                 ctx->connection = cln->data;
  4095.                 break;
  4096.             }
  4097.         }

  4099.         if (ctx->connection == NULL) {
  4100.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  4101.                           "no connection data found for "
  4102.                           "keepalive http2 connection");
  4103.             return NGX_ERROR;
  4104.         }

  4106.         ctx->send_window = ctx->connection->init_window;
  4107.         ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4109.         ctx->connection->last_stream_id += 2;
  4110.         ctx->id = ctx->connection->last_stream_id;

  4112.         return NGX_OK;
  4113.     }

  4115.     cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_proxy_v2_conn_t));
  4116.     if (cln == NULL) {
  4117.         return NGX_ERROR;
  4118.     }

  4120.     cln->handler = ngx_http_proxy_v2_cleanup;
  4121.     ctx->connection = cln->data;

  4123.     ctx->id = 1;

  4125. done:

  4127.     ctx->connection->init_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4128.     ctx->connection->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4129.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4131.     ctx->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4132.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

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

  4136.     return NGX_OK;
  4137. }


  4140. static void
  4141. ‌ngx_http_proxy_v2_cleanup(void *data)
  4142. {
  4143. #if 0
  4144.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  4145.                    "http proxy cleanup");
  4146. #endif
  4147.     return;
  4148. }


  4151. static void
  4152. ‌ngx_http_proxy_v2_abort_request(ngx_http_request_t *r)
  4153. {
  4154.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4155.                    "abort proxy http2 request");
  4156.     return;
  4157. }


  4160. static void
  4161. ‌ngx_http_proxy_v2_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  4162. {
  4163.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4164.                    "finalize proxy http2 request");
  4165.     return;
  4166. }

One Level Up Top Level