One Level Up Top Level

src/http/modules/ngx_http_proxy_v2_module.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

Global variables defined

Data types defined

Functions defined

Source code


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


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


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


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


  37. ‌typedef struct {
  38.     ngx_http_proxy_ctx_t           ctx;

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

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

  49.     ngx_http_proxy_v2_conn_t      *connection;

  51.     ngx_uint_t                     id;

  53.     ngx_uint_t                     pings;
  54.     ngx_uint_t                     settings;

  56.     off_t                          length;

  58.     ssize_t                        send_window;
  59.     size_t                         recv_window;

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

  67.     ngx_uint_t                     error;
  68.     ngx_uint_t                     window_update;

  70.     ngx_uint_t                     setting_id;
  71.     ngx_uint_t                     setting_value;

  73.     u_char                         ping_data[8];

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

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

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

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


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


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

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

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

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

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


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

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

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

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


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


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

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

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


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

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

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

  235.     ngx_http_set_ctx(r, ctx, ngx_http_proxy_v2_module);

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

  239.     plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);

  241.     plcf->upstream.preserve_output = 1;

  243.     u = r->upstream;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  301.     u->accel = 1;

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

  309.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

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

  315.     return NGX_DONE;
  316. }


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

  343.     u = r->upstream;

  345.     plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);

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

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

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

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

  366.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

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

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

  377.     headers_len = 0;

  379.     /* :method header */

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

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

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

  398.     /* :scheme header */

  400.     len += 1;

  402.     /* :path header */

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

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

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

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

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

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

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

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

  440.     len += 1 + NGX_HTTP_V2_INT_OCTETS + uri_len;

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

  446.     /* :authority header */

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

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

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

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

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

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

  475.     /* other headers */

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

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

  482.     body_len = 0;

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

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

  494.         ctx->ctx.internal_body_length = body_len;

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

  499.     } else if (r->discard_body) {
  500.         ctx->ctx.internal_body_length = 0;

  502.     } else {
  503.         ctx->ctx.internal_body_length = r->headers_in.content_length_n;
  504.     }

  506.     le.ip = headers->lengths->elts;
  507.     le.request = r;
  508.     le.flushed = 1;

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

  512.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  513.         key_len = lcode(&le);

  515.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  516.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  517.         }
  518.         le.ip += sizeof(uintptr_t);

  520.         if (val_len == 0) {
  521.             continue;
  522.         }

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

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

  536.         headers_len += 1 + NGX_HTTP_V2_INT_OCTETS + key_len
  537.                          + NGX_HTTP_V2_INT_OCTETS + val_len;

  539.         if (tmp_len < key_len) {
  540.             tmp_len = key_len;
  541.         }

  543.         if (tmp_len < val_len) {
  544.             tmp_len = val_len;
  545.         }
  546.     }

  548.     len += headers_len;

  550.     if (plcf->upstream.pass_request_headers) {
  551.         part = &r->headers_in.headers.part;
  552.         header = part->elts;

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

  556.             if (i >= part->nelts) {
  557.                 if (part->next == NULL) {
  558.                     break;
  559.                 }

  561.                 part = part->next;
  562.                 header = part->elts;
  563.                 i = 0;
  564.             }

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

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

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

  586.             len += 1 + NGX_HTTP_V2_INT_OCTETS + header[i].key.len
  587.                      + NGX_HTTP_V2_INT_OCTETS + header[i].value.len;

  589.             if (tmp_len < header[i].key.len) {
  590.                 tmp_len = header[i].key.len;
  591.             }

  593.             if (tmp_len < header[i].value.len) {
  594.                 tmp_len = header[i].value.len;
  595.             }
  596.         }
  597.     }

  599.     /* continuation frames */

  601.     len += sizeof(ngx_http_proxy_v2_frame_t)
  602.            * (len / NGX_HTTP_V2_DEFAULT_FRAME_SIZE);


  605.     b = ngx_create_temp_buf(r->pool, len);
  606.     if (b == NULL) {
  607.         return NGX_ERROR;
  608.     }

  610.     cl = ngx_alloc_chain_link(r->pool);
  611.     if (cl == NULL) {
  612.         return NGX_ERROR;
  613.     }

  615.     cl->buf = b;
  616.     cl->next = NULL;

  618.     tmp = ngx_palloc(r->pool, tmp_len * 3);
  619.     if (tmp == NULL) {
  620.         return NGX_ERROR;
  621.     }

  623.     key_tmp = tmp + tmp_len;
  624.     val_tmp = tmp + 2 * tmp_len;

  626.     /* connection preface */

  628.     b->last = ngx_copy(b->last, ngx_http_proxy_v2_connection_start,
  629.                        sizeof(ngx_http_proxy_v2_connection_start) - 1);

  631.     /* headers frame */

  633.     headers_frame = b->last;

  635.     f = (ngx_http_proxy_v2_frame_t *) b->last;
  636.     b->last += sizeof(ngx_http_proxy_v2_frame_t);

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

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

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

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

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

  660.     } else {
  661.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_METHOD_INDEX);
  662.         b->last = ngx_http_v2_write_value(b->last, method.data,
  663.                                           method.len, tmp);

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

  669. #if (NGX_HTTP_SSL)
  670.     if (u->ssl) {
  671.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTPS_INDEX);

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

  680.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  681.                        "http proxy header: \":scheme: http\"");
  682.     }

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

  686.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  687.         b->last = ngx_http_v2_write_value(b->last, ctx->ctx.vars.uri.data,
  688.                                           ctx->ctx.vars.uri.len, tmp);

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

  693.     } else if (unparsed_uri) {

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

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

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

  707.     } else {
  708.         p = val_tmp;

  710.         if (r->valid_location) {
  711.             p = ngx_copy(p, ctx->ctx.vars.uri.data, ctx->ctx.vars.uri.len);
  712.         }

  714.         if (escape) {
  715.             ngx_escape_uri(p, r->uri.data + loc_len,
  716.                            r->uri.len - loc_len, NGX_ESCAPE_URI);
  717.             p += r->uri.len - loc_len + escape;

  719.         } else {
  720.             p = ngx_copy(p, r->uri.data + loc_len, r->uri.len - loc_len);
  721.         }

  723.         if (r->args.len > 0) {
  724.             *p++ = '?';
  725.             p = ngx_copy(p, r->args.data, r->args.len);
  726.         }

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

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

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

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

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

  744.     e.ip = headers->values->elts;
  745.     e.request = r;
  746.     e.flushed = 1;

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

  750.     headers_end = b->last + headers_len;

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

  754.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  755.         key_len = lcode(&le);

  757.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  758.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  759.         }
  760.         le.ip += sizeof(uintptr_t);

  762.         if (val_len == 0) {
  763.             e.skip = 1;

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

  771.             e.skip = 0;

  773.             continue;
  774.         }

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

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

  784.         e.pos = key_tmp;
  785.         e.end = key_tmp + tmp_len;

  787.         code = *(ngx_http_script_code_pt *) e.ip;
  788.         code((ngx_http_script_engine_t *) &e);

  790.         if (e.status) {
  791.             return NGX_ERROR;
  792.         }

  794.         key_len = e.pos - key_tmp;

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

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

  806.         e.pos = val_tmp;
  807.         e.end = val_tmp + tmp_len;

  809.         while (*(uintptr_t *) e.ip) {
  810.             code = *(ngx_http_script_code_pt *) e.ip;
  811.             code((ngx_http_script_engine_t *) &e);
  812.         }
  813.         e.ip += sizeof(uintptr_t);

  815.         if (e.status) {
  816.             return NGX_ERROR;
  817.         }

  819.         val_len = e.pos - val_tmp;

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

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

  831. #if (NGX_DEBUG)
  832.         if (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP) {
  833.             ngx_strlow(key_tmp, key_tmp, key_len);

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

  842.     if (plcf->upstream.pass_request_headers) {
  843.         part = &r->headers_in.headers.part;
  844.         header = part->elts;

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

  848.             if (i >= part->nelts) {
  849.                 if (part->next == NULL) {
  850.                     break;
  851.                 }

  853.                 part = part->next;
  854.                 header = part->elts;
  855.                 i = 0;
  856.             }

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

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

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

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

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

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

  884.     /* update headers frame length */

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

  888.     if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  889.         len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  890.         next = 1;

  892.     } else {
  893.         next = 0;
  894.     }

  896.     f = (ngx_http_proxy_v2_frame_t *) headers_frame;

  898.     f->length_0 = (u_char) ((len >> 16) & 0xff);
  899.     f->length_1 = (u_char) ((len >> 8) & 0xff);
  900.     f->length_2 = (u_char) (len & 0xff);

  902.     /* create additional continuation frames */

  904.     p = headers_frame;

  906.     while (next) {
  907.         p += sizeof(ngx_http_proxy_v2_frame_t) + NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  908.         len = b->last - p;

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

  913.         if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  914.             len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  915.             next = 1;

  917.         } else {
  918.             next = 0;
  919.         }

  921.         f = (ngx_http_proxy_v2_frame_t *) p;

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

  934.     f->flags |= NGX_HTTP_V2_END_HEADERS_FLAG;

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

  942.     if (r->request_body_no_buffering) {

  944.         u->request_bufs = cl;

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

  948.         body = u->request_bufs;
  949.         u->request_bufs = cl;

  951.         if (body == NULL) {
  952.             f = (ngx_http_proxy_v2_frame_t *) headers_frame;
  953.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;
  954.         }

  956.         while (body) {
  957.             b = ngx_alloc_buf(r->pool);
  958.             if (b == NULL) {
  959.                 return NGX_ERROR;
  960.             }

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

  964.             cl->next = ngx_alloc_chain_link(r->pool);
  965.             if (cl->next == NULL) {
  966.                 return NGX_ERROR;
  967.             }

  969.             cl = cl->next;
  970.             cl->buf = b;

  972.             body = body->next;
  973.         }

  975.         b->last_buf = 1;

  977.     } else if (body_len) {

  979.         u->request_bufs = cl;

  981.         b = ngx_create_temp_buf(r->pool, body_len);
  982.         if (b == NULL) {
  983.             return NGX_ERROR;
  984.         }

  986.         cl->next = ngx_alloc_chain_link(r->pool);
  987.         if (cl->next == NULL) {
  988.             return NGX_ERROR;
  989.         }

  991.         cl = cl->next;
  992.         cl->buf = b;

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

  1001.         while (*(uintptr_t *) e.ip) {
  1002.             code = *(ngx_http_script_code_pt *) e.ip;
  1003.             code((ngx_http_script_engine_t *) &e);
  1004.         }

  1006.         if (e.status) {
  1007.             return NGX_ERROR;
  1008.         }

  1010.         b->last = e.pos;
  1011.         b->last_buf = 1;

  1013.     } else {
  1014.         u->request_bufs = cl;

  1016.         f = (ngx_http_proxy_v2_frame_t *) headers_frame;
  1017.         f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1019.         b->last_buf = 1;
  1020.     }

  1022.     u->output.output_filter = ngx_http_proxy_v2_body_output_filter;
  1023.     u->output.filter_ctx = r;

  1025.     b->flush = 1;
  1026.     cl->next = NULL;

  1028.     return NGX_OK;
  1029. }


  1032. static ngx_int_t
  1033. ‌ngx_http_proxy_v2_reinit_request(ngx_http_request_t *r)
  1034. {
  1035.     ngx_http_proxy_v2_ctx_t  *ctx;

  1037.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1039.     if (ctx == NULL) {
  1040.         return NGX_OK;
  1041.     }

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

  1058.     return NGX_OK;
  1059. }


  1062. static ngx_int_t
  1063. ‌ngx_http_proxy_v2_body_output_filter(void *data, ngx_chain_t *in)
  1064. {
  1065.     ngx_http_request_t  *r = data;

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

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

  1081.     ctx = ngx_http_proxy_v2_get_ctx(r);

  1083.     if (ctx == NULL) {
  1084.         return NGX_ERROR;
  1085.     }

  1087.     if (in) {
  1088.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  1089.             return NGX_ERROR;
  1090.         }
  1091.     }

  1093.     out = NULL;
  1094.     ll = &out;

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

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

  1102.         ctx->header_sent = 1;

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

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

  1113.             p = b->pos;

  1115.             while (p < b->last) {
  1116.                 f = (ngx_http_proxy_v2_frame_t *) p;
  1117.                 p += sizeof(ngx_http_proxy_v2_frame_t);

  1119.                 f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1120.                 f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1121.                 f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1122.                 f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1124.                 p += (f->length_0 << 16) + (f->length_1 << 8) + f->length_2;
  1125.             }
  1126.         }

  1128.         if (ctx->in->buf->last_buf) {
  1129.             ctx->output_closed = 1;
  1130.         }

  1132.         *ll = ctx->in;
  1133.         ll = &ctx->in->next;

  1135.         ctx->in = ctx->in->next;
  1136.     }

  1138.     if (ctx->out) {
  1139.         /* queued control frames */

  1141.         *ll = ctx->out;

  1143.         for (cl = ctx->out, ll = &cl->next; cl; cl = cl->next) {
  1144.             ll = &cl->next;
  1145.         }

  1147.         ctx->out = NULL;
  1148.     }

  1150.     f = NULL;
  1151.     last = 0;

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

  1155.     if (limit > ctx->connection->send_window) {
  1156.         limit = ctx->connection->send_window;
  1157.     }

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

  1163. #if (NGX_SUPPRESS_WARN)
  1164.     file_pos = 0;
  1165.     pos = NULL;
  1166.     cl = NULL;
  1167. #endif

  1169.     in = ctx->in;

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

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

  1183.         if (ngx_buf_special(in->buf)) {
  1184.             goto next;
  1185.         }

  1187.         if (in->buf->in_file) {
  1188.             file_pos = in->buf->file_pos;

  1190.         } else {
  1191.             pos = in->buf->pos;
  1192.         }

  1194.         next = 0;

  1196.         do {

  1198.             cl = ngx_http_proxy_v2_get_buf(r, ctx);
  1199.             if (cl == NULL) {
  1200.                 return NGX_ERROR;
  1201.             }

  1203.             b = cl->buf;

  1205.             f = (ngx_http_proxy_v2_frame_t *) b->last;
  1206.             b->last += sizeof(ngx_http_proxy_v2_frame_t);

  1208.             *ll = cl;
  1209.             ll = &cl->next;

  1211.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  1212.             if (cl == NULL) {
  1213.                 return NGX_ERROR;
  1214.             }

  1216.             b = cl->buf;
  1217.             start = b->start;

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

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

  1226.             b->start = start;

  1228.             if (in->buf->in_file) {
  1229.                 b->file_pos = file_pos;
  1230.                 file_pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1232.                 if (file_pos >= in->buf->file_last) {
  1233.                     file_pos = in->buf->file_last;
  1234.                     next = 1;
  1235.                 }

  1237.                 b->file_last = file_pos;
  1238.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1240.             } else {
  1241.                 b->pos = pos;
  1242.                 pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1244.                 if (pos >= in->buf->last) {
  1245.                     pos = in->buf->last;
  1246.                     next = 1;
  1247.                 }

  1249.                 b->last = pos;
  1250.                 len = (ngx_uint_t) (pos - b->pos);
  1251.             }

  1253.             b->tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter;
  1254.             b->shadow = in->buf;
  1255.             b->last_shadow = next;

  1257.             b->last_buf = 0;
  1258.             b->last_in_chain = 0;

  1260.             *ll = cl;
  1261.             ll = &cl->next;

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

  1273.             limit -= len;
  1274.             ctx->send_window -= len;
  1275.             ctx->connection->send_window -= len;

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

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

  1285.             if (in->buf->in_file) {
  1286.                 in->buf->file_pos = file_pos;

  1288.             } else {
  1289.                 in->buf->pos = pos;
  1290.             }

  1292.             break;
  1293.         }

  1295.     next:

  1297.         if (in->buf->last_buf) {
  1298.             last = 1;
  1299.         }

  1301.         ln = in;
  1302.         in = in->next;

  1304.         ngx_free_chain(r->pool, ln);
  1305.     }

  1307.     ctx->in = in;

  1309.     if (last) {

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

  1314.         ctx->output_closed = 1;

  1316.         if (f) {
  1317.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1319.         } else {
  1320.             cl = ngx_http_proxy_v2_get_buf(r, ctx);
  1321.             if (cl == NULL) {
  1322.                 return NGX_ERROR;
  1323.             }

  1325.             b = cl->buf;

  1327.             f = (ngx_http_proxy_v2_frame_t *) b->last;
  1328.             b->last += sizeof(ngx_http_proxy_v2_frame_t);

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

  1340.             *ll = cl;
  1341.             ll = &cl->next;
  1342.         }

  1344.         cl->buf->last_buf = 1;
  1345.     }

  1347.     *ll = NULL;

  1349. #if (NGX_DEBUG)

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

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

  1367. #endif

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

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

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

  1376.         /* mark original buffers as sent */

  1378.         if (cl->buf->shadow) {
  1379.             if (cl->buf->last_shadow) {
  1380.                 b = cl->buf->shadow;
  1381.                 b->pos = b->last;
  1382.             }

  1384.             cl->buf->shadow = NULL;
  1385.         }
  1386.     }

  1388.     if (rc == NGX_OK && ctx->in) {
  1389.         rc = NGX_AGAIN;
  1390.     }

  1392.     if (rc == NGX_AGAIN) {
  1393.         ctx->output_blocked = 1;

  1395.     } else {
  1396.         ctx->output_blocked = 0;
  1397.     }

  1399.     if (ctx->done) {

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

  1407.         u = r->upstream;
  1408.         u->length = 0;
  1409.         u->pipe->length = 0;

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

  1421.         ngx_post_event(u->peer.connection->read, &ngx_posted_events);
  1422.     }

  1424.     return rc;
  1425. }


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

  1441.     u = r->upstream;
  1442.     b = &u->buffer;
  1443.     pos = b->pos;

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

  1451.     ctx = ngx_http_proxy_v2_get_ctx(r);

  1453.     if (ctx == NULL) {
  1454.         return NGX_ERROR;
  1455.     }

  1457.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1459.     for ( ;; ) {

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

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

  1465.             if (rc == NGX_AGAIN) {

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

  1473.                 if (!ctx->parsing_headers) {
  1474.                     b->pos = pos;
  1475.                     b->last = b->pos;
  1476.                 }

  1478.                 return NGX_AGAIN;
  1479.             }

  1481.             if (rc == NGX_ERROR) {
  1482.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1483.             }

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

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

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

  1514.         /* frame payload */

  1516.         if (!ngx_http_proxy_v2_cached(r)) {

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

  1521.                 if (rc == NGX_AGAIN) {
  1522.                     return NGX_AGAIN;
  1523.                 }

  1525.                 if (rc == NGX_ERROR) {
  1526.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1527.                 }

  1529.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1530.                               "upstream rejected request with error %ui",
  1531.                               ctx->error);

  1533.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1534.             }

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

  1538.             if (rc == NGX_AGAIN) {
  1539.                 return NGX_AGAIN;
  1540.             }

  1542.             if (rc == NGX_ERROR) {
  1543.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1544.             }

  1546.             if (rc == NGX_OK) {
  1547.                 continue;
  1548.             }
  1549.         }

  1551.         if (ctx->type != NGX_HTTP_V2_HEADERS_FRAME
  1552.             && ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME)
  1553.         {
  1554.             /* priority, unknown frames */

  1556.             rc = ngx_http_proxy_v2_skip_frame(ctx, b);

  1558.             if (rc == NGX_AGAIN) {
  1559.                 return NGX_AGAIN;
  1560.             }

  1562.             continue;
  1563.         }

  1565.         /* headers */

  1567.         for ( ;; ) {

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

  1571.             if (rc == NGX_AGAIN) {
  1572.                 break;
  1573.             }

  1575.             if (rc == NGX_OK) {

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

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

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

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

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

  1602.                     status_line = &ctx->value;

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

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

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

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

  1628.                     u->headers_in.status_n = status;

  1630.                     if (u->state && u->state->status == 0) {
  1631.                         u->state->status = status;
  1632.                     }

  1634.                     ctx->status = 1;

  1636.                     continue;

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

  1644.                 h = ngx_list_push(&u->headers_in.headers);
  1645.                 if (h == NULL) {
  1646.                     return NGX_ERROR;
  1647.                 }

  1649.                 h->key = ctx->name;
  1650.                 h->value = ctx->value;
  1651.                 h->lowcase_key = h->key.data;
  1652.                 h->hash = ngx_hash_key(h->key.data, h->key.len);

  1654.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1655.                     continue;
  1656.                 }

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

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

  1664.                     if (rc != NGX_OK) {
  1665.                         return rc;
  1666.                     }
  1667.                 }

  1669.                 continue;
  1670.             }

  1672.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

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

  1686.                     ctx->status = 0;
  1687.                     return NGX_HTTP_UPSTREAM_EARLY_HINTS;
  1688.                 }

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

  1701.                 return NGX_OK;
  1702.             }

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

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

  1709.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1710.         }

  1712.         /* rc == NGX_AGAIN */

  1714.         if (ctx->rest == 0) {
  1715.             ctx->state = ngx_http_proxy_v2_st_start;
  1716.             continue;
  1717.         }

  1719.         return NGX_AGAIN;
  1720.     }
  1721. }


  1724. static ngx_int_t
  1725. ‌ngx_http_proxy_v2_filter_init(void *data)
  1726. {
  1727.     ngx_http_request_t       *r = data;
  1728.     ngx_http_upstream_t      *u;
  1729.     ngx_http_proxy_v2_ctx_t  *ctx;

  1731.     u = r->upstream;
  1732.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1734.     if (ctx == NULL) {
  1735.         return NGX_ERROR;
  1736.     }

  1738.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1739.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED
  1740.         || ctx->ctx.head)
  1741.     {
  1742.         ctx->length = 0;

  1744.     } else {
  1745.         ctx->length = u->headers_in.content_length_n;
  1746.     }

  1748.     if (ctx->end_stream) {

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

  1756.         u->length = 0;
  1757.         u->pipe->length = 0;
  1758.         ctx->done = 1;

  1760.     } else {
  1761.         u->length = 1;
  1762.         u->pipe->length = 1;
  1763.     }

  1765.     return NGX_OK;
  1766. }


  1769. static ngx_int_t
  1770. ‌ngx_http_proxy_v2_non_buffered_filter(void *data, ssize_t bytes)
  1771. {
  1772.     ngx_http_request_t   *r = data;

  1774.     ngx_int_t                 rc;
  1775.     ngx_buf_t                *b, *buf;
  1776.     ngx_chain_t              *cl, **ll;
  1777.     ngx_http_upstream_t      *u;
  1778.     ngx_http_proxy_v2_ctx_t  *ctx;

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

  1783.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1785.     if (ctx == NULL) {
  1786.         return NGX_ERROR;
  1787.     }

  1789.     u = r->upstream;
  1790.     b = &u->buffer;

  1792.     b->pos = b->last;
  1793.     b->last += bytes;

  1795.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  1796.         ll = &cl->next;
  1797.     }

  1799.     for ( ;; ) {

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

  1803.         if (rc == NGX_OK) {

  1805.             cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  1806.             if (cl == NULL) {
  1807.                 return NGX_ERROR;
  1808.             }

  1810.             *ll = cl;
  1811.             ll = &cl->next;

  1813.             buf = cl->buf;

  1815.             buf->flush = 1;
  1816.             buf->memory = 1;

  1818.             buf->pos = b->pos;
  1819.             buf->tag = u->output.tag;

  1821.             if (b->last - b->pos >= (ssize_t) ctx->rest - ctx->padding) {
  1822.                 b->pos += ctx->rest - ctx->padding;
  1823.                 buf->last = b->pos;
  1824.                 ctx->rest = ctx->padding;

  1826.             } else {
  1827.                 ctx->rest -= b->last - b->pos;
  1828.                 b->pos = b->last;
  1829.                 buf->last = b->pos;
  1830.             }

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

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

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

  1844.                 ctx->length -= buf->last - buf->pos;
  1845.             }

  1847.             continue;
  1848.         }

  1850.         if (rc == NGX_DONE) {
  1851.             u->length = 0;
  1852.             break;
  1853.         }

  1855.         if (rc == NGX_AGAIN) {
  1856.             return NGX_AGAIN;
  1857.         }

  1859.         /* invalid response */

  1861.         return NGX_ERROR;
  1862.     }

  1864.     return NGX_OK;
  1865. }


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

  1877.     if (b->pos == b->last) {
  1878.         return NGX_OK;
  1879.     }

  1881.     r = p->input_ctx;
  1882.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  1884.     if (ctx == NULL) {
  1885.         return NGX_ERROR;
  1886.     }

  1888.     buf = NULL;
  1889.     prev = &b->shadow;

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

  1894.     for ( ;; ) {

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

  1898.         if (rc == NGX_OK) {

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

  1902.             cl = ngx_chain_get_free_buf(p->pool, &p->free);
  1903.             if (cl == NULL) {
  1904.                 return NGX_ERROR;
  1905.             }

  1907.             buf = cl->buf;

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

  1911.             buf->pos = b->pos;
  1912.             buf->start = b->start;
  1913.             buf->end = b->end;
  1914.             buf->tag = p->tag;
  1915.             buf->temporary = 1;
  1916.             buf->recycled = 1;

  1918.             *prev = buf;
  1919.             prev = &buf->shadow;

  1921.             if (p->in) {
  1922.                 *p->last_in = cl;

  1924.             } else {
  1925.                 p->in = cl;
  1926.             }

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

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

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

  1935.             if (b->last - b->pos >= (ssize_t) ctx->rest - ctx->padding) {
  1936.                 b->pos += ctx->rest - ctx->padding;
  1937.                 buf->last = b->pos;
  1938.                 ctx->rest = ctx->padding;

  1940.             } else {
  1941.                 ctx->rest -= b->last - b->pos;
  1942.                 b->pos = b->last;
  1943.                 buf->last = b->pos;
  1944.             }

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

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

  1955.                 ctx->length -= buf->last - buf->pos;
  1956.             }

  1958.             continue;
  1959.         }

  1961.         if (rc == NGX_DONE) {
  1962.             p->length = 0;
  1963.             break;
  1964.         }

  1966.         if (rc == NGX_AGAIN) {
  1967.             break;
  1968.         }

  1970.         /* invalid response */

  1972.         return NGX_ERROR;
  1973.     }

  1975.     if (buf) {
  1976.         buf->shadow = b;
  1977.         buf->last_shadow = 1;

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

  1982.         return NGX_OK;
  1983.     }

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

  1987.     if (ngx_event_pipe_add_free_buf(p, b) != NGX_OK) {
  1988.         return NGX_ERROR;
  1989.     }

  1991.     return NGX_OK;
  1992. }


  1995. static ngx_int_t
  1996. ‌ngx_http_proxy_v2_process_control_frame(ngx_http_request_t *r,
  1997.     ngx_http_proxy_v2_ctx_t *ctx, ngx_buf_t *b)
  1998. {
  1999.     ngx_int_t             rc;
  2000.     ngx_http_upstream_t  *u;

  2002.     u = r->upstream;

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

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

  2008.         if (rc == NGX_AGAIN) {
  2009.             return NGX_AGAIN;
  2010.         }

  2012.         if (rc == NGX_ERROR) {
  2013.             return NGX_ERROR;
  2014.         }

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

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

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

  2029.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2030.                           "upstream sent goaway with error %ui",
  2031.                           ctx->error);

  2033.             return NGX_ERROR;
  2034.         }

  2036.         ctx->goaway = 1;

  2038.         return NGX_OK;
  2039.     }

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

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

  2045.         if (rc == NGX_AGAIN) {
  2046.             return NGX_AGAIN;
  2047.         }

  2049.         if (rc == NGX_ERROR) {
  2050.             return NGX_ERROR;
  2051.         }

  2053.         if (ctx->in) {
  2054.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2055.         }

  2057.         return NGX_OK;
  2058.     }

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

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

  2064.         if (rc == NGX_AGAIN) {
  2065.             return NGX_AGAIN;
  2066.         }

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

  2072.         if (ctx->in) {
  2073.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2074.         }

  2076.         return NGX_OK;
  2077.     }

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

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

  2083.         if (rc == NGX_AGAIN) {
  2084.             return NGX_AGAIN;
  2085.         }

  2087.         if (rc == NGX_ERROR) {
  2088.             return NGX_ERROR;
  2089.         }

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

  2093.         return NGX_OK;
  2094.     }

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

  2102.     return NGX_DECLINED;
  2103. }


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

  2115.     b->pos += ctx->rest;
  2116.     ctx->rest = 0;
  2117.     ctx->state = ngx_http_proxy_v2_st_start;

  2119.     return NGX_OK;
  2120. }


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

  2131.     u = r->upstream;

  2133.     for ( ;; ) {

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

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

  2139.             if (rc == NGX_AGAIN) {

  2141.                 if (ctx->done) {

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

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

  2155.                     if (ctx->out) {
  2156.                         ngx_post_event(u->peer.connection->write,
  2157.                                        &ngx_posted_events);
  2158.                         return NGX_AGAIN;
  2159.                     }

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

  2170.                     return NGX_DONE;
  2171.                 }

  2173.                 return NGX_AGAIN;
  2174.             }

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

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

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

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

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

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

  2217.                 ctx->recv_window -= ctx->rest;
  2218.                 ctx->connection->recv_window -= ctx->rest;

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

  2229.                     ngx_post_event(u->peer.connection->write,
  2230.                                    &ngx_posted_events);
  2231.                 }
  2232.             }

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

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

  2251.             ctx->padding = 0;
  2252.         }

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

  2256.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2257.                 ctx->rest -= b->last - b->pos;
  2258.                 b->pos = b->last;
  2259.                 return NGX_AGAIN;
  2260.             }

  2262.             b->pos += ctx->rest;
  2263.             ctx->rest = 0;
  2264.             ctx->state = ngx_http_proxy_v2_st_start;

  2266.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2267.                 ctx->done = 1;
  2268.             }

  2270.             continue;
  2271.         }

  2273.         /* frame payload */

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

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

  2279.             if (rc == NGX_AGAIN) {
  2280.                 return NGX_AGAIN;
  2281.             }

  2283.             if (rc == NGX_ERROR) {
  2284.                 return NGX_ERROR;
  2285.             }

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

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

  2301.             ctx->rst = 1;

  2303.             continue;
  2304.         }

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

  2308.         if (rc == NGX_AGAIN) {
  2309.             return NGX_AGAIN;
  2310.         }

  2312.         if (rc == NGX_ERROR) {
  2313.             return NGX_ERROR;
  2314.         }

  2316.         if (rc == NGX_OK) {
  2317.             continue;
  2318.         }

  2320.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME
  2321.             || ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME)
  2322.         {
  2323.             for ( ;; ) {

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

  2327.                 if (rc == NGX_AGAIN) {
  2328.                     break;
  2329.                 }

  2331.                 if (rc == NGX_OK) {

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

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

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

  2347.                     h = ngx_list_push(&u->headers_in.trailers);
  2348.                     if (h == NULL) {
  2349.                         return NGX_ERROR;
  2350.                     }

  2352.                     h->key = ctx->name;
  2353.                     h->value = ctx->value;
  2354.                     h->lowcase_key = h->key.data;
  2355.                     h->hash = ngx_hash_key(h->key.data, h->key.len);

  2357.                     continue;
  2358.                 }

  2360.                 if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2367.                     if (ctx->end_stream) {
  2368.                         ctx->done = 1;
  2369.                         break;
  2370.                     }

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

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

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

  2383.                 return NGX_ERROR;
  2384.             }

  2386.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2387.                 continue;
  2388.             }

  2390.             /* rc == NGX_AGAIN */

  2392.             if (ctx->rest == 0) {
  2393.                 ctx->state = ngx_http_proxy_v2_st_start;
  2394.                 continue;
  2395.             }

  2397.             return NGX_AGAIN;
  2398.         }

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

  2402.             /* priority, unknown frames */

  2404.             rc = ngx_http_proxy_v2_skip_frame(ctx, b);

  2406.             if (rc == NGX_AGAIN) {
  2407.                 return NGX_AGAIN;
  2408.             }

  2410.             continue;
  2411.         }

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

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

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

  2433.             if (b->pos == b->last) {
  2434.                 return NGX_AGAIN;
  2435.             }

  2437.             ctx->flags &= ~NGX_HTTP_V2_PADDED_FLAG;
  2438.             ctx->padding = *b->pos++;
  2439.             ctx->rest -= 1;

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

  2449.             continue;
  2450.         }

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

  2454.             if (ctx->padding) {
  2455.                 ctx->state = ngx_http_proxy_v2_st_padding;

  2457.             } else {
  2458.                 ctx->state = ngx_http_proxy_v2_st_start;

  2460.                 if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2461.                     ctx->done = 1;
  2462.                 }
  2463.             }

  2465.             continue;
  2466.         }

  2468.         if (b->pos == b->last) {
  2469.             return NGX_AGAIN;
  2470.         }

  2472.         return NGX_OK;
  2473.     }
  2474. }


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

  2484.     state = ctx->state;

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

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

  2494.         switch (state) {

  2496.         case ngx_http_proxy_v2_st_start:
  2497.             ctx->rest = ch << 16;
  2498.             state = ngx_http_proxy_v2_st_length_2;
  2499.             break;

  2501.         case ngx_http_proxy_v2_st_length_2:
  2502.             ctx->rest |= ch << 8;
  2503.             state = ngx_http_proxy_v2_st_length_3;
  2504.             break;

  2506.         case ngx_http_proxy_v2_st_length_3:
  2507.             ctx->rest |= ch;

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

  2516.             state = ngx_http_proxy_v2_st_type;
  2517.             break;

  2519.         case ngx_http_proxy_v2_st_type:
  2520.             ctx->type = ch;
  2521.             state = ngx_http_proxy_v2_st_flags;
  2522.             break;

  2524.         case ngx_http_proxy_v2_st_flags:
  2525.             ctx->flags = ch;
  2526.             state = ngx_http_proxy_v2_st_stream_id;
  2527.             break;

  2529.         case ngx_http_proxy_v2_st_stream_id:
  2530.             ctx->stream_id = (ch & 0x7f) << 24;
  2531.             state = ngx_http_proxy_v2_st_stream_id_2;
  2532.             break;

  2534.         case ngx_http_proxy_v2_st_stream_id_2:
  2535.             ctx->stream_id |= ch << 16;
  2536.             state = ngx_http_proxy_v2_st_stream_id_3;
  2537.             break;

  2539.         case ngx_http_proxy_v2_st_stream_id_3:
  2540.             ctx->stream_id |= ch << 8;
  2541.             state = ngx_http_proxy_v2_st_stream_id_4;
  2542.             break;

  2544.         case ngx_http_proxy_v2_st_stream_id_4:
  2545.             ctx->stream_id |= ch;

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

  2551.             b->pos = p + 1;

  2553.             ctx->state = ngx_http_proxy_v2_st_payload;
  2554.             ctx->frame_state = 0;

  2556.             return NGX_OK;

  2558.         /* suppress warning */
  2559.         case ngx_http_proxy_v2_st_payload:
  2560.         case ngx_http_proxy_v2_st_padding:
  2561.             break;
  2562.         }
  2563.     }

  2565.     b->pos = p;
  2566.     ctx->state = state;

  2568.     return NGX_AGAIN;
  2569. }


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

  2591.     state = ctx->frame_state;

  2593.     if (state == sw_start) {

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

  2598.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME) {
  2599.             ctx->parsing_headers = 1;
  2600.             ctx->fragment_state = 0;
  2601.             ctx->header_limit = r->upstream->conf->buffer_size;

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

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

  2614.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2615.                 ctx->end_stream = 1;
  2616.             }

  2618.             if (ctx->flags & NGX_HTTP_V2_PADDED_FLAG) {
  2619.                 state = sw_padding_length;

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

  2624.             } else {
  2625.                 state = sw_fragment;
  2626.             }

  2628.         } else if (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME) {
  2629.             state = sw_fragment;
  2630.         }

  2632.         ctx->padding = 0;
  2633.         ctx->frame_state = state;
  2634.     }

  2636.     if (state < sw_fragment) {

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

  2641.         } else {
  2642.             last = b->pos + ctx->rest;
  2643.         }

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

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

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

  2669.             switch (state) {

  2671.             case sw_padding_length:

  2673.                 ctx->padding = ch;

  2675.                 if (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG) {
  2676.                     state = sw_dependency;
  2677.                     break;
  2678.                 }

  2680.                 goto fragment;

  2682.             case sw_dependency:
  2683.                 state = sw_dependency_2;
  2684.                 break;

  2686.             case sw_dependency_2:
  2687.                 state = sw_dependency_3;
  2688.                 break;

  2690.             case sw_dependency_3:
  2691.                 state = sw_dependency_4;
  2692.                 break;

  2694.             case sw_dependency_4:
  2695.                 state = sw_weight;
  2696.                 break;

  2698.             case sw_weight:
  2699.                 goto fragment;

  2701.             /* suppress warning */
  2702.             case sw_start:
  2703.             case sw_fragment:
  2704.             case sw_padding:
  2705.                 break;
  2706.             }
  2707.         }

  2709.         ctx->rest -= p - b->pos;
  2710.         b->pos = p;

  2712.         ctx->frame_state = state;
  2713.         return NGX_AGAIN;

  2715.     fragment:

  2717.         p++;
  2718.         ctx->rest -= p - b->pos;
  2719.         b->pos = p;

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

  2729.         state = sw_fragment;
  2730.         ctx->frame_state = state;
  2731.     }

  2733.     if (state == sw_fragment) {

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

  2737.         if (rc == NGX_AGAIN) {
  2738.             return NGX_AGAIN;
  2739.         }

  2741.         if (rc == NGX_ERROR) {
  2742.             return NGX_ERROR;
  2743.         }

  2745.         if (rc == NGX_OK) {
  2746.             return NGX_OK;
  2747.         }

  2749.         /* rc == NGX_DONE */

  2751.         state = sw_padding;
  2752.         ctx->frame_state = state;
  2753.     }

  2755.     if (state == sw_padding) {

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

  2759.             ctx->rest -= b->last - b->pos;
  2760.             b->pos = b->last;

  2762.             return NGX_AGAIN;
  2763.         }

  2765.         b->pos += ctx->rest;
  2766.         ctx->rest = 0;

  2768.         ctx->state = ngx_http_proxy_v2_st_start;

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

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

  2778.             ctx->parsing_headers = 0;

  2780.             return NGX_HTTP_PARSE_HEADER_DONE;
  2781.         }

  2783.         return NGX_AGAIN;
  2784.     }

  2786.     /* unreachable */

  2788.     return NGX_ERROR;
  2789. }


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

  2816.     /* header block fragment */

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

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

  2827.     } else {
  2828.         last = b->pos + ctx->rest - ctx->padding;
  2829.     }

  2831.     state = ctx->fragment_state;

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

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

  2841.         switch (state) {

  2843.         case sw_start:
  2844.             ctx->index = 0;

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

  2856.                 index = ch & ~0x80;

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

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

  2868.                 ctx->index = index;
  2869.                 ctx->literal = 0;

  2871.                 goto done;

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

  2900.                 index = ch & ~0xc0;

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

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

  2912.                 if (index == 0) {
  2913.                     state = sw_name_length;
  2914.                     break;
  2915.                 }

  2917.                 ctx->index = index;
  2918.                 ctx->literal = 1;

  2920.                 state = sw_value_length;
  2921.                 break;

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

  2933.                 size_update = ch & ~0xe0;

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

  2943.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2944.                                "http proxy table size update: %ui",
  2945.                                size_update);

  2947.                 break;

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

  2976.                 index = ch & ~0xf0;

  2978.                 if (index == 0x0f) {
  2979.                     ctx->index = index;
  2980.                     ctx->literal = 1;
  2981.                     state = sw_index;
  2982.                     break;
  2983.                 }

  2985.                 if (index == 0) {
  2986.                     state = sw_name_length;
  2987.                     break;
  2988.                 }

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

  2994.                 ctx->index = index;
  2995.                 ctx->literal = 1;

  2997.                 state = sw_value_length;
  2998.                 break;

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

  3027.                 index = ch & ~0xf0;

  3029.                 if (index == 0x0f) {
  3030.                     ctx->index = index;
  3031.                     ctx->literal = 1;
  3032.                     state = sw_index;
  3033.                     break;
  3034.                 }

  3036.                 if (index == 0) {
  3037.                     state = sw_name_length;
  3038.                     break;
  3039.                 }

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

  3045.                 ctx->index = index;
  3046.                 ctx->literal = 1;

  3048.                 state = sw_value_length;
  3049.                 break;
  3050.             }

  3052.             /* not reached */

  3054.             return NGX_ERROR;

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

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

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

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

  3076.             state = sw_value_length;
  3077.             break;

  3079.         case sw_name_length:
  3080.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3081.             ctx->field_length = ch & ~0x80;

  3083.             if (ctx->field_length == 0x7f) {
  3084.                 state = sw_name_length_2;
  3085.                 break;
  3086.             }

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

  3095.             state = sw_name;
  3096.             break;

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

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

  3106.             state = sw_name;
  3107.             break;

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

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

  3117.             state = sw_name;
  3118.             break;

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

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

  3130.             state = sw_name;
  3131.             break;

  3133.         case sw_name:
  3134.             ctx->name.len = ctx->field_huffman ?
  3135.                             ctx->field_length * 8 / 5 : ctx->field_length;

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

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

  3150.             ctx->field_end = ctx->name.data;
  3151.             ctx->field_rest = ctx->field_length;
  3152.             ctx->field_state = 0;

  3154.             state = sw_name_bytes;

  3156.             /* fall through */

  3158.         case sw_name_bytes:

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

  3167.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3168.             ctx->field_rest -= size;

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

  3182.                 ctx->name.len = ctx->field_end - ctx->name.data;
  3183.                 ctx->name.data[ctx->name.len] = '\0';

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

  3190.             p += size - 1;

  3192.             if (ctx->field_rest == 0) {
  3193.                 state = sw_value_length;
  3194.             }

  3196.             break;

  3198.         case sw_value_length:
  3199.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3200.             ctx->field_length = ch & ~0x80;

  3202.             if (ctx->field_length == 0x7f) {
  3203.                 state = sw_value_length_2;
  3204.                 break;
  3205.             }

  3207.             if (ctx->field_length == 0) {
  3208.                 ngx_str_set(&ctx->value, "");
  3209.                 goto done;
  3210.             }

  3212.             state = sw_value;
  3213.             break;

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

  3218.             if (ch & 0x80) {
  3219.                 state = sw_value_length_3;
  3220.                 break;
  3221.             }

  3223.             state = sw_value;
  3224.             break;

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

  3229.             if (ch & 0x80) {
  3230.                 state = sw_value_length_4;
  3231.                 break;
  3232.             }

  3234.             state = sw_value;
  3235.             break;

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

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

  3247.             state = sw_value;
  3248.             break;

  3250.         case sw_value:
  3251.             ctx->value.len = ctx->field_huffman ?
  3252.                              ctx->field_length * 8 / 5 : ctx->field_length;

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

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

  3267.             ctx->field_end = ctx->value.data;
  3268.             ctx->field_rest = ctx->field_length;
  3269.             ctx->field_state = 0;

  3271.             state = sw_value_bytes;

  3273.             /* fall through */

  3275.         case sw_value_bytes:

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

  3284.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3285.             ctx->field_rest -= size;

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

  3299.                 ctx->value.len = ctx->field_end - ctx->value.data;
  3300.                 ctx->value.data[ctx->value.len] = '\0';

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

  3307.             p += size - 1;

  3309.             if (ctx->field_rest == 0) {
  3310.                 goto done;
  3311.             }

  3313.             break;
  3314.         }

  3316.         continue;

  3318.     done:

  3320.         p++;
  3321.         ctx->rest -= p - b->pos;
  3322.         ctx->fragment_state = sw_start;
  3323.         b->pos = p;

  3325.         if (ctx->index) {
  3326.             ctx->name = *ngx_http_v2_get_static_name(ctx->index);
  3327.         }

  3329.         if (ctx->index && !ctx->literal) {
  3330.             ctx->value = *ngx_http_v2_get_static_value(ctx->index);
  3331.         }

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

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

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

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

  3363.         ctx->header_limit -= len;

  3365.         return NGX_OK;
  3366.     }

  3368.     ctx->rest -= p - b->pos;
  3369.     ctx->fragment_state = state;
  3370.     b->pos = p;

  3372.     if (ctx->rest > ctx->padding) {
  3373.         return NGX_AGAIN;
  3374.     }

  3376.     return NGX_DONE;
  3377. }


  3380. static ngx_int_t
  3381. ‌ngx_http_proxy_v2_validate_header_name(ngx_http_request_t *r, ngx_str_t *s)
  3382. {
  3383.     u_char      ch;
  3384.     ngx_uint_t  i;

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

  3389.         if (ch == ':' && i > 0) {
  3390.             return NGX_ERROR;
  3391.         }

  3393.         if (ch >= 'A' && ch <= 'Z') {
  3394.             return NGX_ERROR;
  3395.         }

  3397.         if (ch <= 0x20 || ch == 0x7f) {
  3398.             return NGX_ERROR;
  3399.         }
  3400.     }

  3402.     return NGX_OK;
  3403. }


  3406. static ngx_int_t
  3407. ‌ngx_http_proxy_v2_validate_header_value(ngx_http_request_t *r, ngx_str_t *s)
  3408. {
  3409.     u_char      ch;
  3410.     ngx_uint_t  i;

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

  3415.         if (ch == '\0' || ch == CR || ch == LF) {
  3416.             return NGX_ERROR;
  3417.         }
  3418.     }

  3420.     return NGX_OK;
  3421. }


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

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

  3439.     } else {
  3440.         last = b->pos + ctx->rest;
  3441.     }

  3443.     state = ctx->frame_state;

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

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

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

  3463.         switch (state) {

  3465.         case sw_start:
  3466.             ctx->error = (ngx_uint_t) ch << 24;
  3467.             state = sw_error_2;
  3468.             break;

  3470.         case sw_error_2:
  3471.             ctx->error |= ch << 16;
  3472.             state = sw_error_3;
  3473.             break;

  3475.         case sw_error_3:
  3476.             ctx->error |= ch << 8;
  3477.             state = sw_error_4;
  3478.             break;

  3480.         case sw_error_4:
  3481.             ctx->error |= ch;
  3482.             state = sw_start;

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

  3487.             break;
  3488.         }
  3489.     }

  3491.     ctx->rest -= p - b->pos;
  3492.     ctx->frame_state = state;
  3493.     b->pos = p;

  3495.     if (ctx->rest > 0) {
  3496.         return NGX_AGAIN;
  3497.     }

  3499.     ctx->state = ngx_http_proxy_v2_st_start;

  3501.     return NGX_OK;
  3502. }


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

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

  3525.     } else {
  3526.         last = b->pos + ctx->rest;
  3527.     }

  3529.     state = ctx->frame_state;

  3531.     if (state == sw_start) {

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

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

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

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

  3558.         switch (state) {

  3560.         case sw_start:
  3561.             ctx->stream_id = (ch & 0x7f) << 24;
  3562.             state = sw_last_stream_id_2;
  3563.             break;

  3565.         case sw_last_stream_id_2:
  3566.             ctx->stream_id |= ch << 16;
  3567.             state = sw_last_stream_id_3;
  3568.             break;

  3570.         case sw_last_stream_id_3:
  3571.             ctx->stream_id |= ch << 8;
  3572.             state = sw_last_stream_id_4;
  3573.             break;

  3575.         case sw_last_stream_id_4:
  3576.             ctx->stream_id |= ch;
  3577.             state = sw_error;
  3578.             break;

  3580.         case sw_error:
  3581.             ctx->error = (ngx_uint_t) ch << 24;
  3582.             state = sw_error_2;
  3583.             break;

  3585.         case sw_error_2:
  3586.             ctx->error |= ch << 16;
  3587.             state = sw_error_3;
  3588.             break;

  3590.         case sw_error_3:
  3591.             ctx->error |= ch << 8;
  3592.             state = sw_error_4;
  3593.             break;

  3595.         case sw_error_4:
  3596.             ctx->error |= ch;
  3597.             state = sw_debug;
  3598.             break;

  3600.         case sw_debug:
  3601.             break;
  3602.         }
  3603.     }

  3605.     ctx->rest -= p - b->pos;
  3606.     ctx->frame_state = state;
  3607.     b->pos = p;

  3609.     if (ctx->rest > 0) {
  3610.         return NGX_AGAIN;
  3611.     }

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

  3617.     ctx->state = ngx_http_proxy_v2_st_start;

  3619.     return NGX_OK;
  3620. }


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

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

  3638.     } else {
  3639.         last = b->pos + ctx->rest;
  3640.     }

  3642.     state = ctx->frame_state;

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

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

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

  3662.         switch (state) {

  3664.         case sw_start:
  3665.             ctx->window_update = (ch & 0x7f) << 24;
  3666.             state = sw_size_2;
  3667.             break;

  3669.         case sw_size_2:
  3670.             ctx->window_update |= ch << 16;
  3671.             state = sw_size_3;
  3672.             break;

  3674.         case sw_size_3:
  3675.             ctx->window_update |= ch << 8;
  3676.             state = sw_size_4;
  3677.             break;

  3679.         case sw_size_4:
  3680.             ctx->window_update |= ch;
  3681.             state = sw_start;
  3682.             break;
  3683.         }
  3684.     }

  3686.     ctx->rest -= p - b->pos;
  3687.     ctx->frame_state = state;
  3688.     b->pos = p;

  3690.     if (ctx->rest > 0) {
  3691.         return NGX_AGAIN;
  3692.     }

  3694.     ctx->state = ngx_http_proxy_v2_st_start;

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

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

  3705.     if (ctx->stream_id) {

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

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

  3717.     } else {

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

  3727.         ctx->connection->send_window += ctx->window_update;
  3728.     }

  3730.     return NGX_OK;
  3731. }


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

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

  3753.     } else {
  3754.         last = b->pos + ctx->rest;
  3755.     }

  3757.     state = ctx->frame_state;

  3759.     if (state == sw_start) {

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

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

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

  3781.             ctx->state = ngx_http_proxy_v2_st_start;

  3783.             return NGX_OK;
  3784.         }

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

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

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

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

  3809.         switch (state) {

  3811.         case sw_start:
  3812.         case sw_id:
  3813.             ctx->setting_id = ch << 8;
  3814.             state = sw_id_2;
  3815.             break;

  3817.         case sw_id_2:
  3818.             ctx->setting_id |= ch;
  3819.             state = sw_value;
  3820.             break;

  3822.         case sw_value:
  3823.             ctx->setting_value = (ngx_uint_t) ch << 24;
  3824.             state = sw_value_2;
  3825.             break;

  3827.         case sw_value_2:
  3828.             ctx->setting_value |= ch << 16;
  3829.             state = sw_value_3;
  3830.             break;

  3832.         case sw_value_3:
  3833.             ctx->setting_value |= ch << 8;
  3834.             state = sw_value_4;
  3835.             break;

  3837.         case sw_value_4:
  3838.             ctx->setting_value |= ch;
  3839.             state = sw_id;

  3841.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3842.                            "http proxy setting: %ui %ui",
  3843.                            ctx->setting_id, ctx->setting_value);

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

  3856.             if (ctx->setting_id == 0x04) {
  3857.                 /* SETTINGS_INITIAL_WINDOW_SIZE */

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

  3867.                 window_update = ctx->setting_value
  3868.                                 - ctx->connection->init_window;
  3869.                 ctx->connection->init_window = ctx->setting_value;

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

  3882.                 ctx->send_window += window_update;
  3883.             }

  3885.             break;
  3886.         }
  3887.     }

  3889.     ctx->rest -= p - b->pos;
  3890.     ctx->frame_state = state;
  3891.     b->pos = p;

  3893.     if (ctx->rest > 0) {
  3894.         return NGX_AGAIN;
  3895.     }

  3897.     ctx->state = ngx_http_proxy_v2_st_start;

  3899.     return ngx_http_proxy_v2_send_settings_ack(r, ctx);
  3900. }


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

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

  3922.     } else {
  3923.         last = b->pos + ctx->rest;
  3924.     }

  3926.     state = ctx->frame_state;

  3928.     if (state == sw_start) {

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

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

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

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

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

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

  3967.         if (state < sw_data_8) {
  3968.             ctx->ping_data[state] = ch;
  3969.             state++;

  3971.         } else {
  3972.             ctx->ping_data[7] = ch;
  3973.             state = sw_start;

  3975.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3976.                            "http proxy ping");
  3977.         }
  3978.     }

  3980.     ctx->rest -= p - b->pos;
  3981.     ctx->frame_state = state;
  3982.     b->pos = p;

  3984.     if (ctx->rest > 0) {
  3985.         return NGX_AGAIN;
  3986.     }

  3988.     ctx->state = ngx_http_proxy_v2_st_start;

  3990.     return ngx_http_proxy_v2_send_ping_ack(r, ctx);
  3991. }


  3994. static ngx_int_t
  3995. ‌ngx_http_proxy_v2_send_settings_ack(ngx_http_request_t *r,
  3996.     ngx_http_proxy_v2_ctx_t *ctx)
  3997. {
  3998.     ngx_chain_t                *cl, **ll;
  3999.     ngx_http_proxy_v2_frame_t  *f;

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

  4004.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4005.         ll = &cl->next;
  4006.     }

  4008.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  4009.     if (cl == NULL) {
  4010.         return NGX_ERROR;
  4011.     }

  4013.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4014.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

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

  4026.     *ll = cl;

  4028.     return NGX_OK;
  4029. }


  4032. static ngx_int_t
  4033. ‌ngx_http_proxy_v2_send_ping_ack(ngx_http_request_t *r,
  4034.     ngx_http_proxy_v2_ctx_t *ctx)
  4035. {
  4036.     ngx_chain_t                *cl, **ll;
  4037.     ngx_http_proxy_v2_frame_t  *f;

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

  4042.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4043.         ll = &cl->next;
  4044.     }

  4046.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  4047.     if (cl == NULL) {
  4048.         return NGX_ERROR;
  4049.     }

  4051.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4052.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

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

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

  4066.     *ll = cl;

  4068.     return NGX_OK;
  4069. }


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

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

  4084.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4085.         ll = &cl->next;
  4086.     }

  4088.     cl = ngx_http_proxy_v2_get_buf(r, ctx);
  4089.     if (cl == NULL) {
  4090.         return NGX_ERROR;
  4091.     }

  4093.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4094.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

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

  4106.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->connection->recv_window;
  4107.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4109.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4110.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4111.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4112.     *cl->buf->last++ = (u_char) (n & 0xff);

  4114.     f = (ngx_http_proxy_v2_frame_t *) cl->buf->last;
  4115.     cl->buf->last += sizeof(ngx_http_proxy_v2_frame_t);

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

  4127.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->recv_window;
  4128.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4130.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4131.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4132.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4133.     *cl->buf->last++ = (u_char) (n & 0xff);

  4135.     *ll = cl;

  4137.     return NGX_OK;
  4138. }


  4141. static ngx_chain_t *
  4142. ‌ngx_http_proxy_v2_get_buf(ngx_http_request_t *r, ngx_http_proxy_v2_ctx_t *ctx)
  4143. {
  4144.     u_char       *start;
  4145.     ngx_buf_t    *b;
  4146.     ngx_chain_t  *cl;

  4148.     cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  4149.     if (cl == NULL) {
  4150.         return NULL;
  4151.     }

  4153.     b = cl->buf;
  4154.     start = b->start;

  4156.     if (start == NULL) {

  4158.         /*
  4159.          * each buffer is large enough to hold two window update
  4160.          * frames in a row
  4161.          */

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

  4168.     }

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

  4172.     b->start = start;
  4173.     b->pos = start;
  4174.     b->last = start;
  4175.     b->end = start + 2 * sizeof(ngx_http_proxy_v2_frame_t) + 8;

  4177.     b->tag = (ngx_buf_tag_t) &ngx_http_proxy_v2_body_output_filter;
  4178.     b->temporary = 1;
  4179.     b->flush = 1;

  4181.     return cl;
  4182. }


  4185. static ngx_http_proxy_v2_ctx_t *
  4186. ‌ngx_http_proxy_v2_get_ctx(ngx_http_request_t *r)
  4187. {
  4188.     ngx_http_upstream_t      *u;
  4189.     ngx_http_proxy_v2_ctx_t  *ctx;

  4191.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_v2_module);

  4193.     if (ctx->connection == NULL) {
  4194.         u = r->upstream;

  4196.         if (ngx_http_proxy_v2_get_connection_data(r, ctx, &u->peer) != NGX_OK) {
  4197.             return NULL;
  4198.         }
  4199.     }

  4201.     return ctx;
  4202. }


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

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

  4218.         ctx->id = 0;

  4220.         goto done;
  4221.     }

  4223.     c = pc->connection;

  4225.     if (pc->cached) {

  4227.         /*
  4228.          * for cached connections, connection data can be found
  4229.          * in the cleanup handler
  4230.          */

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

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

  4246.         ctx->send_window = ctx->connection->init_window;
  4247.         ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4249.         ctx->connection->last_stream_id += 2;
  4250.         ctx->id = ctx->connection->last_stream_id;

  4252.         return NGX_OK;
  4253.     }

  4255.     cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_proxy_v2_conn_t));
  4256.     if (cln == NULL) {
  4257.         return NGX_ERROR;
  4258.     }

  4260.     cln->handler = ngx_http_proxy_v2_cleanup;
  4261.     ctx->connection = cln->data;

  4263.     ctx->id = 1;

  4265. done:

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

  4271.     ctx->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4272.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

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

  4276.     return NGX_OK;
  4277. }


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


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


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


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

One Level Up Top Level