One Level Up Top Level

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

Global variables defined

Data types defined

Functions defined

Source code


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


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


  13. ‌typedef struct {
  14.     ngx_array_t               *flushes;
  15.     ngx_array_t               *lengths;
  16.     ngx_array_t               *values;
  17.     ngx_hash_t                 hash;
  18. ‌} ngx_http_grpc_headers_t;


  21. ‌typedef struct {
  22.     ngx_http_upstream_conf_t   upstream;

  24.     ngx_http_grpc_headers_t    headers;
  25.     ngx_array_t               *headers_source;

  27.     ngx_str_t                  host;
  28.     ngx_uint_t                 host_set;

  30.     ngx_array_t               *grpc_lengths;
  31.     ngx_array_t               *grpc_values;

  33. #if (NGX_HTTP_SSL)
  34.     ngx_uint_t                 ssl;
  35.     ngx_uint_t                 ssl_protocols;
  36.     ngx_str_t                  ssl_ciphers;
  37.     ngx_uint_t                 ssl_verify_depth;
  38.     ngx_str_t                  ssl_trusted_certificate;
  39.     ngx_str_t                  ssl_crl;
  40.     ngx_array_t               *ssl_conf_commands;
  41. #endif
  42. ‌} ngx_http_grpc_loc_conf_t;


  45. ‌typedef enum {
  46.     ngx_http_grpc_st_start = 0,
  47.     ngx_http_grpc_st_length_2,
  48.     ngx_http_grpc_st_length_3,
  49.     ngx_http_grpc_st_type,
  50.     ngx_http_grpc_st_flags,
  51.     ngx_http_grpc_st_stream_id,
  52.     ngx_http_grpc_st_stream_id_2,
  53.     ngx_http_grpc_st_stream_id_3,
  54.     ngx_http_grpc_st_stream_id_4,
  55.     ngx_http_grpc_st_payload,
  56.     ngx_http_grpc_st_padding
  57. ‌} ngx_http_grpc_state_e;


  60. ‌typedef struct {
  61.     size_t                     init_window;
  62.     size_t                     send_window;
  63.     size_t                     recv_window;
  64.     ngx_uint_t                 last_stream_id;
  65. ‌} ngx_http_grpc_conn_t;


  68. ‌typedef struct {
  69.     ngx_http_grpc_state_e      state;
  70.     ngx_uint_t                 frame_state;
  71.     ngx_uint_t                 fragment_state;

  73.     ngx_chain_t               *in;
  74.     ngx_chain_t               *out;
  75.     ngx_chain_t               *free;
  76.     ngx_chain_t               *busy;

  78.     ngx_http_grpc_conn_t      *connection;

  80.     ngx_uint_t                 id;

  82.     ngx_uint_t                 pings;
  83.     ngx_uint_t                 settings;

  85.     off_t                      length;

  87.     ssize_t                    send_window;
  88.     size_t                     recv_window;

  90.     size_t                     rest;
  91.     ngx_uint_t                 stream_id;
  92.     u_char                     type;
  93.     u_char                     flags;
  94.     u_char                     padding;

  96.     ngx_uint_t                 error;
  97.     ngx_uint_t                 window_update;

  99.     ngx_uint_t                 setting_id;
  100.     ngx_uint_t                 setting_value;

  102.     u_char                     ping_data[8];

  104.     ngx_uint_t                 index;
  105.     ngx_str_t                  name;
  106.     ngx_str_t                  value;

  108.     u_char                    *field_end;
  109.     size_t                     field_length;
  110.     size_t                     field_rest;
  111.     u_char                     field_state;

  113.     unsigned                   literal:1;
  114.     unsigned                   field_huffman:1;

  116.     unsigned                   header_sent:1;
  117.     unsigned                   output_closed:1;
  118.     unsigned                   output_blocked:1;
  119.     unsigned                   parsing_headers:1;
  120.     unsigned                   end_stream:1;
  121.     unsigned                   done:1;
  122.     unsigned                   status:1;
  123.     unsigned                   rst:1;
  124.     unsigned                   goaway:1;

  126.     ngx_http_request_t        *request;

  128.     ngx_str_t                  host;
  129. ‌} ngx_http_grpc_ctx_t;


  132. ‌typedef struct {
  133.     u_char                     length_0;
  134.     u_char                     length_1;
  135.     u_char                     length_2;
  136.     u_char                     type;
  137.     u_char                     flags;
  138.     u_char                     stream_id_0;
  139.     u_char                     stream_id_1;
  140.     u_char                     stream_id_2;
  141.     u_char                     stream_id_3;
  142. ‌} ngx_http_grpc_frame_t;


  145. static ngx_int_t ngx_http_grpc_eval(ngx_http_request_t *r,
  146.     ngx_http_grpc_ctx_t *ctx, ngx_http_grpc_loc_conf_t *glcf);
  147. static ngx_int_t ngx_http_grpc_create_request(ngx_http_request_t *r);
  148. static ngx_int_t ngx_http_grpc_reinit_request(ngx_http_request_t *r);
  149. static ngx_int_t ngx_http_grpc_body_output_filter(void *data, ngx_chain_t *in);
  150. static ngx_int_t ngx_http_grpc_process_header(ngx_http_request_t *r);
  151. static ngx_int_t ngx_http_grpc_filter_init(void *data);
  152. static ngx_int_t ngx_http_grpc_filter(void *data, ssize_t bytes);

  154. static ngx_int_t ngx_http_grpc_parse_frame(ngx_http_request_t *r,
  155.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b);
  156. static ngx_int_t ngx_http_grpc_parse_header(ngx_http_request_t *r,
  157.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b);
  158. static ngx_int_t ngx_http_grpc_parse_fragment(ngx_http_request_t *r,
  159.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b);
  160. static ngx_int_t ngx_http_grpc_validate_header_name(ngx_http_request_t *r,
  161.     ngx_str_t *s);
  162. static ngx_int_t ngx_http_grpc_validate_header_value(ngx_http_request_t *r,
  163.     ngx_str_t *s);
  164. static ngx_int_t ngx_http_grpc_parse_rst_stream(ngx_http_request_t *r,
  165.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b);
  166. static ngx_int_t ngx_http_grpc_parse_goaway(ngx_http_request_t *r,
  167.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b);
  168. static ngx_int_t ngx_http_grpc_parse_window_update(ngx_http_request_t *r,
  169.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b);
  170. static ngx_int_t ngx_http_grpc_parse_settings(ngx_http_request_t *r,
  171.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b);
  172. static ngx_int_t ngx_http_grpc_parse_ping(ngx_http_request_t *r,
  173.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b);

  175. static ngx_int_t ngx_http_grpc_send_settings_ack(ngx_http_request_t *r,
  176.     ngx_http_grpc_ctx_t *ctx);
  177. static ngx_int_t ngx_http_grpc_send_ping_ack(ngx_http_request_t *r,
  178.     ngx_http_grpc_ctx_t *ctx);
  179. static ngx_int_t ngx_http_grpc_send_window_update(ngx_http_request_t *r,
  180.     ngx_http_grpc_ctx_t *ctx);

  182. static ngx_chain_t *ngx_http_grpc_get_buf(ngx_http_request_t *r,
  183.     ngx_http_grpc_ctx_t *ctx);
  184. static ngx_http_grpc_ctx_t *ngx_http_grpc_get_ctx(ngx_http_request_t *r);
  185. static ngx_int_t ngx_http_grpc_get_connection_data(ngx_http_request_t *r,
  186.     ngx_http_grpc_ctx_t *ctx, ngx_peer_connection_t *pc);
  187. static void ngx_http_grpc_cleanup(void *data);

  189. static void ngx_http_grpc_abort_request(ngx_http_request_t *r);
  190. static void ngx_http_grpc_finalize_request(ngx_http_request_t *r,
  191.     ngx_int_t rc);

  193. static ngx_int_t ngx_http_grpc_internal_trailers_variable(
  194.     ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);

  196. static ngx_int_t ngx_http_grpc_add_variables(ngx_conf_t *cf);
  197. static void *ngx_http_grpc_create_loc_conf(ngx_conf_t *cf);
  198. static char *ngx_http_grpc_merge_loc_conf(ngx_conf_t *cf,
  199.     void *parent, void *child);
  200. static ngx_int_t ngx_http_grpc_init_headers(ngx_conf_t *cf,
  201.     ngx_http_grpc_loc_conf_t *conf, ngx_http_grpc_headers_t *headers,
  202.     ngx_keyval_t *default_headers);

  204. static char *ngx_http_grpc_pass(ngx_conf_t *cf, ngx_command_t *cmd,
  205.     void *conf);

  207. #if (NGX_HTTP_SSL)
  208. static char *ngx_http_grpc_ssl_certificate_cache(ngx_conf_t *cf,
  209.     ngx_command_t *cmd, void *conf);
  210. static char *ngx_http_grpc_ssl_password_file(ngx_conf_t *cf,
  211.     ngx_command_t *cmd, void *conf);
  212. static char *ngx_http_grpc_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  213.     void *data);
  214. static ngx_int_t ngx_http_grpc_merge_ssl(ngx_conf_t *cf,
  215.     ngx_http_grpc_loc_conf_t *conf, ngx_http_grpc_loc_conf_t *prev);
  216. static ngx_int_t ngx_http_grpc_set_ssl(ngx_conf_t *cf,
  217.     ngx_http_grpc_loc_conf_t *glcf);
  218. #endif


  221. ‌static ngx_conf_bitmask_t  ngx_http_grpc_next_upstream_masks[] = {
  222.     { ngx_string("error"), NGX_HTTP_UPSTREAM_FT_ERROR },
  223.     { ngx_string("timeout"), NGX_HTTP_UPSTREAM_FT_TIMEOUT },
  224.     { ngx_string("invalid_header"), NGX_HTTP_UPSTREAM_FT_INVALID_HEADER },
  225.     { ngx_string("non_idempotent"), NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT },
  226.     { ngx_string("http_500"), NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  227.     { ngx_string("http_502"), NGX_HTTP_UPSTREAM_FT_HTTP_502 },
  228.     { ngx_string("http_503"), NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  229.     { ngx_string("http_504"), NGX_HTTP_UPSTREAM_FT_HTTP_504 },
  230.     { ngx_string("http_403"), NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  231.     { ngx_string("http_404"), NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  232.     { ngx_string("http_429"), NGX_HTTP_UPSTREAM_FT_HTTP_429 },
  233.     { ngx_string("off"), NGX_HTTP_UPSTREAM_FT_OFF },
  234.     { ngx_null_string, 0 }
  235. };


  238. #if (NGX_HTTP_SSL)

  240. ‌static ngx_conf_bitmask_t  ngx_http_grpc_ssl_protocols[] = {
  241.     { ngx_string("SSLv2"), NGX_SSL_SSLv2 },
  242.     { ngx_string("SSLv3"), NGX_SSL_SSLv3 },
  243.     { ngx_string("TLSv1"), NGX_SSL_TLSv1 },
  244.     { ngx_string("TLSv1.1"), NGX_SSL_TLSv1_1 },
  245.     { ngx_string("TLSv1.2"), NGX_SSL_TLSv1_2 },
  246.     { ngx_string("TLSv1.3"), NGX_SSL_TLSv1_3 },
  247.     { ngx_null_string, 0 }
  248. };

  250. ‌static ngx_conf_post_t  ngx_http_grpc_ssl_conf_command_post =
  251.     { ngx_http_grpc_ssl_conf_command_check };

  253. #endif


  256. ‌static ngx_command_t  ngx_http_grpc_commands[] = {

  258.     { ngx_string("grpc_pass"),
  259.       NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
  260.       ngx_http_grpc_pass,
  261.       NGX_HTTP_LOC_CONF_OFFSET,
  262.       0,
  263.       NULL },

  265.     { ngx_string("grpc_bind"),
  266.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  267.       ngx_http_upstream_bind_set_slot,
  268.       NGX_HTTP_LOC_CONF_OFFSET,
  269.       offsetof(ngx_http_grpc_loc_conf_t, upstream.local),
  270.       NULL },

  272.     { ngx_string("grpc_socket_keepalive"),
  273.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  274.       ngx_conf_set_flag_slot,
  275.       NGX_HTTP_LOC_CONF_OFFSET,
  276.       offsetof(ngx_http_grpc_loc_conf_t, upstream.socket_keepalive),
  277.       NULL },

  279.     { ngx_string("grpc_connect_timeout"),
  280.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  281.       ngx_conf_set_msec_slot,
  282.       NGX_HTTP_LOC_CONF_OFFSET,
  283.       offsetof(ngx_http_grpc_loc_conf_t, upstream.connect_timeout),
  284.       NULL },

  286.     { ngx_string("grpc_send_timeout"),
  287.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  288.       ngx_conf_set_msec_slot,
  289.       NGX_HTTP_LOC_CONF_OFFSET,
  290.       offsetof(ngx_http_grpc_loc_conf_t, upstream.send_timeout),
  291.       NULL },

  293.     { ngx_string("grpc_intercept_errors"),
  294.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  295.       ngx_conf_set_flag_slot,
  296.       NGX_HTTP_LOC_CONF_OFFSET,
  297.       offsetof(ngx_http_grpc_loc_conf_t, upstream.intercept_errors),
  298.       NULL },

  300.     { ngx_string("grpc_buffer_size"),
  301.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  302.       ngx_conf_set_size_slot,
  303.       NGX_HTTP_LOC_CONF_OFFSET,
  304.       offsetof(ngx_http_grpc_loc_conf_t, upstream.buffer_size),
  305.       NULL },

  307.     { ngx_string("grpc_read_timeout"),
  308.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  309.       ngx_conf_set_msec_slot,
  310.       NGX_HTTP_LOC_CONF_OFFSET,
  311.       offsetof(ngx_http_grpc_loc_conf_t, upstream.read_timeout),
  312.       NULL },

  314.     { ngx_string("grpc_next_upstream"),
  315.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  316.       ngx_conf_set_bitmask_slot,
  317.       NGX_HTTP_LOC_CONF_OFFSET,
  318.       offsetof(ngx_http_grpc_loc_conf_t, upstream.next_upstream),
  319.       &ngx_http_grpc_next_upstream_masks },

  321.     { ngx_string("grpc_next_upstream_tries"),
  322.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  323.       ngx_conf_set_num_slot,
  324.       NGX_HTTP_LOC_CONF_OFFSET,
  325.       offsetof(ngx_http_grpc_loc_conf_t, upstream.next_upstream_tries),
  326.       NULL },

  328.     { ngx_string("grpc_next_upstream_timeout"),
  329.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  330.       ngx_conf_set_msec_slot,
  331.       NGX_HTTP_LOC_CONF_OFFSET,
  332.       offsetof(ngx_http_grpc_loc_conf_t, upstream.next_upstream_timeout),
  333.       NULL },

  335.     { ngx_string("grpc_set_header"),
  336.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  337.       ngx_conf_set_keyval_slot,
  338.       NGX_HTTP_LOC_CONF_OFFSET,
  339.       offsetof(ngx_http_grpc_loc_conf_t, headers_source),
  340.       NULL },

  342.     { ngx_string("grpc_pass_header"),
  343.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  344.       ngx_conf_set_str_array_slot,
  345.       NGX_HTTP_LOC_CONF_OFFSET,
  346.       offsetof(ngx_http_grpc_loc_conf_t, upstream.pass_headers),
  347.       NULL },

  349.     { ngx_string("grpc_hide_header"),
  350.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  351.       ngx_conf_set_str_array_slot,
  352.       NGX_HTTP_LOC_CONF_OFFSET,
  353.       offsetof(ngx_http_grpc_loc_conf_t, upstream.hide_headers),
  354.       NULL },

  356.     { ngx_string("grpc_ignore_headers"),
  357.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  358.       ngx_conf_set_bitmask_slot,
  359.       NGX_HTTP_LOC_CONF_OFFSET,
  360.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ignore_headers),
  361.       &ngx_http_upstream_ignore_headers_masks },

  363. #if (NGX_HTTP_SSL)

  365.     { ngx_string("grpc_ssl_session_reuse"),
  366.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  367.       ngx_conf_set_flag_slot,
  368.       NGX_HTTP_LOC_CONF_OFFSET,
  369.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_session_reuse),
  370.       NULL },

  372.     { ngx_string("grpc_ssl_protocols"),
  373.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  374.       ngx_conf_set_bitmask_slot,
  375.       NGX_HTTP_LOC_CONF_OFFSET,
  376.       offsetof(ngx_http_grpc_loc_conf_t, ssl_protocols),
  377.       &ngx_http_grpc_ssl_protocols },

  379.     { ngx_string("grpc_ssl_ciphers"),
  380.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  381.       ngx_conf_set_str_slot,
  382.       NGX_HTTP_LOC_CONF_OFFSET,
  383.       offsetof(ngx_http_grpc_loc_conf_t, ssl_ciphers),
  384.       NULL },

  386.     { ngx_string("grpc_ssl_name"),
  387.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  388.       ngx_http_set_complex_value_slot,
  389.       NGX_HTTP_LOC_CONF_OFFSET,
  390.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_name),
  391.       NULL },

  393.     { ngx_string("grpc_ssl_server_name"),
  394.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  395.       ngx_conf_set_flag_slot,
  396.       NGX_HTTP_LOC_CONF_OFFSET,
  397.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_server_name),
  398.       NULL },

  400.     { ngx_string("grpc_ssl_verify"),
  401.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  402.       ngx_conf_set_flag_slot,
  403.       NGX_HTTP_LOC_CONF_OFFSET,
  404.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_verify),
  405.       NULL },

  407.     { ngx_string("grpc_ssl_verify_depth"),
  408.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  409.       ngx_conf_set_num_slot,
  410.       NGX_HTTP_LOC_CONF_OFFSET,
  411.       offsetof(ngx_http_grpc_loc_conf_t, ssl_verify_depth),
  412.       NULL },

  414.     { ngx_string("grpc_ssl_trusted_certificate"),
  415.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  416.       ngx_conf_set_str_slot,
  417.       NGX_HTTP_LOC_CONF_OFFSET,
  418.       offsetof(ngx_http_grpc_loc_conf_t, ssl_trusted_certificate),
  419.       NULL },

  421.     { ngx_string("grpc_ssl_crl"),
  422.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  423.       ngx_conf_set_str_slot,
  424.       NGX_HTTP_LOC_CONF_OFFSET,
  425.       offsetof(ngx_http_grpc_loc_conf_t, ssl_crl),
  426.       NULL },

  428.     { ngx_string("grpc_ssl_certificate"),
  429.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  430.       ngx_http_set_complex_value_zero_slot,
  431.       NGX_HTTP_LOC_CONF_OFFSET,
  432.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_certificate),
  433.       NULL },

  435.     { ngx_string("grpc_ssl_certificate_key"),
  436.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  437.       ngx_http_set_complex_value_zero_slot,
  438.       NGX_HTTP_LOC_CONF_OFFSET,
  439.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_certificate_key),
  440.       NULL },

  442.     { ngx_string("grpc_ssl_certificate_cache"),
  443.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  444.       ngx_http_grpc_ssl_certificate_cache,
  445.       NGX_HTTP_LOC_CONF_OFFSET,
  446.       0,
  447.       NULL },

  449.     { ngx_string("grpc_ssl_password_file"),
  450.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  451.       ngx_http_grpc_ssl_password_file,
  452.       NGX_HTTP_LOC_CONF_OFFSET,
  453.       0,
  454.       NULL },

  456.     { ngx_string("grpc_ssl_conf_command"),
  457.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  458.       ngx_conf_set_keyval_slot,
  459.       NGX_HTTP_LOC_CONF_OFFSET,
  460.       offsetof(ngx_http_grpc_loc_conf_t, ssl_conf_commands),
  461.       &ngx_http_grpc_ssl_conf_command_post },

  463. #endif

  465.       ngx_null_command
  466. };


  469. ‌static ngx_http_module_t  ngx_http_grpc_module_ctx = {
  470.     ngx_http_grpc_add_variables,           /* preconfiguration */
  471.     NULL,                                  /* postconfiguration */

  473.     NULL,                                  /* create main configuration */
  474.     NULL,                                  /* init main configuration */

  476.     NULL,                                  /* create server configuration */
  477.     NULL,                                  /* merge server configuration */

  479.     ngx_http_grpc_create_loc_conf,         /* create location configuration */
  480.     ngx_http_grpc_merge_loc_conf           /* merge location configuration */
  481. };


  484. ‌ngx_module_t  ngx_http_grpc_module = {
  485.     NGX_MODULE_V1,
  486.     &ngx_http_grpc_module_ctx,             /* module context */
  487.     ngx_http_grpc_commands,                /* module directives */
  488.     NGX_HTTP_MODULE,                       /* module type */
  489.     NULL,                                  /* init master */
  490.     NULL,                                  /* init module */
  491.     NULL,                                  /* init process */
  492.     NULL,                                  /* init thread */
  493.     NULL,                                  /* exit thread */
  494.     NULL,                                  /* exit process */
  495.     NULL,                                  /* exit master */
  496.     NGX_MODULE_V1_PADDING
  497. };


  500. ‌static u_char  ngx_http_grpc_connection_start[] =
  501.     "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"         /* connection preface */

  503.     "\x00\x00\x12\x04\x00\x00\x00\x00\x00"     /* settings frame */
  504.     "\x00\x01\x00\x00\x00\x00"                 /* header table size */
  505.     "\x00\x02\x00\x00\x00\x00"                 /* disable push */
  506.     "\x00\x04\x7f\xff\xff\xff"                 /* initial window */

  508.     "\x00\x00\x04\x08\x00\x00\x00\x00\x00"     /* window update frame */
  509.     "\x7f\xff\x00\x00";


  512. ‌static ngx_keyval_t  ngx_http_grpc_headers[] = {
  513.     { ngx_string("Content-Length"), ngx_string("$content_length") },
  514.     { ngx_string("TE"), ngx_string("$grpc_internal_trailers") },
  515.     { ngx_string("Host"), ngx_string("") },
  516.     { ngx_string("Connection"), ngx_string("") },
  517.     { ngx_string("Proxy-Connection"), ngx_string("") },
  518.     { ngx_string("Transfer-Encoding"), ngx_string("") },
  519.     { ngx_string("Keep-Alive"), ngx_string("") },
  520.     { ngx_string("Expect"), ngx_string("") },
  521.     { ngx_string("Upgrade"), ngx_string("") },
  522.     { ngx_null_string, ngx_null_string }
  523. };


  526. ‌static ngx_str_t  ngx_http_grpc_hide_headers[] = {
  527.     ngx_string("Date"),
  528.     ngx_string("Server"),
  529.     ngx_string("X-Accel-Expires"),
  530.     ngx_string("X-Accel-Redirect"),
  531.     ngx_string("X-Accel-Limit-Rate"),
  532.     ngx_string("X-Accel-Buffering"),
  533.     ngx_string("X-Accel-Charset"),
  534.     ngx_null_string
  535. };


  538. ‌static ngx_http_variable_t  ngx_http_grpc_vars[] = {

  540.     { ngx_string("grpc_internal_trailers"), NULL,
  541.       ngx_http_grpc_internal_trailers_variable, 0,
  542.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  544.       ngx_http_null_variable
  545. };


  548. static ngx_int_t
  549. ‌ngx_http_grpc_handler(ngx_http_request_t *r)
  550. {
  551.     ngx_int_t                  rc;
  552.     ngx_http_upstream_t       *u;
  553.     ngx_http_grpc_ctx_t       *ctx;
  554.     ngx_http_grpc_loc_conf_t  *glcf;

  556.     if (ngx_http_upstream_create(r) != NGX_OK) {
  557.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  558.     }

  560.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_grpc_ctx_t));
  561.     if (ctx == NULL) {
  562.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  563.     }

  565.     ctx->request = r;

  567.     ngx_http_set_ctx(r, ctx, ngx_http_grpc_module);

  569.     glcf = ngx_http_get_module_loc_conf(r, ngx_http_grpc_module);

  571.     u = r->upstream;

  573.     if (glcf->grpc_lengths == NULL) {
  574.         ctx->host = glcf->host;

  576. #if (NGX_HTTP_SSL)
  577.         u->ssl = glcf->ssl;

  579.         if (u->ssl) {
  580.             ngx_str_set(&u->schema, "grpcs://");

  582.         } else {
  583.             ngx_str_set(&u->schema, "grpc://");
  584.         }
  585. #else
  586.         ngx_str_set(&u->schema, "grpc://");
  587. #endif

  589.     } else {
  590.         if (ngx_http_grpc_eval(r, ctx, glcf) != NGX_OK) {
  591.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  592.         }
  593.     }

  595.     u->output.tag = (ngx_buf_tag_t) &ngx_http_grpc_module;

  597.     u->conf = &glcf->upstream;

  599.     u->create_request = ngx_http_grpc_create_request;
  600.     u->reinit_request = ngx_http_grpc_reinit_request;
  601.     u->process_header = ngx_http_grpc_process_header;
  602.     u->abort_request = ngx_http_grpc_abort_request;
  603.     u->finalize_request = ngx_http_grpc_finalize_request;

  605.     u->input_filter_init = ngx_http_grpc_filter_init;
  606.     u->input_filter = ngx_http_grpc_filter;
  607.     u->input_filter_ctx = ctx;

  609.     r->request_body_no_buffering = 1;

  611.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  613.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  614.         return rc;
  615.     }

  617.     return NGX_DONE;
  618. }


  621. static ngx_int_t
  622. ‌ngx_http_grpc_eval(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  623.     ngx_http_grpc_loc_conf_t *glcf)
  624. {
  625.     size_t                add;
  626.     ngx_url_t             url;
  627.     ngx_http_upstream_t  *u;

  629.     ngx_memzero(&url, sizeof(ngx_url_t));

  631.     if (ngx_http_script_run(r, &url.url, glcf->grpc_lengths->elts, 0,
  632.                             glcf->grpc_values->elts)
  633.         == NULL)
  634.     {
  635.         return NGX_ERROR;
  636.     }

  638.     if (url.url.len > 7
  639.         && ngx_strncasecmp(url.url.data, (u_char *) "grpc://", 7) == 0)
  640.     {
  641.         add = 7;

  643.     } else if (url.url.len > 8
  644.                && ngx_strncasecmp(url.url.data, (u_char *) "grpcs://", 8) == 0)
  645.     {

  647. #if (NGX_HTTP_SSL)
  648.         add = 8;
  649.         r->upstream->ssl = 1;
  650. #else
  651.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  652.                       "grpcs protocol requires SSL support");
  653.         return NGX_ERROR;
  654. #endif

  656.     } else {
  657.         add = 0;
  658.     }

  660.     u = r->upstream;

  662.     if (add) {
  663.         u->schema.len = add;
  664.         u->schema.data = url.url.data;

  666.         url.url.data += add;
  667.         url.url.len -= add;

  669.     } else {
  670.         ngx_str_set(&u->schema, "grpc://");
  671.     }

  673.     url.no_resolve = 1;

  675.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  676.         if (url.err) {
  677.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  678.                           "%s in upstream \"%V\"", url.err, &url.url);
  679.         }

  681.         return NGX_ERROR;
  682.     }

  684.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  685.     if (u->resolved == NULL) {
  686.         return NGX_ERROR;
  687.     }

  689.     if (url.addrs) {
  690.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  691.         u->resolved->socklen = url.addrs[0].socklen;
  692.         u->resolved->name = url.addrs[0].name;
  693.         u->resolved->naddrs = 1;
  694.     }

  696.     u->resolved->host = url.host;
  697.     u->resolved->port = url.port;
  698.     u->resolved->no_port = url.no_port;

  700.     if (url.family != AF_UNIX) {

  702.         if (url.no_port) {
  703.             ctx->host = url.host;

  705.         } else {
  706.             ctx->host.len = url.host.len + 1 + url.port_text.len;
  707.             ctx->host.data = url.host.data;
  708.         }

  710.     } else {
  711.         ngx_str_set(&ctx->host, "localhost");
  712.     }

  714.     return NGX_OK;
  715. }


  718. static ngx_int_t
  719. ‌ngx_http_grpc_create_request(ngx_http_request_t *r)
  720. {
  721.     u_char                       *p, *tmp, *key_tmp, *val_tmp, *headers_frame;
  722.     size_t                        len, tmp_len, key_len, val_len, uri_len;
  723.     uintptr_t                     escape;
  724.     ngx_buf_t                    *b;
  725.     ngx_uint_t                    i, next;
  726.     ngx_chain_t                  *cl, *body;
  727.     ngx_list_part_t              *part;
  728.     ngx_table_elt_t              *header;
  729.     ngx_http_grpc_ctx_t          *ctx;
  730.     ngx_http_upstream_t          *u;
  731.     ngx_http_grpc_frame_t        *f;
  732.     ngx_http_script_code_pt       code;
  733.     ngx_http_grpc_loc_conf_t     *glcf;
  734.     ngx_http_script_engine_t      e, le;
  735.     ngx_http_script_len_code_pt   lcode;

  737.     u = r->upstream;

  739.     glcf = ngx_http_get_module_loc_conf(r, ngx_http_grpc_module);

  741.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

  743.     len = sizeof(ngx_http_grpc_connection_start) - 1
  744.           + sizeof(ngx_http_grpc_frame_t);             /* headers frame */

  746.     /* :method header */

  748.     if (r->method == NGX_HTTP_GET || r->method == NGX_HTTP_POST) {
  749.         len += 1;
  750.         tmp_len = 0;

  752.     } else {
  753.         if (r->method_name.len > NGX_HTTP_V2_MAX_FIELD) {
  754.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  755.                           "too long http2 method: \"%V\"", &r->method_name);
  756.             return NGX_ERROR;
  757.         }

  759.         len += 1 + NGX_HTTP_V2_INT_OCTETS + r->method_name.len;
  760.         tmp_len = r->method_name.len;
  761.     }

  763.     /* :scheme header */

  765.     len += 1;

  767.     /* :path header */

  769.     if (r->valid_unparsed_uri) {
  770.         escape = 0;
  771.         uri_len = r->unparsed_uri.len;

  773.     } else {
  774.         escape = 2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len,
  775.                                     NGX_ESCAPE_URI);
  776.         uri_len = r->uri.len + escape + sizeof("?") - 1 + r->args.len;
  777.     }

  779.     if (uri_len > NGX_HTTP_V2_MAX_FIELD) {
  780.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  781.                       "too long http2 URI");
  782.         return NGX_ERROR;
  783.     }

  785.     len += 1 + NGX_HTTP_V2_INT_OCTETS + uri_len;

  787.     if (tmp_len < uri_len) {
  788.         tmp_len = uri_len;
  789.     }

  791.     /* :authority header */

  793.     if (!glcf->host_set) {
  794.         if (ctx->host.len > NGX_HTTP_V2_MAX_FIELD) {
  795.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  796.                           "too long http2 host: \"%V\"", &ctx->host);
  797.             return NGX_ERROR;
  798.         }

  800.         len += 1 + NGX_HTTP_V2_INT_OCTETS + ctx->host.len;

  802.         if (tmp_len < ctx->host.len) {
  803.             tmp_len = ctx->host.len;
  804.         }
  805.     }

  807.     /* other headers */

  809.     ngx_http_script_flush_no_cacheable_variables(r, glcf->headers.flushes);
  810.     ngx_memzero(&le, sizeof(ngx_http_script_engine_t));

  812.     le.ip = glcf->headers.lengths->elts;
  813.     le.request = r;
  814.     le.flushed = 1;

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

  818.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  819.         key_len = lcode(&le);

  821.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  822.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  823.         }
  824.         le.ip += sizeof(uintptr_t);

  826.         if (val_len == 0) {
  827.             continue;
  828.         }

  830.         if (key_len > NGX_HTTP_V2_MAX_FIELD) {
  831.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  832.                           "too long http2 header name");
  833.             return NGX_ERROR;
  834.         }

  836.         if (val_len > NGX_HTTP_V2_MAX_FIELD) {
  837.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  838.                           "too long http2 header value");
  839.             return NGX_ERROR;
  840.         }

  842.         len += 1 + NGX_HTTP_V2_INT_OCTETS + key_len
  843.                  + NGX_HTTP_V2_INT_OCTETS + val_len;

  845.         if (tmp_len < key_len) {
  846.             tmp_len = key_len;
  847.         }

  849.         if (tmp_len < val_len) {
  850.             tmp_len = val_len;
  851.         }
  852.     }

  854.     if (glcf->upstream.pass_request_headers) {
  855.         part = &r->headers_in.headers.part;
  856.         header = part->elts;

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

  860.             if (i >= part->nelts) {
  861.                 if (part->next == NULL) {
  862.                     break;
  863.                 }

  865.                 part = part->next;
  866.                 header = part->elts;
  867.                 i = 0;
  868.             }

  870.             if (ngx_hash_find(&glcf->headers.hash, header[i].hash,
  871.                               header[i].lowcase_key, header[i].key.len))
  872.             {
  873.                 continue;
  874.             }

  876.             if (header[i].key.len > NGX_HTTP_V2_MAX_FIELD) {
  877.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  878.                               "too long http2 header name: \"%V\"",
  879.                               &header[i].key);
  880.                 return NGX_ERROR;
  881.             }

  883.             if (header[i].value.len > NGX_HTTP_V2_MAX_FIELD) {
  884.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  885.                               "too long http2 header value: \"%V: %V\"",
  886.                               &header[i].key, &header[i].value);
  887.                 return NGX_ERROR;
  888.             }

  890.             len += 1 + NGX_HTTP_V2_INT_OCTETS + header[i].key.len
  891.                      + NGX_HTTP_V2_INT_OCTETS + header[i].value.len;

  893.             if (tmp_len < header[i].key.len) {
  894.                 tmp_len = header[i].key.len;
  895.             }

  897.             if (tmp_len < header[i].value.len) {
  898.                 tmp_len = header[i].value.len;
  899.             }
  900.         }
  901.     }

  903.     /* continuation frames */

  905.     len += sizeof(ngx_http_grpc_frame_t)
  906.            * (len / NGX_HTTP_V2_DEFAULT_FRAME_SIZE);


  909.     b = ngx_create_temp_buf(r->pool, len);
  910.     if (b == NULL) {
  911.         return NGX_ERROR;
  912.     }

  914.     cl = ngx_alloc_chain_link(r->pool);
  915.     if (cl == NULL) {
  916.         return NGX_ERROR;
  917.     }

  919.     cl->buf = b;
  920.     cl->next = NULL;

  922.     tmp = ngx_palloc(r->pool, tmp_len * 3);
  923.     if (tmp == NULL) {
  924.         return NGX_ERROR;
  925.     }

  927.     key_tmp = tmp + tmp_len;
  928.     val_tmp = tmp + 2 * tmp_len;

  930.     /* connection preface */

  932.     b->last = ngx_copy(b->last, ngx_http_grpc_connection_start,
  933.                        sizeof(ngx_http_grpc_connection_start) - 1);

  935.     /* headers frame */

  937.     headers_frame = b->last;

  939.     f = (ngx_http_grpc_frame_t *) b->last;
  940.     b->last += sizeof(ngx_http_grpc_frame_t);

  942.     f->length_0 = 0;
  943.     f->length_1 = 0;
  944.     f->length_2 = 0;
  945.     f->type = NGX_HTTP_V2_HEADERS_FRAME;
  946.     f->flags = 0;
  947.     f->stream_id_0 = 0;
  948.     f->stream_id_1 = 0;
  949.     f->stream_id_2 = 0;
  950.     f->stream_id_3 = 1;

  952.     if (r->method == NGX_HTTP_GET) {
  953.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_METHOD_GET_INDEX);

  955.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  956.                        "grpc header: \":method: GET\"");

  958.     } else if (r->method == NGX_HTTP_POST) {
  959.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_METHOD_POST_INDEX);

  961.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  962.                        "grpc header: \":method: POST\"");

  964.     } else {
  965.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_METHOD_INDEX);
  966.         b->last = ngx_http_v2_write_value(b->last, r->method_name.data,
  967.                                           r->method_name.len, tmp);

  969.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  970.                        "grpc header: \":method: %V\"", &r->method_name);
  971.     }

  973. #if (NGX_HTTP_SSL)
  974.     if (u->ssl) {
  975.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTPS_INDEX);

  977.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  978.                        "grpc header: \":scheme: https\"");
  979.     } else
  980. #endif
  981.     {
  982.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTP_INDEX);

  984.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  985.                        "grpc header: \":scheme: http\"");
  986.     }

  988.     if (r->valid_unparsed_uri) {

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

  993.         } else {
  994.             *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  995.             b->last = ngx_http_v2_write_value(b->last, r->unparsed_uri.data,
  996.                                               r->unparsed_uri.len, tmp);
  997.         }

  999.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1000.                        "grpc header: \":path: %V\"", &r->unparsed_uri);

  1002.     } else if (escape || r->args.len > 0) {
  1003.         p = val_tmp;

  1005.         if (escape) {
  1006.             p = (u_char *) ngx_escape_uri(p, r->uri.data, r->uri.len,
  1007.                                           NGX_ESCAPE_URI);

  1009.         } else {
  1010.             p = ngx_copy(p, r->uri.data, r->uri.len);
  1011.         }

  1013.         if (r->args.len > 0) {
  1014.             *p++ = '?';
  1015.             p = ngx_copy(p, r->args.data, r->args.len);
  1016.         }

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

  1021.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1022.                        "grpc header: \":path: %*s\"", p - val_tmp, val_tmp);

  1024.     } else {
  1025.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  1026.         b->last = ngx_http_v2_write_value(b->last, r->uri.data,
  1027.                                           r->uri.len, tmp);

  1029.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1030.                        "grpc header: \":path: %V\"", &r->uri);
  1031.     }

  1033.     if (!glcf->host_set) {
  1034.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_AUTHORITY_INDEX);
  1035.         b->last = ngx_http_v2_write_value(b->last, ctx->host.data,
  1036.                                           ctx->host.len, tmp);

  1038.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1039.                        "grpc header: \":authority: %V\"", &ctx->host);
  1040.     }

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

  1044.     e.ip = glcf->headers.values->elts;
  1045.     e.request = r;
  1046.     e.flushed = 1;

  1048.     le.ip = glcf->headers.lengths->elts;

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

  1052.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1053.         key_len = lcode(&le);

  1055.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1056.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1057.         }
  1058.         le.ip += sizeof(uintptr_t);

  1060.         if (val_len == 0) {
  1061.             e.skip = 1;

  1063.             while (*(uintptr_t *) e.ip) {
  1064.                 code = *(ngx_http_script_code_pt *) e.ip;
  1065.                 code((ngx_http_script_engine_t *) &e);
  1066.             }
  1067.             e.ip += sizeof(uintptr_t);

  1069.             e.skip = 0;

  1071.             continue;
  1072.         }

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

  1076.         e.pos = key_tmp;

  1078.         code = *(ngx_http_script_code_pt *) e.ip;
  1079.         code((ngx_http_script_engine_t *) &e);

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

  1083.         e.pos = val_tmp;

  1085.         while (*(uintptr_t *) e.ip) {
  1086.             code = *(ngx_http_script_code_pt *) e.ip;
  1087.             code((ngx_http_script_engine_t *) &e);
  1088.         }
  1089.         e.ip += sizeof(uintptr_t);

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

  1093. #if (NGX_DEBUG)
  1094.         if (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP) {
  1095.             ngx_strlow(key_tmp, key_tmp, key_len);

  1097.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1098.                            "grpc header: \"%*s: %*s\"",
  1099.                            key_len, key_tmp, val_len, val_tmp);
  1100.         }
  1101. #endif
  1102.     }

  1104.     if (glcf->upstream.pass_request_headers) {
  1105.         part = &r->headers_in.headers.part;
  1106.         header = part->elts;

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

  1110.             if (i >= part->nelts) {
  1111.                 if (part->next == NULL) {
  1112.                     break;
  1113.                 }

  1115.                 part = part->next;
  1116.                 header = part->elts;
  1117.                 i = 0;
  1118.             }

  1120.             if (ngx_hash_find(&glcf->headers.hash, header[i].hash,
  1121.                               header[i].lowcase_key, header[i].key.len))
  1122.             {
  1123.                 continue;
  1124.             }

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

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

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

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

  1138.                 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1139.                                "grpc header: \"%*s: %V\"",
  1140.                                header[i].key.len, tmp, &header[i].value);
  1141.             }
  1142. #endif
  1143.         }
  1144.     }

  1146.     /* update headers frame length */

  1148.     len = b->last - headers_frame - sizeof(ngx_http_grpc_frame_t);

  1150.     if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  1151.         len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1152.         next = 1;

  1154.     } else {
  1155.         next = 0;
  1156.     }

  1158.     f = (ngx_http_grpc_frame_t *) headers_frame;

  1160.     f->length_0 = (u_char) ((len >> 16) & 0xff);
  1161.     f->length_1 = (u_char) ((len >> 8) & 0xff);
  1162.     f->length_2 = (u_char) (len & 0xff);

  1164.     /* create additional continuation frames */

  1166.     p = headers_frame;

  1168.     while (next) {
  1169.         p += sizeof(ngx_http_grpc_frame_t) + NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1170.         len = b->last - p;

  1172.         ngx_memmove(p + sizeof(ngx_http_grpc_frame_t), p, len);
  1173.         b->last += sizeof(ngx_http_grpc_frame_t);

  1175.         if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  1176.             len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1177.             next = 1;

  1179.         } else {
  1180.             next = 0;
  1181.         }

  1183.         f = (ngx_http_grpc_frame_t *) p;

  1185.         f->length_0 = (u_char) ((len >> 16) & 0xff);
  1186.         f->length_1 = (u_char) ((len >> 8) & 0xff);
  1187.         f->length_2 = (u_char) (len & 0xff);
  1188.         f->type = NGX_HTTP_V2_CONTINUATION_FRAME;
  1189.         f->flags = 0;
  1190.         f->stream_id_0 = 0;
  1191.         f->stream_id_1 = 0;
  1192.         f->stream_id_2 = 0;
  1193.         f->stream_id_3 = 1;
  1194.     }

  1196.     f->flags |= NGX_HTTP_V2_END_HEADERS_FLAG;

  1198.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1199.                    "grpc header: %*xs%s, len: %uz",
  1200.                    (size_t) ngx_min(b->last - b->pos, 256), b->pos,
  1201.                    b->last - b->pos > 256 ? "..." : "",
  1202.                    b->last - b->pos);

  1204.     if (r->request_body_no_buffering) {

  1206.         u->request_bufs = cl;

  1208.     } else {

  1210.         body = u->request_bufs;
  1211.         u->request_bufs = cl;

  1213.         if (body == NULL) {
  1214.             f = (ngx_http_grpc_frame_t *) headers_frame;
  1215.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;
  1216.         }

  1218.         while (body) {
  1219.             b = ngx_alloc_buf(r->pool);
  1220.             if (b == NULL) {
  1221.                 return NGX_ERROR;
  1222.             }

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

  1226.             cl->next = ngx_alloc_chain_link(r->pool);
  1227.             if (cl->next == NULL) {
  1228.                 return NGX_ERROR;
  1229.             }

  1231.             cl = cl->next;
  1232.             cl->buf = b;

  1234.             body = body->next;
  1235.         }

  1237.         b->last_buf = 1;
  1238.     }

  1240.     u->output.output_filter = ngx_http_grpc_body_output_filter;
  1241.     u->output.filter_ctx = r;

  1243.     b->flush = 1;
  1244.     cl->next = NULL;

  1246.     return NGX_OK;
  1247. }


  1250. static ngx_int_t
  1251. ‌ngx_http_grpc_reinit_request(ngx_http_request_t *r)
  1252. {
  1253.     ngx_http_grpc_ctx_t  *ctx;

  1255.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

  1257.     if (ctx == NULL) {
  1258.         return NGX_OK;
  1259.     }

  1261.     ctx->state = 0;
  1262.     ctx->header_sent = 0;
  1263.     ctx->output_closed = 0;
  1264.     ctx->output_blocked = 0;
  1265.     ctx->parsing_headers = 0;
  1266.     ctx->end_stream = 0;
  1267.     ctx->done = 0;
  1268.     ctx->status = 0;
  1269.     ctx->rst = 0;
  1270.     ctx->goaway = 0;
  1271.     ctx->connection = NULL;
  1272.     ctx->in = NULL;
  1273.     ctx->busy = NULL;
  1274.     ctx->out = NULL;

  1276.     return NGX_OK;
  1277. }


  1280. static ngx_int_t
  1281. ‌ngx_http_grpc_body_output_filter(void *data, ngx_chain_t *in)
  1282. {
  1283.     ngx_http_request_t  *r = data;

  1285.     off_t                   file_pos;
  1286.     u_char                 *p, *pos, *start;
  1287.     size_t                  len, limit;
  1288.     ngx_buf_t              *b;
  1289.     ngx_int_t               rc;
  1290.     ngx_uint_t              next, last;
  1291.     ngx_chain_t            *cl, *out, *ln, **ll;
  1292.     ngx_http_upstream_t    *u;
  1293.     ngx_http_grpc_ctx_t    *ctx;
  1294.     ngx_http_grpc_frame_t  *f;

  1296.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1297.                    "grpc output filter");

  1299.     ctx = ngx_http_grpc_get_ctx(r);

  1301.     if (ctx == NULL) {
  1302.         return NGX_ERROR;
  1303.     }

  1305.     if (in) {
  1306.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  1307.             return NGX_ERROR;
  1308.         }
  1309.     }

  1311.     out = NULL;
  1312.     ll = &out;

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

  1317.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1318.                        "grpc output header");

  1320.         ctx->header_sent = 1;

  1322.         if (ctx->id != 1) {
  1323.             /*
  1324.              * keepalive connection: skip connection preface,
  1325.              * update stream identifiers
  1326.              */

  1328.             b = ctx->in->buf;
  1329.             b->pos += sizeof(ngx_http_grpc_connection_start) - 1;

  1331.             p = b->pos;

  1333.             while (p < b->last) {
  1334.                 f = (ngx_http_grpc_frame_t *) p;
  1335.                 p += sizeof(ngx_http_grpc_frame_t);

  1337.                 f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1338.                 f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1339.                 f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1340.                 f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1342.                 p += (f->length_0 << 16) + (f->length_1 << 8) + f->length_2;
  1343.             }
  1344.         }

  1346.         if (ctx->in->buf->last_buf) {
  1347.             ctx->output_closed = 1;
  1348.         }

  1350.         *ll = ctx->in;
  1351.         ll = &ctx->in->next;

  1353.         ctx->in = ctx->in->next;
  1354.     }

  1356.     if (ctx->out) {
  1357.         /* queued control frames */

  1359.         *ll = ctx->out;

  1361.         for (cl = ctx->out, ll = &cl->next; cl; cl = cl->next) {
  1362.             ll = &cl->next;
  1363.         }

  1365.         ctx->out = NULL;
  1366.     }

  1368.     f = NULL;
  1369.     last = 0;

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

  1373.     if (limit > ctx->connection->send_window) {
  1374.         limit = ctx->connection->send_window;
  1375.     }

  1377.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1378.                    "grpc output limit: %uz w:%z:%uz",
  1379.                    limit, ctx->send_window, ctx->connection->send_window);

  1381. #if (NGX_SUPPRESS_WARN)
  1382.     file_pos = 0;
  1383.     pos = NULL;
  1384.     cl = NULL;
  1385. #endif

  1387.     in = ctx->in;

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

  1391.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1392.                        "grpc output in  l:%d f:%d %p, pos %p, size: %z "
  1393.                        "file: %O, size: %O",
  1394.                        in->buf->last_buf,
  1395.                        in->buf->in_file,
  1396.                        in->buf->start, in->buf->pos,
  1397.                        in->buf->last - in->buf->pos,
  1398.                        in->buf->file_pos,
  1399.                        in->buf->file_last - in->buf->file_pos);

  1401.         if (ngx_buf_special(in->buf)) {
  1402.             goto next;
  1403.         }

  1405.         if (in->buf->in_file) {
  1406.             file_pos = in->buf->file_pos;

  1408.         } else {
  1409.             pos = in->buf->pos;
  1410.         }

  1412.         next = 0;

  1414.         do {

  1416.             cl = ngx_http_grpc_get_buf(r, ctx);
  1417.             if (cl == NULL) {
  1418.                 return NGX_ERROR;
  1419.             }

  1421.             b = cl->buf;

  1423.             f = (ngx_http_grpc_frame_t *) b->last;
  1424.             b->last += sizeof(ngx_http_grpc_frame_t);

  1426.             *ll = cl;
  1427.             ll = &cl->next;

  1429.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  1430.             if (cl == NULL) {
  1431.                 return NGX_ERROR;
  1432.             }

  1434.             b = cl->buf;
  1435.             start = b->start;

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

  1439.             /*
  1440.              * restore b->start to preserve memory allocated in the buffer,
  1441.              * to reuse it later for headers and control frames
  1442.              */

  1444.             b->start = start;

  1446.             if (in->buf->in_file) {
  1447.                 b->file_pos = file_pos;
  1448.                 file_pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1450.                 if (file_pos >= in->buf->file_last) {
  1451.                     file_pos = in->buf->file_last;
  1452.                     next = 1;
  1453.                 }

  1455.                 b->file_last = file_pos;
  1456.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1458.             } else {
  1459.                 b->pos = pos;
  1460.                 pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1462.                 if (pos >= in->buf->last) {
  1463.                     pos = in->buf->last;
  1464.                     next = 1;
  1465.                 }

  1467.                 b->last = pos;
  1468.                 len = (ngx_uint_t) (pos - b->pos);
  1469.             }

  1471.             b->tag = (ngx_buf_tag_t) &ngx_http_grpc_body_output_filter;
  1472.             b->shadow = in->buf;
  1473.             b->last_shadow = next;

  1475.             b->last_buf = 0;
  1476.             b->last_in_chain = 0;

  1478.             *ll = cl;
  1479.             ll = &cl->next;

  1481.             f->length_0 = (u_char) ((len >> 16) & 0xff);
  1482.             f->length_1 = (u_char) ((len >> 8) & 0xff);
  1483.             f->length_2 = (u_char) (len & 0xff);
  1484.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1485.             f->flags = 0;
  1486.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1487.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1488.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1489.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1491.             limit -= len;
  1492.             ctx->send_window -= len;
  1493.             ctx->connection->send_window -= len;

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

  1497.         if (!next) {
  1498.             /*
  1499.              * if the buffer wasn't fully sent due to flow control limits,
  1500.              * preserve position for future use
  1501.              */

  1503.             if (in->buf->in_file) {
  1504.                 in->buf->file_pos = file_pos;

  1506.             } else {
  1507.                 in->buf->pos = pos;
  1508.             }

  1510.             break;
  1511.         }

  1513.     next:

  1515.         if (in->buf->last_buf) {
  1516.             last = 1;
  1517.         }

  1519.         ln = in;
  1520.         in = in->next;

  1522.         ngx_free_chain(r->pool, ln);
  1523.     }

  1525.     ctx->in = in;

  1527.     if (last) {

  1529.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1530.                        "grpc output last");

  1532.         ctx->output_closed = 1;

  1534.         if (f) {
  1535.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1537.         } else {
  1538.             cl = ngx_http_grpc_get_buf(r, ctx);
  1539.             if (cl == NULL) {
  1540.                 return NGX_ERROR;
  1541.             }

  1543.             b = cl->buf;

  1545.             f = (ngx_http_grpc_frame_t *) b->last;
  1546.             b->last += sizeof(ngx_http_grpc_frame_t);

  1548.             f->length_0 = 0;
  1549.             f->length_1 = 0;
  1550.             f->length_2 = 0;
  1551.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1552.             f->flags = NGX_HTTP_V2_END_STREAM_FLAG;
  1553.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1554.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1555.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1556.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1558.             *ll = cl;
  1559.             ll = &cl->next;
  1560.         }

  1562.         cl->buf->last_buf = 1;
  1563.     }

  1565.     *ll = NULL;

  1567. #if (NGX_DEBUG)

  1569.     for (cl = out; cl; cl = cl->next) {
  1570.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1571.                        "grpc output out l:%d f:%d %p, pos %p, size: %z "
  1572.                        "file: %O, size: %O",
  1573.                        cl->buf->last_buf,
  1574.                        cl->buf->in_file,
  1575.                        cl->buf->start, cl->buf->pos,
  1576.                        cl->buf->last - cl->buf->pos,
  1577.                        cl->buf->file_pos,
  1578.                        cl->buf->file_last - cl->buf->file_pos);
  1579.     }

  1581.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1582.                    "grpc output limit: %uz w:%z:%uz",
  1583.                    limit, ctx->send_window, ctx->connection->send_window);

  1585. #endif

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

  1589.     ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &out,
  1590.                             (ngx_buf_tag_t) &ngx_http_grpc_body_output_filter);

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

  1594.         /* mark original buffers as sent */

  1596.         if (cl->buf->shadow) {
  1597.             if (cl->buf->last_shadow) {
  1598.                 b = cl->buf->shadow;
  1599.                 b->pos = b->last;
  1600.             }

  1602.             cl->buf->shadow = NULL;
  1603.         }
  1604.     }

  1606.     if (rc == NGX_OK && ctx->in) {
  1607.         rc = NGX_AGAIN;
  1608.     }

  1610.     if (rc == NGX_AGAIN) {
  1611.         ctx->output_blocked = 1;

  1613.     } else {
  1614.         ctx->output_blocked = 0;
  1615.     }

  1617.     if (ctx->done) {

  1619.         /*
  1620.          * We have already got the response and were sending some additional
  1621.          * control frames.  Even if there is still something unsent, stop
  1622.          * here anyway.
  1623.          */

  1625.         u = r->upstream;
  1626.         u->length = 0;

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

  1638.         ngx_post_event(u->peer.connection->read, &ngx_posted_events);
  1639.     }

  1641.     return rc;
  1642. }


  1645. static ngx_int_t
  1646. ‌ngx_http_grpc_process_header(ngx_http_request_t *r)
  1647. {
  1648.     ngx_str_t                      *status_line;
  1649.     ngx_int_t                       rc, status;
  1650.     ngx_buf_t                      *b;
  1651.     ngx_table_elt_t                *h;
  1652.     ngx_http_upstream_t            *u;
  1653.     ngx_http_grpc_ctx_t            *ctx;
  1654.     ngx_http_upstream_header_t     *hh;
  1655.     ngx_http_upstream_main_conf_t  *umcf;

  1657.     u = r->upstream;
  1658.     b = &u->buffer;

  1660.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1661.                    "grpc response: %*xs%s, len: %uz",
  1662.                    (size_t) ngx_min(b->last - b->pos, 256),
  1663.                    b->pos, b->last - b->pos > 256 ? "..." : "",
  1664.                    b->last - b->pos);

  1666.     ctx = ngx_http_grpc_get_ctx(r);

  1668.     if (ctx == NULL) {
  1669.         return NGX_ERROR;
  1670.     }

  1672.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1674.     for ( ;; ) {

  1676.         if (ctx->state < ngx_http_grpc_st_payload) {

  1678.             rc = ngx_http_grpc_parse_frame(r, ctx, b);

  1680.             if (rc == NGX_AGAIN) {

  1682.                 /*
  1683.                  * there can be a lot of window update frames,
  1684.                  * so we reset buffer if it is empty and we haven't
  1685.                  * started parsing headers yet
  1686.                  */

  1688.                 if (!ctx->parsing_headers) {
  1689.                     b->pos = b->start;
  1690.                     b->last = b->pos;
  1691.                 }

  1693.                 return NGX_AGAIN;
  1694.             }

  1696.             if (rc == NGX_ERROR) {
  1697.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1698.             }

  1700.             /*
  1701.              * RFC 7540 says that implementations MUST discard frames
  1702.              * that have unknown or unsupported types.  However, extension
  1703.              * frames that appear in the middle of a header block are
  1704.              * not permitted.  Also, for obvious reasons CONTINUATION frames
  1705.              * cannot appear before headers, and DATA frames are not expected
  1706.              * to appear before all headers are parsed.
  1707.              */

  1709.             if (ctx->type == NGX_HTTP_V2_DATA_FRAME
  1710.                 || (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  1711.                     && !ctx->parsing_headers)
  1712.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  1713.                     && ctx->parsing_headers))
  1714.             {
  1715.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1716.                               "upstream sent unexpected http2 frame: %d",
  1717.                               ctx->type);
  1718.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1719.             }

  1721.             if (ctx->stream_id && ctx->stream_id != ctx->id) {
  1722.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1723.                               "upstream sent frame for unknown stream %ui",
  1724.                               ctx->stream_id);
  1725.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1726.             }
  1727.         }

  1729.         /* frame payload */

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

  1733.             rc = ngx_http_grpc_parse_rst_stream(r, ctx, b);

  1735.             if (rc == NGX_AGAIN) {
  1736.                 return NGX_AGAIN;
  1737.             }

  1739.             if (rc == NGX_ERROR) {
  1740.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1741.             }

  1743.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1744.                           "upstream rejected request with error %ui",
  1745.                           ctx->error);

  1747.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1748.         }

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

  1752.             rc = ngx_http_grpc_parse_goaway(r, ctx, b);

  1754.             if (rc == NGX_AGAIN) {
  1755.                 return NGX_AGAIN;
  1756.             }

  1758.             if (rc == NGX_ERROR) {
  1759.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1760.             }

  1762.             /*
  1763.              * If stream_id is lower than one we use, our
  1764.              * request won't be processed and needs to be retried.
  1765.              * If stream_id is greater or equal to the one we use,
  1766.              * we can continue normally (except we can't use this
  1767.              * connection for additional requests).  If there is
  1768.              * a real error, the connection will be closed.
  1769.              */

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

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

  1775.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1776.                               "upstream sent goaway with error %ui",
  1777.                               ctx->error);

  1779.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1780.             }

  1782.             ctx->goaway = 1;

  1784.             continue;
  1785.         }

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

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

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

  1795.             if (rc == NGX_ERROR) {
  1796.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1797.             }

  1799.             if (ctx->in) {
  1800.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1801.             }

  1803.             continue;
  1804.         }

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

  1808.             rc = ngx_http_grpc_parse_settings(r, ctx, b);

  1810.             if (rc == NGX_AGAIN) {
  1811.                 return NGX_AGAIN;
  1812.             }

  1814.             if (rc == NGX_ERROR) {
  1815.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1816.             }

  1818.             if (ctx->in) {
  1819.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1820.             }

  1822.             continue;
  1823.         }

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

  1827.             rc = ngx_http_grpc_parse_ping(r, ctx, b);

  1829.             if (rc == NGX_AGAIN) {
  1830.                 return NGX_AGAIN;
  1831.             }

  1833.             if (rc == NGX_ERROR) {
  1834.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1835.             }

  1837.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1838.             continue;
  1839.         }

  1841.         if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  1842.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1843.                           "upstream sent unexpected push promise frame");
  1844.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1845.         }

  1847.         if (ctx->type != NGX_HTTP_V2_HEADERS_FRAME
  1848.             && ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME)
  1849.         {
  1850.             /* priority, unknown frames */

  1852.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  1853.                 ctx->rest -= b->last - b->pos;
  1854.                 b->pos = b->last;
  1855.                 return NGX_AGAIN;
  1856.             }

  1858.             b->pos += ctx->rest;
  1859.             ctx->rest = 0;
  1860.             ctx->state = ngx_http_grpc_st_start;

  1862.             continue;
  1863.         }

  1865.         /* headers */

  1867.         for ( ;; ) {

  1869.             rc = ngx_http_grpc_parse_header(r, ctx, b);

  1871.             if (rc == NGX_AGAIN) {
  1872.                 break;
  1873.             }

  1875.             if (rc == NGX_OK) {

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

  1879.                 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1880.                                "grpc header: \"%V: %V\"",
  1881.                                &ctx->name, &ctx->value);

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

  1885.                     if (ctx->name.len != sizeof(":status") - 1
  1886.                         || ngx_strncmp(ctx->name.data, ":status",
  1887.                                        sizeof(":status") - 1)
  1888.                            != 0)
  1889.                     {
  1890.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1891.                                       "upstream sent invalid header \"%V: %V\"",
  1892.                                       &ctx->name, &ctx->value);
  1893.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1894.                     }

  1896.                     if (ctx->status) {
  1897.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1898.                                       "upstream sent duplicate :status header");
  1899.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1900.                     }

  1902.                     status_line = &ctx->value;

  1904.                     if (status_line->len != 3) {
  1905.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1906.                                       "upstream sent invalid :status \"%V\"",
  1907.                                       status_line);
  1908.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1909.                     }

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

  1913.                     if (status == NGX_ERROR) {
  1914.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1915.                                       "upstream sent invalid :status \"%V\"",
  1916.                                       status_line);
  1917.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1918.                     }

  1920.                     if (status < NGX_HTTP_OK && status != NGX_HTTP_EARLY_HINTS)
  1921.                     {
  1922.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1923.                                       "upstream sent unexpected :status \"%V\"",
  1924.                                       status_line);
  1925.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1926.                     }

  1928.                     u->headers_in.status_n = status;

  1930.                     if (u->state && u->state->status == 0) {
  1931.                         u->state->status = status;
  1932.                     }

  1934.                     ctx->status = 1;

  1936.                     continue;

  1938.                 } else if (!ctx->status) {
  1939.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1940.                                   "upstream sent no :status header");
  1941.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1942.                 }

  1944.                 h = ngx_list_push(&u->headers_in.headers);
  1945.                 if (h == NULL) {
  1946.                     return NGX_ERROR;
  1947.                 }

  1949.                 h->key = ctx->name;
  1950.                 h->value = ctx->value;
  1951.                 h->lowcase_key = h->key.data;
  1952.                 h->hash = ngx_hash_key(h->key.data, h->key.len);

  1954.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1955.                     continue;
  1956.                 }

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

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

  1964.                     if (rc != NGX_OK) {
  1965.                         return rc;
  1966.                     }
  1967.                 }

  1969.                 continue;
  1970.             }

  1972.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

  1976.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1977.                                "grpc header done");

  1979.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  1980.                     if (ctx->end_stream) {
  1981.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1982.                                       "upstream prematurely closed stream");
  1983.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1984.                     }

  1986.                     ctx->status = 0;
  1987.                     return NGX_HTTP_UPSTREAM_EARLY_HINTS;
  1988.                 }

  1990.                 if (ctx->end_stream) {
  1991.                     u->headers_in.content_length_n = 0;

  1993.                     if (ctx->in == NULL
  1994.                         && ctx->out == NULL
  1995.                         && ctx->output_closed
  1996.                         && !ctx->output_blocked
  1997.                         && !ctx->goaway
  1998.                         && b->last == b->pos)
  1999.                     {
  2000.                         u->keepalive = 1;
  2001.                     }
  2002.                 }

  2004.                 return NGX_OK;
  2005.             }

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

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

  2012.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2013.         }

  2015.         /* rc == NGX_AGAIN */

  2017.         if (ctx->rest == 0) {
  2018.             ctx->state = ngx_http_grpc_st_start;
  2019.             continue;
  2020.         }

  2022.         return NGX_AGAIN;
  2023.     }
  2024. }


  2027. static ngx_int_t
  2028. ‌ngx_http_grpc_filter_init(void *data)
  2029. {
  2030.     ngx_http_grpc_ctx_t  *ctx = data;

  2032.     ngx_http_request_t   *r;
  2033.     ngx_http_upstream_t  *u;

  2035.     r = ctx->request;
  2036.     u = r->upstream;

  2038.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  2039.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED
  2040.         || r->method == NGX_HTTP_HEAD)
  2041.     {
  2042.         ctx->length = 0;

  2044.     } else {
  2045.         ctx->length = u->headers_in.content_length_n;
  2046.     }

  2048.     if (ctx->end_stream) {

  2050.         if (ctx->length > 0) {
  2051.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2052.                           "upstream prematurely closed stream");
  2053.             return NGX_ERROR;
  2054.         }

  2056.         u->length = 0;
  2057.         ctx->done = 1;

  2059.     } else {
  2060.         u->length = 1;
  2061.     }

  2063.     return NGX_OK;
  2064. }


  2067. static ngx_int_t
  2068. ‌ngx_http_grpc_filter(void *data, ssize_t bytes)
  2069. {
  2070.     ngx_http_grpc_ctx_t  *ctx = data;

  2072.     ngx_int_t             rc;
  2073.     ngx_buf_t            *b, *buf;
  2074.     ngx_chain_t          *cl, **ll;
  2075.     ngx_table_elt_t      *h;
  2076.     ngx_http_request_t   *r;
  2077.     ngx_http_upstream_t  *u;

  2079.     r = ctx->request;
  2080.     u = r->upstream;
  2081.     b = &u->buffer;

  2083.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2084.                    "grpc filter bytes:%z", bytes);

  2086.     b->pos = b->last;
  2087.     b->last += bytes;

  2089.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  2090.         ll = &cl->next;
  2091.     }

  2093.     for ( ;; ) {

  2095.         if (ctx->state < ngx_http_grpc_st_payload) {

  2097.             rc = ngx_http_grpc_parse_frame(r, ctx, b);

  2099.             if (rc == NGX_AGAIN) {

  2101.                 if (ctx->done) {

  2103.                     if (ctx->length > 0) {
  2104.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2105.                                       "upstream prematurely closed stream");
  2106.                         return NGX_ERROR;
  2107.                     }

  2109.                     /*
  2110.                      * We have finished parsing the response and the
  2111.                      * remaining control frames.  If there are unsent
  2112.                      * control frames, post a write event to send them.
  2113.                      */

  2115.                     if (ctx->out) {
  2116.                         ngx_post_event(u->peer.connection->write,
  2117.                                        &ngx_posted_events);
  2118.                         return NGX_AGAIN;
  2119.                     }

  2121.                     u->length = 0;

  2123.                     if (ctx->in == NULL
  2124.                         && ctx->output_closed
  2125.                         && !ctx->output_blocked
  2126.                         && !ctx->goaway
  2127.                         && ctx->state == ngx_http_grpc_st_start)
  2128.                     {
  2129.                         u->keepalive = 1;
  2130.                     }

  2132.                     break;
  2133.                 }

  2135.                 return NGX_AGAIN;
  2136.             }

  2138.             if (rc == NGX_ERROR) {
  2139.                 return NGX_ERROR;
  2140.             }

  2142.             if ((ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  2143.                  && !ctx->parsing_headers)
  2144.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  2145.                     && ctx->parsing_headers))
  2146.             {
  2147.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2148.                               "upstream sent unexpected http2 frame: %d",
  2149.                               ctx->type);
  2150.                 return NGX_ERROR;
  2151.             }

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

  2155.                 if (ctx->stream_id != ctx->id) {
  2156.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2157.                                   "upstream sent data frame "
  2158.                                   "for unknown stream %ui",
  2159.                                   ctx->stream_id);
  2160.                     return NGX_ERROR;
  2161.                 }

  2163.                 if (ctx->rest > ctx->recv_window) {
  2164.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2165.                                   "upstream violated stream flow control, "
  2166.                                   "received %uz data frame with window %uz",
  2167.                                   ctx->rest, ctx->recv_window);
  2168.                     return NGX_ERROR;
  2169.                 }

  2171.                 if (ctx->rest > ctx->connection->recv_window) {
  2172.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2173.                                   "upstream violated connection flow control, "
  2174.                                   "received %uz data frame with window %uz",
  2175.                                   ctx->rest, ctx->connection->recv_window);
  2176.                     return NGX_ERROR;
  2177.                 }

  2179.                 ctx->recv_window -= ctx->rest;
  2180.                 ctx->connection->recv_window -= ctx->rest;

  2182.                 if (ctx->connection->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4
  2183.                     || ctx->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4)
  2184.                 {
  2185.                     if (ngx_http_grpc_send_window_update(r, ctx) != NGX_OK) {
  2186.                         return NGX_ERROR;
  2187.                     }

  2189.                     ngx_post_event(u->peer.connection->write,
  2190.                                    &ngx_posted_events);
  2191.                 }
  2192.             }

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

  2201.             if (ctx->stream_id && ctx->done
  2202.                 && ctx->type != NGX_HTTP_V2_RST_STREAM_FRAME
  2203.                 && ctx->type != NGX_HTTP_V2_WINDOW_UPDATE_FRAME)
  2204.             {
  2205.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2206.                               "upstream sent frame for closed stream %ui",
  2207.                               ctx->stream_id);
  2208.                 return NGX_ERROR;
  2209.             }

  2211.             ctx->padding = 0;
  2212.         }

  2214.         if (ctx->state == ngx_http_grpc_st_padding) {

  2216.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2217.                 ctx->rest -= b->last - b->pos;
  2218.                 b->pos = b->last;
  2219.                 return NGX_AGAIN;
  2220.             }

  2222.             b->pos += ctx->rest;
  2223.             ctx->rest = 0;
  2224.             ctx->state = ngx_http_grpc_st_start;

  2226.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2227.                 ctx->done = 1;
  2228.             }

  2230.             continue;
  2231.         }

  2233.         /* frame payload */

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

  2237.             rc = ngx_http_grpc_parse_rst_stream(r, ctx, b);

  2239.             if (rc == NGX_AGAIN) {
  2240.                 return NGX_AGAIN;
  2241.             }

  2243.             if (rc == NGX_ERROR) {
  2244.                 return NGX_ERROR;
  2245.             }

  2247.             if (ctx->error || !ctx->done) {
  2248.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2249.                               "upstream rejected request with error %ui",
  2250.                               ctx->error);
  2251.                 return NGX_ERROR;
  2252.             }

  2254.             if (ctx->rst) {
  2255.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2256.                               "upstream sent frame for closed stream %ui",
  2257.                               ctx->stream_id);
  2258.                 return NGX_ERROR;
  2259.             }

  2261.             ctx->rst = 1;

  2263.             continue;
  2264.         }

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

  2268.             rc = ngx_http_grpc_parse_goaway(r, ctx, b);

  2270.             if (rc == NGX_AGAIN) {
  2271.                 return NGX_AGAIN;
  2272.             }

  2274.             if (rc == NGX_ERROR) {
  2275.                 return NGX_ERROR;
  2276.             }

  2278.             /*
  2279.              * If stream_id is lower than one we use, our
  2280.              * request won't be processed and needs to be retried.
  2281.              * If stream_id is greater or equal to the one we use,
  2282.              * we can continue normally (except we can't use this
  2283.              * connection for additional requests).  If there is
  2284.              * a real error, the connection will be closed.
  2285.              */

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

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

  2291.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2292.                               "upstream sent goaway with error %ui",
  2293.                               ctx->error);

  2295.                 return NGX_ERROR;
  2296.             }

  2298.             ctx->goaway = 1;

  2300.             continue;
  2301.         }

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

  2305.             rc = ngx_http_grpc_parse_window_update(r, ctx, b);

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

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

  2315.             if (ctx->in) {
  2316.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2317.             }

  2319.             continue;
  2320.         }

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

  2324.             rc = ngx_http_grpc_parse_settings(r, ctx, b);

  2326.             if (rc == NGX_AGAIN) {
  2327.                 return NGX_AGAIN;
  2328.             }

  2330.             if (rc == NGX_ERROR) {
  2331.                 return NGX_ERROR;
  2332.             }

  2334.             if (ctx->in) {
  2335.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2336.             }

  2338.             continue;
  2339.         }

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

  2343.             rc = ngx_http_grpc_parse_ping(r, ctx, b);

  2345.             if (rc == NGX_AGAIN) {
  2346.                 return NGX_AGAIN;
  2347.             }

  2349.             if (rc == NGX_ERROR) {
  2350.                 return NGX_ERROR;
  2351.             }

  2353.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2354.             continue;
  2355.         }

  2357.         if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  2358.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2359.                           "upstream sent unexpected push promise frame");
  2360.             return NGX_ERROR;
  2361.         }

  2363.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME
  2364.             || ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME)
  2365.         {
  2366.             for ( ;; ) {

  2368.                 rc = ngx_http_grpc_parse_header(r, ctx, b);

  2370.                 if (rc == NGX_AGAIN) {
  2371.                     break;
  2372.                 }

  2374.                 if (rc == NGX_OK) {

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

  2378.                     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2379.                                    "grpc trailer: \"%V: %V\"",
  2380.                                    &ctx->name, &ctx->value);

  2382.                     if (ctx->name.len && ctx->name.data[0] == ':') {
  2383.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2384.                                       "upstream sent invalid "
  2385.                                       "trailer \"%V: %V\"",
  2386.                                       &ctx->name, &ctx->value);
  2387.                         return NGX_ERROR;
  2388.                     }

  2390.                     h = ngx_list_push(&u->headers_in.trailers);
  2391.                     if (h == NULL) {
  2392.                         return NGX_ERROR;
  2393.                     }

  2395.                     h->key = ctx->name;
  2396.                     h->value = ctx->value;
  2397.                     h->lowcase_key = h->key.data;
  2398.                     h->hash = ngx_hash_key(h->key.data, h->key.len);

  2400.                     continue;
  2401.                 }

  2403.                 if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

  2407.                     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2408.                                    "grpc trailer done");

  2410.                     if (ctx->end_stream) {
  2411.                         ctx->done = 1;
  2412.                         break;
  2413.                     }

  2415.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2416.                                   "upstream sent trailer without "
  2417.                                   "end stream flag");
  2418.                     return NGX_ERROR;
  2419.                 }

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

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

  2426.                 return NGX_ERROR;
  2427.             }

  2429.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2430.                 continue;
  2431.             }

  2433.             /* rc == NGX_AGAIN */

  2435.             if (ctx->rest == 0) {
  2436.                 ctx->state = ngx_http_grpc_st_start;
  2437.                 continue;
  2438.             }

  2440.             return NGX_AGAIN;
  2441.         }

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

  2445.             /* priority, unknown frames */

  2447.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2448.                 ctx->rest -= b->last - b->pos;
  2449.                 b->pos = b->last;
  2450.                 return NGX_AGAIN;
  2451.             }

  2453.             b->pos += ctx->rest;
  2454.             ctx->rest = 0;
  2455.             ctx->state = ngx_http_grpc_st_start;

  2457.             continue;
  2458.         }

  2460.         /*
  2461.          * data frame:
  2462.          *
  2463.          * +---------------+
  2464.          * |Pad Length? (8)|
  2465.          * +---------------+-----------------------------------------------+
  2466.          * |                            Data (*)                         ...
  2467.          * +---------------------------------------------------------------+
  2468.          * |                           Padding (*)                       ...
  2469.          * +---------------------------------------------------------------+
  2470.          */

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

  2474.             if (ctx->rest == 0) {
  2475.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2476.                               "upstream sent too short http2 frame");
  2477.                 return NGX_ERROR;
  2478.             }

  2480.             if (b->pos == b->last) {
  2481.                 return NGX_AGAIN;
  2482.             }

  2484.             ctx->flags &= ~NGX_HTTP_V2_PADDED_FLAG;
  2485.             ctx->padding = *b->pos++;
  2486.             ctx->rest -= 1;

  2488.             if (ctx->padding > ctx->rest) {
  2489.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2490.                               "upstream sent http2 frame with too long "
  2491.                               "padding: %d in frame %uz",
  2492.                               ctx->padding, ctx->rest);
  2493.                 return NGX_ERROR;
  2494.             }

  2496.             continue;
  2497.         }

  2499.         if (ctx->rest == ctx->padding) {
  2500.             goto done;
  2501.         }

  2503.         if (b->pos == b->last) {
  2504.             return NGX_AGAIN;
  2505.         }

  2507.         cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  2508.         if (cl == NULL) {
  2509.             return NGX_ERROR;
  2510.         }

  2512.         *ll = cl;
  2513.         ll = &cl->next;

  2515.         buf = cl->buf;

  2517.         buf->flush = 1;
  2518.         buf->memory = 1;

  2520.         buf->pos = b->pos;
  2521.         buf->tag = u->output.tag;

  2523.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2524.                        "grpc output buf %p", buf->pos);

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

  2528.             ctx->rest -= b->last - b->pos;
  2529.             b->pos = b->last;
  2530.             buf->last = b->pos;

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

  2534.                 if (buf->last - buf->pos > ctx->length) {
  2535.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2536.                                   "upstream sent response body larger "
  2537.                                   "than indicated content length");
  2538.                     return NGX_ERROR;
  2539.                 }

  2541.                 ctx->length -= buf->last - buf->pos;
  2542.             }

  2544.             return NGX_AGAIN;
  2545.         }

  2547.         b->pos += ctx->rest - ctx->padding;
  2548.         buf->last = b->pos;
  2549.         ctx->rest = ctx->padding;

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

  2553.             if (buf->last - buf->pos > ctx->length) {
  2554.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2555.                               "upstream sent response body larger "
  2556.                               "than indicated content length");
  2557.                 return NGX_ERROR;
  2558.             }

  2560.             ctx->length -= buf->last - buf->pos;
  2561.         }

  2563.     done:

  2565.         if (ctx->padding) {
  2566.             ctx->state = ngx_http_grpc_st_padding;
  2567.             continue;
  2568.         }

  2570.         ctx->state = ngx_http_grpc_st_start;

  2572.         if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2573.             ctx->done = 1;
  2574.         }
  2575.     }

  2577.     return NGX_OK;
  2578. }


  2581. static ngx_int_t
  2582. ‌ngx_http_grpc_parse_frame(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2583.     ngx_buf_t *b)
  2584. {
  2585.     u_char                 ch, *p;
  2586.     ngx_http_grpc_state_e  state;

  2588.     state = ctx->state;

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

  2593. #if 0
  2594.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2595.                        "grpc frame byte: %02Xd, s:%d", ch, state);
  2596. #endif

  2598.         switch (state) {

  2600.         case ngx_http_grpc_st_start:
  2601.             ctx->rest = ch << 16;
  2602.             state = ngx_http_grpc_st_length_2;
  2603.             break;

  2605.         case ngx_http_grpc_st_length_2:
  2606.             ctx->rest |= ch << 8;
  2607.             state = ngx_http_grpc_st_length_3;
  2608.             break;

  2610.         case ngx_http_grpc_st_length_3:
  2611.             ctx->rest |= ch;

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

  2620.             state = ngx_http_grpc_st_type;
  2621.             break;

  2623.         case ngx_http_grpc_st_type:
  2624.             ctx->type = ch;
  2625.             state = ngx_http_grpc_st_flags;
  2626.             break;

  2628.         case ngx_http_grpc_st_flags:
  2629.             ctx->flags = ch;
  2630.             state = ngx_http_grpc_st_stream_id;
  2631.             break;

  2633.         case ngx_http_grpc_st_stream_id:
  2634.             ctx->stream_id = (ch & 0x7f) << 24;
  2635.             state = ngx_http_grpc_st_stream_id_2;
  2636.             break;

  2638.         case ngx_http_grpc_st_stream_id_2:
  2639.             ctx->stream_id |= ch << 16;
  2640.             state = ngx_http_grpc_st_stream_id_3;
  2641.             break;

  2643.         case ngx_http_grpc_st_stream_id_3:
  2644.             ctx->stream_id |= ch << 8;
  2645.             state = ngx_http_grpc_st_stream_id_4;
  2646.             break;

  2648.         case ngx_http_grpc_st_stream_id_4:
  2649.             ctx->stream_id |= ch;

  2651.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2652.                            "grpc frame: %d, len: %uz, f:%d, i:%ui",
  2653.                            ctx->type, ctx->rest, ctx->flags, ctx->stream_id);

  2655.             b->pos = p + 1;

  2657.             ctx->state = ngx_http_grpc_st_payload;
  2658.             ctx->frame_state = 0;

  2660.             return NGX_OK;

  2662.         /* suppress warning */
  2663.         case ngx_http_grpc_st_payload:
  2664.         case ngx_http_grpc_st_padding:
  2665.             break;
  2666.         }
  2667.     }

  2669.     b->pos = p;
  2670.     ctx->state = state;

  2672.     return NGX_AGAIN;
  2673. }


  2676. static ngx_int_t
  2677. ‌ngx_http_grpc_parse_header(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2678.     ngx_buf_t *b)
  2679. {
  2680.     u_char     ch, *p, *last;
  2681.     size_t     min;
  2682.     ngx_int_t  rc;
  2683. ‌    enum {
  2684.         sw_start = 0,
  2685.         sw_padding_length,
  2686.         sw_dependency,
  2687.         sw_dependency_2,
  2688.         sw_dependency_3,
  2689.         sw_dependency_4,
  2690.         sw_weight,
  2691.         sw_fragment,
  2692.         sw_padding
  2693.     } state;

  2695.     state = ctx->frame_state;

  2697.     if (state == sw_start) {

  2699.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2700.                        "grpc parse header: start");

  2702.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME) {
  2703.             ctx->parsing_headers = 1;
  2704.             ctx->fragment_state = 0;

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

  2709.             if (ctx->rest < min) {
  2710.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2711.                               "upstream sent headers frame "
  2712.                               "with invalid length: %uz",
  2713.                               ctx->rest);
  2714.                 return NGX_ERROR;
  2715.             }

  2717.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2718.                 ctx->end_stream = 1;
  2719.             }

  2721.             if (ctx->flags & NGX_HTTP_V2_PADDED_FLAG) {
  2722.                 state = sw_padding_length;

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

  2727.             } else {
  2728.                 state = sw_fragment;
  2729.             }

  2731.         } else if (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME) {
  2732.             state = sw_fragment;
  2733.         }

  2735.         ctx->padding = 0;
  2736.         ctx->frame_state = state;
  2737.     }

  2739.     if (state < sw_fragment) {

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

  2744.         } else {
  2745.             last = b->pos + ctx->rest;
  2746.         }

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

  2751. #if 0
  2752.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2753.                            "grpc header byte: %02Xd s:%d", ch, state);
  2754. #endif

  2756.             /*
  2757.              * headers frame:
  2758.              *
  2759.              * +---------------+
  2760.              * |Pad Length? (8)|
  2761.              * +-+-------------+----------------------------------------------+
  2762.              * |E|                 Stream Dependency? (31)                    |
  2763.              * +-+-------------+----------------------------------------------+
  2764.              * |  Weight? (8)  |
  2765.              * +-+-------------+----------------------------------------------+
  2766.              * |                   Header Block Fragment (*)                ...
  2767.              * +--------------------------------------------------------------+
  2768.              * |                           Padding (*)                      ...
  2769.              * +--------------------------------------------------------------+
  2770.              */

  2772.             switch (state) {

  2774.             case sw_padding_length:

  2776.                 ctx->padding = ch;

  2778.                 if (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG) {
  2779.                     state = sw_dependency;
  2780.                     break;
  2781.                 }

  2783.                 goto fragment;

  2785.             case sw_dependency:
  2786.                 state = sw_dependency_2;
  2787.                 break;

  2789.             case sw_dependency_2:
  2790.                 state = sw_dependency_3;
  2791.                 break;

  2793.             case sw_dependency_3:
  2794.                 state = sw_dependency_4;
  2795.                 break;

  2797.             case sw_dependency_4:
  2798.                 state = sw_weight;
  2799.                 break;

  2801.             case sw_weight:
  2802.                 goto fragment;

  2804.             /* suppress warning */
  2805.             case sw_start:
  2806.             case sw_fragment:
  2807.             case sw_padding:
  2808.                 break;
  2809.             }
  2810.         }

  2812.         ctx->rest -= p - b->pos;
  2813.         b->pos = p;

  2815.         ctx->frame_state = state;
  2816.         return NGX_AGAIN;

  2818.     fragment:

  2820.         p++;
  2821.         ctx->rest -= p - b->pos;
  2822.         b->pos = p;

  2824.         if (ctx->padding > ctx->rest) {
  2825.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2826.                           "upstream sent http2 frame with too long "
  2827.                           "padding: %d in frame %uz",
  2828.                           ctx->padding, ctx->rest);
  2829.             return NGX_ERROR;
  2830.         }

  2832.         state = sw_fragment;
  2833.         ctx->frame_state = state;
  2834.     }

  2836.     if (state == sw_fragment) {

  2838.         rc = ngx_http_grpc_parse_fragment(r, ctx, b);

  2840.         if (rc == NGX_AGAIN) {
  2841.             return NGX_AGAIN;
  2842.         }

  2844.         if (rc == NGX_ERROR) {
  2845.             return NGX_ERROR;
  2846.         }

  2848.         if (rc == NGX_OK) {
  2849.             return NGX_OK;
  2850.         }

  2852.         /* rc == NGX_DONE */

  2854.         state = sw_padding;
  2855.         ctx->frame_state = state;
  2856.     }

  2858.     if (state == sw_padding) {

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

  2862.             ctx->rest -= b->last - b->pos;
  2863.             b->pos = b->last;

  2865.             return NGX_AGAIN;
  2866.         }

  2868.         b->pos += ctx->rest;
  2869.         ctx->rest = 0;

  2871.         ctx->state = ngx_http_grpc_st_start;

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

  2875.             if (ctx->fragment_state) {
  2876.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2877.                               "upstream sent truncated http2 header");
  2878.                 return NGX_ERROR;
  2879.             }

  2881.             ctx->parsing_headers = 0;

  2883.             return NGX_HTTP_PARSE_HEADER_DONE;
  2884.         }

  2886.         return NGX_AGAIN;
  2887.     }

  2889.     /* unreachable */

  2891.     return NGX_ERROR;
  2892. }


  2895. static ngx_int_t
  2896. ‌ngx_http_grpc_parse_fragment(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2897.     ngx_buf_t *b)
  2898. {
  2899.     u_char      ch, *p, *last;
  2900.     size_t      size;
  2901.     ngx_uint_t  index, size_update;
  2902. ‌    enum {
  2903.         sw_start = 0,
  2904.         sw_index,
  2905.         sw_name_length,
  2906.         sw_name_length_2,
  2907.         sw_name_length_3,
  2908.         sw_name_length_4,
  2909.         sw_name,
  2910.         sw_name_bytes,
  2911.         sw_value_length,
  2912.         sw_value_length_2,
  2913.         sw_value_length_3,
  2914.         sw_value_length_4,
  2915.         sw_value,
  2916.         sw_value_bytes
  2917.     } state;

  2919.     /* header block fragment */

  2921. #if 0
  2922.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2923.                    "grpc header fragment %p:%p rest:%uz",
  2924.                    b->pos, b->last, ctx->rest);
  2925. #endif

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

  2930.     } else {
  2931.         last = b->pos + ctx->rest - ctx->padding;
  2932.     }

  2934.     state = ctx->fragment_state;

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

  2939. #if 0
  2940.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2941.                        "grpc header byte: %02Xd s:%d", ch, state);
  2942. #endif

  2944.         switch (state) {

  2946.         case sw_start:
  2947.             ctx->index = 0;

  2949.             if ((ch & 0x80) == 0x80) {
  2950.                 /*
  2951.                  * indexed header:
  2952.                  *
  2953.                  *   0   1   2   3   4   5   6   7
  2954.                  * +---+---+---+---+---+---+---+---+
  2955.                  * | 1 |        Index (7+)         |
  2956.                  * +---+---------------------------+
  2957.                  */

  2959.                 index = ch & ~0x80;

  2961.                 if (index == 0 || index > 61) {
  2962.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2963.                                   "upstream sent invalid http2 "
  2964.                                   "table index: %ui", index);
  2965.                     return NGX_ERROR;
  2966.                 }

  2968.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2969.                                "grpc indexed header: %ui", index);

  2971.                 ctx->index = index;
  2972.                 ctx->literal = 0;

  2974.                 goto done;

  2976.             } else if ((ch & 0xc0) == 0x40) {
  2977.                 /*
  2978.                  * literal header with incremental indexing:
  2979.                  *
  2980.                  *   0   1   2   3   4   5   6   7
  2981.                  * +---+---+---+---+---+---+---+---+
  2982.                  * | 0 | 1 |      Index (6+)       |
  2983.                  * +---+---+-----------------------+
  2984.                  * | H |     Value Length (7+)     |
  2985.                  * +---+---------------------------+
  2986.                  * | Value String (Length octets)  |
  2987.                  * +-------------------------------+
  2988.                  *
  2989.                  *   0   1   2   3   4   5   6   7
  2990.                  * +---+---+---+---+---+---+---+---+
  2991.                  * | 0 | 1 |           0           |
  2992.                  * +---+---+-----------------------+
  2993.                  * | H |     Name Length (7+)      |
  2994.                  * +---+---------------------------+
  2995.                  * |  Name String (Length octets)  |
  2996.                  * +---+---------------------------+
  2997.                  * | H |     Value Length (7+)     |
  2998.                  * +---+---------------------------+
  2999.                  * | Value String (Length octets)  |
  3000.                  * +-------------------------------+
  3001.                  */

  3003.                 index = ch & ~0xc0;

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

  3012.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3013.                                "grpc literal header: %ui", index);

  3015.                 if (index == 0) {
  3016.                     state = sw_name_length;
  3017.                     break;
  3018.                 }

  3020.                 ctx->index = index;
  3021.                 ctx->literal = 1;

  3023.                 state = sw_value_length;
  3024.                 break;

  3026.             } else if ((ch & 0xe0) == 0x20) {
  3027.                 /*
  3028.                  * dynamic table size update:
  3029.                  *
  3030.                  *   0   1   2   3   4   5   6   7
  3031.                  * +---+---+---+---+---+---+---+---+
  3032.                  * | 0 | 0 | 1 |   Max size (5+)   |
  3033.                  * +---+---------------------------+
  3034.                  */

  3036.                 size_update = ch & ~0xe0;

  3038.                 if (size_update > 0) {
  3039.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3040.                                   "upstream sent invalid http2 "
  3041.                                   "dynamic table size update: %ui",
  3042.                                   size_update);
  3043.                     return NGX_ERROR;
  3044.                 }

  3046.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3047.                                "grpc table size update: %ui", size_update);

  3049.                 break;

  3051.             } else if ((ch & 0xf0) == 0x10) {
  3052.                 /*
  3053.                  *  literal header field never indexed:
  3054.                  *
  3055.                  *   0   1   2   3   4   5   6   7
  3056.                  * +---+---+---+---+---+---+---+---+
  3057.                  * | 0 | 0 | 0 | 1 |  Index (4+)   |
  3058.                  * +---+---+-----------------------+
  3059.                  * | H |     Value Length (7+)     |
  3060.                  * +---+---------------------------+
  3061.                  * | Value String (Length octets)  |
  3062.                  * +-------------------------------+
  3063.                  *
  3064.                  *   0   1   2   3   4   5   6   7
  3065.                  * +---+---+---+---+---+---+---+---+
  3066.                  * | 0 | 0 | 0 | 1 |       0       |
  3067.                  * +---+---+-----------------------+
  3068.                  * | H |     Name Length (7+)      |
  3069.                  * +---+---------------------------+
  3070.                  * |  Name String (Length octets)  |
  3071.                  * +---+---------------------------+
  3072.                  * | H |     Value Length (7+)     |
  3073.                  * +---+---------------------------+
  3074.                  * | Value String (Length octets)  |
  3075.                  * +-------------------------------+
  3076.                  */

  3078.                 index = ch & ~0xf0;

  3080.                 if (index == 0x0f) {
  3081.                     ctx->index = index;
  3082.                     ctx->literal = 1;
  3083.                     state = sw_index;
  3084.                     break;
  3085.                 }

  3087.                 if (index == 0) {
  3088.                     state = sw_name_length;
  3089.                     break;
  3090.                 }

  3092.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3093.                                "grpc literal header never indexed: %ui",
  3094.                                index);

  3096.                 ctx->index = index;
  3097.                 ctx->literal = 1;

  3099.                 state = sw_value_length;
  3100.                 break;

  3102.             } else if ((ch & 0xf0) == 0x00) {
  3103.                 /*
  3104.                  * literal header field without indexing:
  3105.                  *
  3106.                  *   0   1   2   3   4   5   6   7
  3107.                  * +---+---+---+---+---+---+---+---+
  3108.                  * | 0 | 0 | 0 | 0 |  Index (4+)   |
  3109.                  * +---+---+-----------------------+
  3110.                  * | H |     Value Length (7+)     |
  3111.                  * +---+---------------------------+
  3112.                  * | Value String (Length octets)  |
  3113.                  * +-------------------------------+
  3114.                  *
  3115.                  *   0   1   2   3   4   5   6   7
  3116.                  * +---+---+---+---+---+---+---+---+
  3117.                  * | 0 | 0 | 0 | 0 |       0       |
  3118.                  * +---+---+-----------------------+
  3119.                  * | H |     Name Length (7+)      |
  3120.                  * +---+---------------------------+
  3121.                  * |  Name String (Length octets)  |
  3122.                  * +---+---------------------------+
  3123.                  * | H |     Value Length (7+)     |
  3124.                  * +---+---------------------------+
  3125.                  * | Value String (Length octets)  |
  3126.                  * +-------------------------------+
  3127.                  */

  3129.                 index = ch & ~0xf0;

  3131.                 if (index == 0x0f) {
  3132.                     ctx->index = index;
  3133.                     ctx->literal = 1;
  3134.                     state = sw_index;
  3135.                     break;
  3136.                 }

  3138.                 if (index == 0) {
  3139.                     state = sw_name_length;
  3140.                     break;
  3141.                 }

  3143.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3144.                                "grpc literal header without indexing: %ui",
  3145.                                index);

  3147.                 ctx->index = index;
  3148.                 ctx->literal = 1;

  3150.                 state = sw_value_length;
  3151.                 break;
  3152.             }

  3154.             /* not reached */

  3156.             return NGX_ERROR;

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

  3161.             if (ch & 0x80) {
  3162.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3163.                               "upstream sent http2 table index "
  3164.                               "with continuation flag");
  3165.                 return NGX_ERROR;
  3166.             }

  3168.             if (ctx->index > 61) {
  3169.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3170.                               "upstream sent invalid http2 "
  3171.                               "table index: %ui", ctx->index);
  3172.                 return NGX_ERROR;
  3173.             }

  3175.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3176.                            "grpc header index: %ui", ctx->index);

  3178.             state = sw_value_length;
  3179.             break;

  3181.         case sw_name_length:
  3182.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3183.             ctx->field_length = ch & ~0x80;

  3185.             if (ctx->field_length == 0x7f) {
  3186.                 state = sw_name_length_2;
  3187.                 break;
  3188.             }

  3190.             if (ctx->field_length == 0) {
  3191.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3192.                               "upstream sent zero http2 "
  3193.                               "header name length");
  3194.                 return NGX_ERROR;
  3195.             }

  3197.             state = sw_name;
  3198.             break;

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

  3203.             if (ch & 0x80) {
  3204.                 state = sw_name_length_3;
  3205.                 break;
  3206.             }

  3208.             state = sw_name;
  3209.             break;

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

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

  3219.             state = sw_name;
  3220.             break;

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

  3225.             if (ch & 0x80) {
  3226.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3227.                               "upstream sent too large http2 "
  3228.                               "header name length");
  3229.                 return NGX_ERROR;
  3230.             }

  3232.             state = sw_name;
  3233.             break;

  3235.         case sw_name:
  3236.             ctx->name.len = ctx->field_huffman ?
  3237.                             ctx->field_length * 8 / 5 : ctx->field_length;

  3239.             ctx->name.data = ngx_pnalloc(r->pool, ctx->name.len + 1);
  3240.             if (ctx->name.data == NULL) {
  3241.                 return NGX_ERROR;
  3242.             }

  3244.             ctx->field_end = ctx->name.data;
  3245.             ctx->field_rest = ctx->field_length;
  3246.             ctx->field_state = 0;

  3248.             state = sw_name_bytes;

  3250.             /* fall through */

  3252.         case sw_name_bytes:

  3254.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3255.                            "grpc name: len:%uz h:%d last:%uz, rest:%uz",
  3256.                            ctx->field_length,
  3257.                            ctx->field_huffman,
  3258.                            last - p,
  3259.                            ctx->rest - (p - b->pos));

  3261.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3262.             ctx->field_rest -= size;

  3264.             if (ctx->field_huffman) {
  3265.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3266.                                          &ctx->field_end,
  3267.                                          ctx->field_rest == 0,
  3268.                                          r->connection->log)
  3269.                     != NGX_OK)
  3270.                 {
  3271.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3272.                                   "upstream sent invalid encoded header");
  3273.                     return NGX_ERROR;
  3274.                 }

  3276.                 ctx->name.len = ctx->field_end - ctx->name.data;
  3277.                 ctx->name.data[ctx->name.len] = '\0';

  3279.             } else {
  3280.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3281.                 ctx->name.data[ctx->name.len] = '\0';
  3282.             }

  3284.             p += size - 1;

  3286.             if (ctx->field_rest == 0) {
  3287.                 state = sw_value_length;
  3288.             }

  3290.             break;

  3292.         case sw_value_length:
  3293.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3294.             ctx->field_length = ch & ~0x80;

  3296.             if (ctx->field_length == 0x7f) {
  3297.                 state = sw_value_length_2;
  3298.                 break;
  3299.             }

  3301.             if (ctx->field_length == 0) {
  3302.                 ngx_str_set(&ctx->value, "");
  3303.                 goto done;
  3304.             }

  3306.             state = sw_value;
  3307.             break;

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

  3312.             if (ch & 0x80) {
  3313.                 state = sw_value_length_3;
  3314.                 break;
  3315.             }

  3317.             state = sw_value;
  3318.             break;

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

  3323.             if (ch & 0x80) {
  3324.                 state = sw_value_length_4;
  3325.                 break;
  3326.             }

  3328.             state = sw_value;
  3329.             break;

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

  3334.             if (ch & 0x80) {
  3335.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3336.                               "upstream sent too large http2 "
  3337.                               "header value length");
  3338.                 return NGX_ERROR;
  3339.             }

  3341.             state = sw_value;
  3342.             break;

  3344.         case sw_value:
  3345.             ctx->value.len = ctx->field_huffman ?
  3346.                              ctx->field_length * 8 / 5 : ctx->field_length;

  3348.             ctx->value.data = ngx_pnalloc(r->pool, ctx->value.len + 1);
  3349.             if (ctx->value.data == NULL) {
  3350.                 return NGX_ERROR;
  3351.             }

  3353.             ctx->field_end = ctx->value.data;
  3354.             ctx->field_rest = ctx->field_length;
  3355.             ctx->field_state = 0;

  3357.             state = sw_value_bytes;

  3359.             /* fall through */

  3361.         case sw_value_bytes:

  3363.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3364.                            "grpc value: len:%uz h:%d last:%uz, rest:%uz",
  3365.                            ctx->field_length,
  3366.                            ctx->field_huffman,
  3367.                            last - p,
  3368.                            ctx->rest - (p - b->pos));

  3370.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3371.             ctx->field_rest -= size;

  3373.             if (ctx->field_huffman) {
  3374.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3375.                                          &ctx->field_end,
  3376.                                          ctx->field_rest == 0,
  3377.                                          r->connection->log)
  3378.                     != NGX_OK)
  3379.                 {
  3380.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3381.                                   "upstream sent invalid encoded header");
  3382.                     return NGX_ERROR;
  3383.                 }

  3385.                 ctx->value.len = ctx->field_end - ctx->value.data;
  3386.                 ctx->value.data[ctx->value.len] = '\0';

  3388.             } else {
  3389.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3390.                 ctx->value.data[ctx->value.len] = '\0';
  3391.             }

  3393.             p += size - 1;

  3395.             if (ctx->field_rest == 0) {
  3396.                 goto done;
  3397.             }

  3399.             break;
  3400.         }

  3402.         continue;

  3404.     done:

  3406.         p++;
  3407.         ctx->rest -= p - b->pos;
  3408.         ctx->fragment_state = sw_start;
  3409.         b->pos = p;

  3411.         if (ctx->index) {
  3412.             ctx->name = *ngx_http_v2_get_static_name(ctx->index);
  3413.         }

  3415.         if (ctx->index && !ctx->literal) {
  3416.             ctx->value = *ngx_http_v2_get_static_value(ctx->index);
  3417.         }

  3419.         if (!ctx->index) {
  3420.             if (ngx_http_grpc_validate_header_name(r, &ctx->name) != NGX_OK) {
  3421.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3422.                               "upstream sent invalid header: \"%V: %V\"",
  3423.                               &ctx->name, &ctx->value);
  3424.                 return NGX_ERROR;
  3425.             }
  3426.         }

  3428.         if (!ctx->index || ctx->literal) {
  3429.             if (ngx_http_grpc_validate_header_value(r, &ctx->value) != NGX_OK) {
  3430.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3431.                               "upstream sent invalid header: \"%V: %V\"",
  3432.                               &ctx->name, &ctx->value);
  3433.                 return NGX_ERROR;
  3434.             }
  3435.         }

  3437.         return NGX_OK;
  3438.     }

  3440.     ctx->rest -= p - b->pos;
  3441.     ctx->fragment_state = state;
  3442.     b->pos = p;

  3444.     if (ctx->rest > ctx->padding) {
  3445.         return NGX_AGAIN;
  3446.     }

  3448.     return NGX_DONE;
  3449. }


  3452. static ngx_int_t
  3453. ‌ngx_http_grpc_validate_header_name(ngx_http_request_t *r, ngx_str_t *s)
  3454. {
  3455.     u_char      ch;
  3456.     ngx_uint_t  i;

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

  3461.         if (ch == ':' && i > 0) {
  3462.             return NGX_ERROR;
  3463.         }

  3465.         if (ch >= 'A' && ch <= 'Z') {
  3466.             return NGX_ERROR;
  3467.         }

  3469.         if (ch <= 0x20 || ch == 0x7f) {
  3470.             return NGX_ERROR;
  3471.         }
  3472.     }

  3474.     return NGX_OK;
  3475. }


  3478. static ngx_int_t
  3479. ‌ngx_http_grpc_validate_header_value(ngx_http_request_t *r, ngx_str_t *s)
  3480. {
  3481.     u_char      ch;
  3482.     ngx_uint_t  i;

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

  3487.         if (ch == '\0' || ch == CR || ch == LF) {
  3488.             return NGX_ERROR;
  3489.         }
  3490.     }

  3492.     return NGX_OK;
  3493. }


  3496. static ngx_int_t
  3497. ‌ngx_http_grpc_parse_rst_stream(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  3498.     ngx_buf_t *b)
  3499. {
  3500.     u_char  ch, *p, *last;
  3501. ‌    enum {
  3502.         sw_start = 0,
  3503.         sw_error_2,
  3504.         sw_error_3,
  3505.         sw_error_4
  3506.     } state;

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

  3511.     } else {
  3512.         last = b->pos + ctx->rest;
  3513.     }

  3515.     state = ctx->frame_state;

  3517.     if (state == sw_start) {
  3518.         if (ctx->rest != 4) {
  3519.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3520.                           "upstream sent rst stream frame "
  3521.                           "with invalid length: %uz",
  3522.                           ctx->rest);
  3523.             return NGX_ERROR;
  3524.         }
  3525.     }

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

  3530. #if 0
  3531.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3532.                        "grpc rst byte: %02Xd s:%d", ch, state);
  3533. #endif

  3535.         switch (state) {

  3537.         case sw_start:
  3538.             ctx->error = (ngx_uint_t) ch << 24;
  3539.             state = sw_error_2;
  3540.             break;

  3542.         case sw_error_2:
  3543.             ctx->error |= ch << 16;
  3544.             state = sw_error_3;
  3545.             break;

  3547.         case sw_error_3:
  3548.             ctx->error |= ch << 8;
  3549.             state = sw_error_4;
  3550.             break;

  3552.         case sw_error_4:
  3553.             ctx->error |= ch;
  3554.             state = sw_start;

  3556.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3557.                            "grpc error: %ui", ctx->error);

  3559.             break;
  3560.         }
  3561.     }

  3563.     ctx->rest -= p - b->pos;
  3564.     ctx->frame_state = state;
  3565.     b->pos = p;

  3567.     if (ctx->rest > 0) {
  3568.         return NGX_AGAIN;
  3569.     }

  3571.     ctx->state = ngx_http_grpc_st_start;

  3573.     return NGX_OK;
  3574. }


  3577. static ngx_int_t
  3578. ‌ngx_http_grpc_parse_goaway(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  3579.     ngx_buf_t *b)
  3580. {
  3581.     u_char  ch, *p, *last;
  3582. ‌    enum {
  3583.         sw_start = 0,
  3584.         sw_last_stream_id_2,
  3585.         sw_last_stream_id_3,
  3586.         sw_last_stream_id_4,
  3587.         sw_error,
  3588.         sw_error_2,
  3589.         sw_error_3,
  3590.         sw_error_4,
  3591.         sw_debug
  3592.     } state;

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

  3597.     } else {
  3598.         last = b->pos + ctx->rest;
  3599.     }

  3601.     state = ctx->frame_state;

  3603.     if (state == sw_start) {

  3605.         if (ctx->stream_id) {
  3606.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3607.                           "upstream sent goaway frame "
  3608.                           "with non-zero stream id: %ui",
  3609.                           ctx->stream_id);
  3610.             return NGX_ERROR;
  3611.         }

  3613.         if (ctx->rest < 8) {
  3614.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3615.                           "upstream sent goaway frame "
  3616.                           "with invalid length: %uz",
  3617.                           ctx->rest);
  3618.             return NGX_ERROR;
  3619.         }
  3620.     }

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

  3625. #if 0
  3626.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3627.                        "grpc goaway byte: %02Xd s:%d", ch, state);
  3628. #endif

  3630.         switch (state) {

  3632.         case sw_start:
  3633.             ctx->stream_id = (ch & 0x7f) << 24;
  3634.             state = sw_last_stream_id_2;
  3635.             break;

  3637.         case sw_last_stream_id_2:
  3638.             ctx->stream_id |= ch << 16;
  3639.             state = sw_last_stream_id_3;
  3640.             break;

  3642.         case sw_last_stream_id_3:
  3643.             ctx->stream_id |= ch << 8;
  3644.             state = sw_last_stream_id_4;
  3645.             break;

  3647.         case sw_last_stream_id_4:
  3648.             ctx->stream_id |= ch;
  3649.             state = sw_error;
  3650.             break;

  3652.         case sw_error:
  3653.             ctx->error = (ngx_uint_t) ch << 24;
  3654.             state = sw_error_2;
  3655.             break;

  3657.         case sw_error_2:
  3658.             ctx->error |= ch << 16;
  3659.             state = sw_error_3;
  3660.             break;

  3662.         case sw_error_3:
  3663.             ctx->error |= ch << 8;
  3664.             state = sw_error_4;
  3665.             break;

  3667.         case sw_error_4:
  3668.             ctx->error |= ch;
  3669.             state = sw_debug;
  3670.             break;

  3672.         case sw_debug:
  3673.             break;
  3674.         }
  3675.     }

  3677.     ctx->rest -= p - b->pos;
  3678.     ctx->frame_state = state;
  3679.     b->pos = p;

  3681.     if (ctx->rest > 0) {
  3682.         return NGX_AGAIN;
  3683.     }

  3685.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3686.                    "grpc goaway: %ui, stream %ui",
  3687.                    ctx->error, ctx->stream_id);

  3689.     ctx->state = ngx_http_grpc_st_start;

  3691.     return NGX_OK;
  3692. }


  3695. static ngx_int_t
  3696. ‌ngx_http_grpc_parse_window_update(ngx_http_request_t *r,
  3697.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b)
  3698. {
  3699.     u_char  ch, *p, *last;
  3700. ‌    enum {
  3701.         sw_start = 0,
  3702.         sw_size_2,
  3703.         sw_size_3,
  3704.         sw_size_4
  3705.     } state;

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

  3710.     } else {
  3711.         last = b->pos + ctx->rest;
  3712.     }

  3714.     state = ctx->frame_state;

  3716.     if (state == sw_start) {
  3717.         if (ctx->rest != 4) {
  3718.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3719.                           "upstream sent window update frame "
  3720.                           "with invalid length: %uz",
  3721.                           ctx->rest);
  3722.             return NGX_ERROR;
  3723.         }
  3724.     }

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

  3729. #if 0
  3730.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3731.                        "grpc window update byte: %02Xd s:%d", ch, state);
  3732. #endif

  3734.         switch (state) {

  3736.         case sw_start:
  3737.             ctx->window_update = (ch & 0x7f) << 24;
  3738.             state = sw_size_2;
  3739.             break;

  3741.         case sw_size_2:
  3742.             ctx->window_update |= ch << 16;
  3743.             state = sw_size_3;
  3744.             break;

  3746.         case sw_size_3:
  3747.             ctx->window_update |= ch << 8;
  3748.             state = sw_size_4;
  3749.             break;

  3751.         case sw_size_4:
  3752.             ctx->window_update |= ch;
  3753.             state = sw_start;
  3754.             break;
  3755.         }
  3756.     }

  3758.     ctx->rest -= p - b->pos;
  3759.     ctx->frame_state = state;
  3760.     b->pos = p;

  3762.     if (ctx->rest > 0) {
  3763.         return NGX_AGAIN;
  3764.     }

  3766.     ctx->state = ngx_http_grpc_st_start;

  3768.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3769.                    "grpc window update: %ui", ctx->window_update);

  3771.     if (ctx->stream_id) {

  3773.         if (ctx->window_update > (size_t) NGX_HTTP_V2_MAX_WINDOW
  3774.                                  - ctx->send_window)
  3775.         {
  3776.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3777.                           "upstream sent too large window update");
  3778.             return NGX_ERROR;
  3779.         }

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

  3783.     } else {

  3785.         if (ctx->window_update > NGX_HTTP_V2_MAX_WINDOW
  3786.                                  - ctx->connection->send_window)
  3787.         {
  3788.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3789.                           "upstream sent too large window update");
  3790.             return NGX_ERROR;
  3791.         }

  3793.         ctx->connection->send_window += ctx->window_update;
  3794.     }

  3796.     return NGX_OK;
  3797. }


  3800. static ngx_int_t
  3801. ‌ngx_http_grpc_parse_settings(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  3802.     ngx_buf_t *b)
  3803. {
  3804.     u_char   ch, *p, *last;
  3805.     ssize_t  window_update;
  3806. ‌    enum {
  3807.         sw_start = 0,
  3808.         sw_id,
  3809.         sw_id_2,
  3810.         sw_value,
  3811.         sw_value_2,
  3812.         sw_value_3,
  3813.         sw_value_4
  3814.     } state;

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

  3819.     } else {
  3820.         last = b->pos + ctx->rest;
  3821.     }

  3823.     state = ctx->frame_state;

  3825.     if (state == sw_start) {

  3827.         if (ctx->stream_id) {
  3828.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3829.                           "upstream sent settings frame "
  3830.                           "with non-zero stream id: %ui",
  3831.                           ctx->stream_id);
  3832.             return NGX_ERROR;
  3833.         }

  3835.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  3836.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3837.                            "grpc settings ack");

  3839.             if (ctx->rest != 0) {
  3840.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3841.                               "upstream sent settings frame "
  3842.                               "with ack flag and non-zero length: %uz",
  3843.                               ctx->rest);
  3844.                 return NGX_ERROR;
  3845.             }

  3847.             ctx->state = ngx_http_grpc_st_start;

  3849.             return NGX_OK;
  3850.         }

  3852.         if (ctx->rest % 6 != 0) {
  3853.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3854.                           "upstream sent settings frame "
  3855.                           "with invalid length: %uz",
  3856.                           ctx->rest);
  3857.             return NGX_ERROR;
  3858.         }

  3860.         if (ctx->free == NULL && ctx->settings++ > 1000) {
  3861.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3862.                           "upstream sent too many settings frames");
  3863.             return NGX_ERROR;
  3864.         }
  3865.     }

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

  3870. #if 0
  3871.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3872.                        "grpc settings byte: %02Xd s:%d", ch, state);
  3873. #endif

  3875.         switch (state) {

  3877.         case sw_start:
  3878.         case sw_id:
  3879.             ctx->setting_id = ch << 8;
  3880.             state = sw_id_2;
  3881.             break;

  3883.         case sw_id_2:
  3884.             ctx->setting_id |= ch;
  3885.             state = sw_value;
  3886.             break;

  3888.         case sw_value:
  3889.             ctx->setting_value = (ngx_uint_t) ch << 24;
  3890.             state = sw_value_2;
  3891.             break;

  3893.         case sw_value_2:
  3894.             ctx->setting_value |= ch << 16;
  3895.             state = sw_value_3;
  3896.             break;

  3898.         case sw_value_3:
  3899.             ctx->setting_value |= ch << 8;
  3900.             state = sw_value_4;
  3901.             break;

  3903.         case sw_value_4:
  3904.             ctx->setting_value |= ch;
  3905.             state = sw_id;

  3907.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3908.                            "grpc setting: %ui %ui",
  3909.                            ctx->setting_id, ctx->setting_value);

  3911.             /*
  3912.              * The following settings are defined by the protocol:
  3913.              *
  3914.              * SETTINGS_HEADER_TABLE_SIZE, SETTINGS_ENABLE_PUSH,
  3915.              * SETTINGS_MAX_CONCURRENT_STREAMS, SETTINGS_INITIAL_WINDOW_SIZE,
  3916.              * SETTINGS_MAX_FRAME_SIZE, SETTINGS_MAX_HEADER_LIST_SIZE
  3917.              *
  3918.              * Only SETTINGS_INITIAL_WINDOW_SIZE seems to be needed in
  3919.              * a simple client.
  3920.              */

  3922.             if (ctx->setting_id == 0x04) {
  3923.                 /* SETTINGS_INITIAL_WINDOW_SIZE */

  3925.                 if (ctx->setting_value > NGX_HTTP_V2_MAX_WINDOW) {
  3926.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3927.                                   "upstream sent settings frame "
  3928.                                   "with too large initial window size: %ui",
  3929.                                   ctx->setting_value);
  3930.                     return NGX_ERROR;
  3931.                 }

  3933.                 window_update = ctx->setting_value
  3934.                                 - ctx->connection->init_window;
  3935.                 ctx->connection->init_window = ctx->setting_value;

  3937.                 if (ctx->send_window > 0
  3938.                     && window_update > (ssize_t) NGX_HTTP_V2_MAX_WINDOW
  3939.                                        - ctx->send_window)
  3940.                 {
  3941.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3942.                                   "upstream sent settings frame "
  3943.                                   "with too large initial window size: %ui",
  3944.                                   ctx->setting_value);
  3945.                     return NGX_ERROR;
  3946.                 }

  3948.                 ctx->send_window += window_update;
  3949.             }

  3951.             break;
  3952.         }
  3953.     }

  3955.     ctx->rest -= p - b->pos;
  3956.     ctx->frame_state = state;
  3957.     b->pos = p;

  3959.     if (ctx->rest > 0) {
  3960.         return NGX_AGAIN;
  3961.     }

  3963.     ctx->state = ngx_http_grpc_st_start;

  3965.     return ngx_http_grpc_send_settings_ack(r, ctx);
  3966. }


  3969. static ngx_int_t
  3970. ‌ngx_http_grpc_parse_ping(ngx_http_request_t *r,
  3971.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b)
  3972. {
  3973.     u_char  ch, *p, *last;
  3974. ‌    enum {
  3975.         sw_start = 0,
  3976.         sw_data_2,
  3977.         sw_data_3,
  3978.         sw_data_4,
  3979.         sw_data_5,
  3980.         sw_data_6,
  3981.         sw_data_7,
  3982.         sw_data_8
  3983.     } state;

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

  3988.     } else {
  3989.         last = b->pos + ctx->rest;
  3990.     }

  3992.     state = ctx->frame_state;

  3994.     if (state == sw_start) {

  3996.         if (ctx->stream_id) {
  3997.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3998.                           "upstream sent ping frame "
  3999.                           "with non-zero stream id: %ui",
  4000.                           ctx->stream_id);
  4001.             return NGX_ERROR;
  4002.         }

  4004.         if (ctx->rest != 8) {
  4005.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4006.                           "upstream sent ping frame "
  4007.                           "with invalid length: %uz",
  4008.                           ctx->rest);
  4009.             return NGX_ERROR;
  4010.         }

  4012.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  4013.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4014.                           "upstream sent ping frame with ack flag");
  4015.             return NGX_ERROR;
  4016.         }

  4018.         if (ctx->free == NULL && ctx->pings++ > 1000) {
  4019.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4020.                           "upstream sent too many ping frames");
  4021.             return NGX_ERROR;
  4022.         }
  4023.     }

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

  4028. #if 0
  4029.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4030.                        "grpc ping byte: %02Xd s:%d", ch, state);
  4031. #endif

  4033.         if (state < sw_data_8) {
  4034.             ctx->ping_data[state] = ch;
  4035.             state++;

  4037.         } else {
  4038.             ctx->ping_data[7] = ch;
  4039.             state = sw_start;

  4041.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4042.                            "grpc ping");
  4043.         }
  4044.     }

  4046.     ctx->rest -= p - b->pos;
  4047.     ctx->frame_state = state;
  4048.     b->pos = p;

  4050.     if (ctx->rest > 0) {
  4051.         return NGX_AGAIN;
  4052.     }

  4054.     ctx->state = ngx_http_grpc_st_start;

  4056.     return ngx_http_grpc_send_ping_ack(r, ctx);
  4057. }


  4060. static ngx_int_t
  4061. ‌ngx_http_grpc_send_settings_ack(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  4062. {
  4063.     ngx_chain_t            *cl, **ll;
  4064.     ngx_http_grpc_frame_t  *f;

  4066.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4067.                    "grpc send settings ack");

  4069.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4070.         ll = &cl->next;
  4071.     }

  4073.     cl = ngx_http_grpc_get_buf(r, ctx);
  4074.     if (cl == NULL) {
  4075.         return NGX_ERROR;
  4076.     }

  4078.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4079.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4081.     f->length_0 = 0;
  4082.     f->length_1 = 0;
  4083.     f->length_2 = 0;
  4084.     f->type = NGX_HTTP_V2_SETTINGS_FRAME;
  4085.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  4086.     f->stream_id_0 = 0;
  4087.     f->stream_id_1 = 0;
  4088.     f->stream_id_2 = 0;
  4089.     f->stream_id_3 = 0;

  4091.     *ll = cl;

  4093.     return NGX_OK;
  4094. }


  4097. static ngx_int_t
  4098. ‌ngx_http_grpc_send_ping_ack(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  4099. {
  4100.     ngx_chain_t            *cl, **ll;
  4101.     ngx_http_grpc_frame_t  *f;

  4103.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4104.                    "grpc send ping ack");

  4106.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4107.         ll = &cl->next;
  4108.     }

  4110.     cl = ngx_http_grpc_get_buf(r, ctx);
  4111.     if (cl == NULL) {
  4112.         return NGX_ERROR;
  4113.     }

  4115.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4116.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4118.     f->length_0 = 0;
  4119.     f->length_1 = 0;
  4120.     f->length_2 = 8;
  4121.     f->type = NGX_HTTP_V2_PING_FRAME;
  4122.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  4123.     f->stream_id_0 = 0;
  4124.     f->stream_id_1 = 0;
  4125.     f->stream_id_2 = 0;
  4126.     f->stream_id_3 = 0;

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

  4130.     *ll = cl;

  4132.     return NGX_OK;
  4133. }


  4136. static ngx_int_t
  4137. ‌ngx_http_grpc_send_window_update(ngx_http_request_t *r,
  4138.     ngx_http_grpc_ctx_t *ctx)
  4139. {
  4140.     size_t                  n;
  4141.     ngx_chain_t            *cl, **ll;
  4142.     ngx_http_grpc_frame_t  *f;

  4144.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4145.                    "grpc send window update: %uz %uz",
  4146.                    ctx->connection->recv_window, ctx->recv_window);

  4148.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4149.         ll = &cl->next;
  4150.     }

  4152.     cl = ngx_http_grpc_get_buf(r, ctx);
  4153.     if (cl == NULL) {
  4154.         return NGX_ERROR;
  4155.     }

  4157.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4158.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4160.     f->length_0 = 0;
  4161.     f->length_1 = 0;
  4162.     f->length_2 = 4;
  4163.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4164.     f->flags = 0;
  4165.     f->stream_id_0 = 0;
  4166.     f->stream_id_1 = 0;
  4167.     f->stream_id_2 = 0;
  4168.     f->stream_id_3 = 0;

  4170.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->connection->recv_window;
  4171.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4173.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4174.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4175.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4176.     *cl->buf->last++ = (u_char) (n & 0xff);

  4178.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4179.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4181.     f->length_0 = 0;
  4182.     f->length_1 = 0;
  4183.     f->length_2 = 4;
  4184.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4185.     f->flags = 0;
  4186.     f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  4187.     f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  4188.     f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  4189.     f->stream_id_3 = (u_char) (ctx->id & 0xff);

  4191.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->recv_window;
  4192.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4194.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4195.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4196.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4197.     *cl->buf->last++ = (u_char) (n & 0xff);

  4199.     *ll = cl;

  4201.     return NGX_OK;
  4202. }


  4205. static ngx_chain_t *
  4206. ‌ngx_http_grpc_get_buf(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  4207. {
  4208.     u_char       *start;
  4209.     ngx_buf_t    *b;
  4210.     ngx_chain_t  *cl;

  4212.     cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  4213.     if (cl == NULL) {
  4214.         return NULL;
  4215.     }

  4217.     b = cl->buf;
  4218.     start = b->start;

  4220.     if (start == NULL) {

  4222.         /*
  4223.          * each buffer is large enough to hold two window update
  4224.          * frames in a row
  4225.          */

  4227.         start = ngx_palloc(r->pool, 2 * sizeof(ngx_http_grpc_frame_t) + 8);
  4228.         if (start == NULL) {
  4229.             return NULL;
  4230.         }

  4232.     }

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

  4236.     b->start = start;
  4237.     b->pos = start;
  4238.     b->last = start;
  4239.     b->end = start + 2 * sizeof(ngx_http_grpc_frame_t) + 8;

  4241.     b->tag = (ngx_buf_tag_t) &ngx_http_grpc_body_output_filter;
  4242.     b->temporary = 1;
  4243.     b->flush = 1;

  4245.     return cl;
  4246. }


  4249. static ngx_http_grpc_ctx_t *
  4250. ‌ngx_http_grpc_get_ctx(ngx_http_request_t *r)
  4251. {
  4252.     ngx_http_grpc_ctx_t  *ctx;
  4253.     ngx_http_upstream_t  *u;

  4255.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

  4257.     if (ctx->connection == NULL) {
  4258.         u = r->upstream;

  4260.         if (ngx_http_grpc_get_connection_data(r, ctx, &u->peer) != NGX_OK) {
  4261.             return NULL;
  4262.         }
  4263.     }

  4265.     return ctx;
  4266. }


  4269. static ngx_int_t
  4270. ‌ngx_http_grpc_get_connection_data(ngx_http_request_t *r,
  4271.     ngx_http_grpc_ctx_t *ctx, ngx_peer_connection_t *pc)
  4272. {
  4273.     ngx_connection_t    *c;
  4274.     ngx_pool_cleanup_t  *cln;

  4276.     c = pc->connection;

  4278.     if (pc->cached) {

  4280.         /*
  4281.          * for cached connections, connection data can be found
  4282.          * in the cleanup handler
  4283.          */

  4285.         for (cln = c->pool->cleanup; cln; cln = cln->next) {
  4286.             if (cln->handler == ngx_http_grpc_cleanup) {
  4287.                 ctx->connection = cln->data;
  4288.                 break;
  4289.             }
  4290.         }

  4292.         if (ctx->connection == NULL) {
  4293.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  4294.                           "no connection data found for "
  4295.                           "keepalive http2 connection");
  4296.             return NGX_ERROR;
  4297.         }

  4299.         ctx->send_window = ctx->connection->init_window;
  4300.         ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4302.         ctx->connection->last_stream_id += 2;
  4303.         ctx->id = ctx->connection->last_stream_id;

  4305.         return NGX_OK;
  4306.     }

  4308.     cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_grpc_conn_t));
  4309.     if (cln == NULL) {
  4310.         return NGX_ERROR;
  4311.     }

  4313.     cln->handler = ngx_http_grpc_cleanup;
  4314.     ctx->connection = cln->data;

  4316.     ctx->connection->init_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4317.     ctx->connection->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4318.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4320.     ctx->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4321.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4323.     ctx->id = 1;
  4324.     ctx->connection->last_stream_id = 1;

  4326.     return NGX_OK;
  4327. }


  4330. static void
  4331. ‌ngx_http_grpc_cleanup(void *data)
  4332. {
  4333. #if 0
  4334.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  4335.                    "grpc cleanup");
  4336. #endif
  4337.     return;
  4338. }


  4341. static void
  4342. ‌ngx_http_grpc_abort_request(ngx_http_request_t *r)
  4343. {
  4344.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4345.                    "abort grpc request");
  4346.     return;
  4347. }


  4350. static void
  4351. ‌ngx_http_grpc_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  4352. {
  4353.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4354.                    "finalize grpc request");
  4355.     return;
  4356. }


  4359. static ngx_int_t
  4360. ‌ngx_http_grpc_internal_trailers_variable(ngx_http_request_t *r,
  4361.     ngx_http_variable_value_t *v, uintptr_t data)
  4362. {
  4363.     ngx_table_elt_t  *te;

  4365.     te = r->headers_in.te;

  4367.     if (te == NULL) {
  4368.         v->not_found = 1;
  4369.         return NGX_OK;
  4370.     }

  4372.     if (ngx_strlcasestrn(te->value.data, te->value.data + te->value.len,
  4373.                          (u_char *) "trailers", 8 - 1)
  4374.         == NULL)
  4375.     {
  4376.         v->not_found = 1;
  4377.         return NGX_OK;
  4378.     }

  4380.     v->valid = 1;
  4381.     v->no_cacheable = 0;
  4382.     v->not_found = 0;

  4384.     v->data = (u_char *) "trailers";
  4385.     v->len = sizeof("trailers") - 1;

  4387.     return NGX_OK;
  4388. }


  4391. static ngx_int_t
  4392. ‌ngx_http_grpc_add_variables(ngx_conf_t *cf)
  4393. {
  4394.     ngx_http_variable_t  *var, *v;

  4396.     for (v = ngx_http_grpc_vars; v->name.len; v++) {
  4397.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  4398.         if (var == NULL) {
  4399.             return NGX_ERROR;
  4400.         }

  4402.         var->get_handler = v->get_handler;
  4403.         var->data = v->data;
  4404.     }

  4406.     return NGX_OK;
  4407. }


  4410. static void *
  4411. ‌ngx_http_grpc_create_loc_conf(ngx_conf_t *cf)
  4412. {
  4413.     ngx_http_grpc_loc_conf_t  *conf;

  4415.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_grpc_loc_conf_t));
  4416.     if (conf == NULL) {
  4417.         return NULL;
  4418.     }

  4420.     /*
  4421.      * set by ngx_pcalloc():
  4422.      *
  4423.      *     conf->upstream.ignore_headers = 0;
  4424.      *     conf->upstream.next_upstream = 0;
  4425.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  4426.      *
  4427.      *     conf->headers.lengths = NULL;
  4428.      *     conf->headers.values = NULL;
  4429.      *     conf->headers.hash = { NULL, 0 };
  4430.      *     conf->host = { 0, NULL };
  4431.      *     conf->host_set = 0;
  4432.      *     conf->ssl = 0;
  4433.      *     conf->ssl_protocols = 0;
  4434.      *     conf->ssl_ciphers = { 0, NULL };
  4435.      *     conf->ssl_trusted_certificate = { 0, NULL };
  4436.      *     conf->ssl_crl = { 0, NULL };
  4437.      */

  4439.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  4440.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;
  4441.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  4442.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  4443.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  4444.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  4445.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  4447.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;

  4449.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  4450.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  4452.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  4454. #if (NGX_HTTP_SSL)
  4455.     conf->upstream.ssl_session_reuse = NGX_CONF_UNSET;
  4456.     conf->upstream.ssl_name = NGX_CONF_UNSET_PTR;
  4457.     conf->upstream.ssl_server_name = NGX_CONF_UNSET;
  4458.     conf->upstream.ssl_verify = NGX_CONF_UNSET;
  4459.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  4460.     conf->upstream.ssl_certificate = NGX_CONF_UNSET_PTR;
  4461.     conf->upstream.ssl_certificate_key = NGX_CONF_UNSET_PTR;
  4462.     conf->upstream.ssl_certificate_cache = NGX_CONF_UNSET_PTR;
  4463.     conf->upstream.ssl_passwords = NGX_CONF_UNSET_PTR;
  4464.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  4465. #endif

  4467.     /* the hardcoded values */
  4468.     conf->upstream.cyclic_temp_file = 0;
  4469.     conf->upstream.buffering = 0;
  4470.     conf->upstream.ignore_client_abort = 0;
  4471.     conf->upstream.send_lowat = 0;
  4472.     conf->upstream.bufs.num = 0;
  4473.     conf->upstream.busy_buffers_size = 0;
  4474.     conf->upstream.max_temp_file_size = 0;
  4475.     conf->upstream.temp_file_write_size = 0;
  4476.     conf->upstream.pass_request_headers = 1;
  4477.     conf->upstream.pass_request_body = 1;
  4478.     conf->upstream.force_ranges = 0;
  4479.     conf->upstream.pass_trailers = 1;
  4480.     conf->upstream.pass_early_hints = 1;
  4481.     conf->upstream.preserve_output = 1;

  4483.     conf->headers_source = NGX_CONF_UNSET_PTR;

  4485.     ngx_str_set(&conf->upstream.module, "grpc");

  4487.     return conf;
  4488. }


  4491. static char *
  4492. ‌ngx_http_grpc_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  4493. {
  4494.     ngx_http_grpc_loc_conf_t *prev = parent;
  4495.     ngx_http_grpc_loc_conf_t *conf = child;

  4497.     ngx_int_t                  rc;
  4498.     ngx_hash_init_t            hash;
  4499.     ngx_http_core_loc_conf_t  *clcf;

  4501.     ngx_conf_merge_ptr_value(conf->upstream.local,
  4502.                               prev->upstream.local, NULL);

  4504.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  4505.                               prev->upstream.socket_keepalive, 0);

  4507.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  4508.                               prev->upstream.next_upstream_tries, 0);

  4510.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  4511.                               prev->upstream.connect_timeout, 60000);

  4513.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  4514.                               prev->upstream.send_timeout, 60000);

  4516.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  4517.                               prev->upstream.read_timeout, 60000);

  4519.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  4520.                               prev->upstream.next_upstream_timeout, 0);

  4522.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  4523.                               prev->upstream.buffer_size,
  4524.                               (size_t) ngx_pagesize);

  4526.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  4527.                               prev->upstream.ignore_headers,
  4528.                               NGX_CONF_BITMASK_SET);

  4530.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  4531.                               prev->upstream.next_upstream,
  4532.                               (NGX_CONF_BITMASK_SET
  4533.                                |NGX_HTTP_UPSTREAM_FT_ERROR
  4534.                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  4536.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  4537.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  4538.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  4539.     }

  4541.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  4542.                               prev->upstream.intercept_errors, 0);

  4544. #if (NGX_HTTP_SSL)

  4546.     if (ngx_http_grpc_merge_ssl(cf, conf, prev) != NGX_OK) {
  4547.         return NGX_CONF_ERROR;
  4548.     }

  4550.     ngx_conf_merge_value(conf->upstream.ssl_session_reuse,
  4551.                               prev->upstream.ssl_session_reuse, 1);

  4553.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  4554.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  4556.     ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers,
  4557.                              "DEFAULT");

  4559.     ngx_conf_merge_ptr_value(conf->upstream.ssl_name,
  4560.                               prev->upstream.ssl_name, NULL);
  4561.     ngx_conf_merge_value(conf->upstream.ssl_server_name,
  4562.                               prev->upstream.ssl_server_name, 0);
  4563.     ngx_conf_merge_value(conf->upstream.ssl_verify,
  4564.                               prev->upstream.ssl_verify, 0);
  4565.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  4566.                               prev->ssl_verify_depth, 1);
  4567.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  4568.                               prev->ssl_trusted_certificate, "");
  4569.     ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");

  4571.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate,
  4572.                               prev->upstream.ssl_certificate, NULL);
  4573.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_key,
  4574.                               prev->upstream.ssl_certificate_key, NULL);
  4575.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_cache,
  4576.                               prev->upstream.ssl_certificate_cache, NULL);

  4578.     if (ngx_http_upstream_merge_ssl_passwords(cf, &conf->upstream,
  4579.                                               &prev->upstream)
  4580.         != NGX_OK)
  4581.     {
  4582.         return NGX_CONF_ERROR;
  4583.     }

  4585.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  4586.                               prev->ssl_conf_commands, NULL);

  4588.     if (conf->ssl && ngx_http_grpc_set_ssl(cf, conf) != NGX_OK) {
  4589.         return NGX_CONF_ERROR;
  4590.     }

  4592. #endif

  4594.     hash.max_size = 512;
  4595.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  4596.     hash.name = "grpc_headers_hash";

  4598.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  4599.             &prev->upstream, ngx_http_grpc_hide_headers, &hash)
  4600.         != NGX_OK)
  4601.     {
  4602.         return NGX_CONF_ERROR;
  4603.     }

  4605.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  4607.     if (clcf->noname
  4608.         && conf->upstream.upstream == NULL && conf->grpc_lengths == NULL)
  4609.     {
  4610.         conf->upstream.upstream = prev->upstream.upstream;
  4611.         conf->host = prev->host;

  4613.         conf->grpc_lengths = prev->grpc_lengths;
  4614.         conf->grpc_values = prev->grpc_values;

  4616. #if (NGX_HTTP_SSL)
  4617.         conf->ssl = prev->ssl;
  4618. #endif
  4619.     }

  4621.     if (clcf->lmt_excpt && clcf->handler == NULL
  4622.         && (conf->upstream.upstream || conf->grpc_lengths))
  4623.     {
  4624.         clcf->handler = ngx_http_grpc_handler;
  4625.     }

  4627.     ngx_conf_merge_ptr_value(conf->headers_source, prev->headers_source, NULL);

  4629.     if (conf->headers_source == prev->headers_source) {
  4630.         conf->headers = prev->headers;
  4631.         conf->host_set = prev->host_set;
  4632.     }

  4634.     rc = ngx_http_grpc_init_headers(cf, conf, &conf->headers,
  4635.                                     ngx_http_grpc_headers);
  4636.     if (rc != NGX_OK) {
  4637.         return NGX_CONF_ERROR;
  4638.     }

  4640.     /*
  4641.      * special handling to preserve conf->headers in the "http" section
  4642.      * to inherit it to all servers
  4643.      */

  4645.     if (prev->headers.hash.buckets == NULL
  4646.         && conf->headers_source == prev->headers_source)
  4647.     {
  4648.         prev->headers = conf->headers;
  4649.         prev->host_set = conf->host_set;
  4650.     }

  4652.     return NGX_CONF_OK;
  4653. }


  4656. static ngx_int_t
  4657. ‌ngx_http_grpc_init_headers(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *conf,
  4658.     ngx_http_grpc_headers_t *headers, ngx_keyval_t *default_headers)
  4659. {
  4660.     u_char                       *p;
  4661.     size_t                        size;
  4662.     uintptr_t                    *code;
  4663.     ngx_uint_t                    i;
  4664.     ngx_array_t                   headers_names, headers_merged;
  4665.     ngx_keyval_t                 *src, *s, *h;
  4666.     ngx_hash_key_t               *hk;
  4667.     ngx_hash_init_t               hash;
  4668.     ngx_http_script_compile_t     sc;
  4669.     ngx_http_script_copy_code_t  *copy;

  4671.     if (headers->hash.buckets) {
  4672.         return NGX_OK;
  4673.     }

  4675.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  4676.         != NGX_OK)
  4677.     {
  4678.         return NGX_ERROR;
  4679.     }

  4681.     if (ngx_array_init(&headers_merged, cf->temp_pool, 4, sizeof(ngx_keyval_t))
  4682.         != NGX_OK)
  4683.     {
  4684.         return NGX_ERROR;
  4685.     }

  4687.     headers->lengths = ngx_array_create(cf->pool, 64, 1);
  4688.     if (headers->lengths == NULL) {
  4689.         return NGX_ERROR;
  4690.     }

  4692.     headers->values = ngx_array_create(cf->pool, 512, 1);
  4693.     if (headers->values == NULL) {
  4694.         return NGX_ERROR;
  4695.     }

  4697.     if (conf->headers_source) {

  4699.         src = conf->headers_source->elts;
  4700.         for (i = 0; i < conf->headers_source->nelts; i++) {

  4702.             if (src[i].key.len == 4
  4703.                 && ngx_strncasecmp(src[i].key.data, (u_char *) "Host", 4) == 0)
  4704.             {
  4705.                 conf->host_set = 1;
  4706.             }

  4708.             s = ngx_array_push(&headers_merged);
  4709.             if (s == NULL) {
  4710.                 return NGX_ERROR;
  4711.             }

  4713.             *s = src[i];
  4714.         }
  4715.     }

  4717.     h = default_headers;

  4719.     while (h->key.len) {

  4721.         src = headers_merged.elts;
  4722.         for (i = 0; i < headers_merged.nelts; i++) {
  4723.             if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  4724.                 goto next;
  4725.             }
  4726.         }

  4728.         s = ngx_array_push(&headers_merged);
  4729.         if (s == NULL) {
  4730.             return NGX_ERROR;
  4731.         }

  4733.         *s = *h;

  4735.     next:

  4737.         h++;
  4738.     }


  4741.     src = headers_merged.elts;
  4742.     for (i = 0; i < headers_merged.nelts; i++) {

  4744.         hk = ngx_array_push(&headers_names);
  4745.         if (hk == NULL) {
  4746.             return NGX_ERROR;
  4747.         }

  4749.         hk->key = src[i].key;
  4750.         hk->key_hash = ngx_hash_key_lc(src[i].key.data, src[i].key.len);
  4751.         hk->value = (void *) 1;

  4753.         if (src[i].value.len == 0) {
  4754.             continue;
  4755.         }

  4757.         copy = ngx_array_push_n(headers->lengths,
  4758.                                 sizeof(ngx_http_script_copy_code_t));
  4759.         if (copy == NULL) {
  4760.             return NGX_ERROR;
  4761.         }

  4763.         copy->code = (ngx_http_script_code_pt) (void *)
  4764.                                                  ngx_http_script_copy_len_code;
  4765.         copy->len = src[i].key.len;

  4767.         size = (sizeof(ngx_http_script_copy_code_t)
  4768.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  4769.                & ~(sizeof(uintptr_t) - 1);

  4771.         copy = ngx_array_push_n(headers->values, size);
  4772.         if (copy == NULL) {
  4773.             return NGX_ERROR;
  4774.         }

  4776.         copy->code = ngx_http_script_copy_code;
  4777.         copy->len = src[i].key.len;

  4779.         p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
  4780.         ngx_memcpy(p, src[i].key.data, src[i].key.len);

  4782.         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  4784.         sc.cf = cf;
  4785.         sc.source = &src[i].value;
  4786.         sc.flushes = &headers->flushes;
  4787.         sc.lengths = &headers->lengths;
  4788.         sc.values = &headers->values;

  4790.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  4791.             return NGX_ERROR;
  4792.         }

  4794.         code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
  4795.         if (code == NULL) {
  4796.             return NGX_ERROR;
  4797.         }

  4799.         *code = (uintptr_t) NULL;

  4801.         code = ngx_array_push_n(headers->values, sizeof(uintptr_t));
  4802.         if (code == NULL) {
  4803.             return NGX_ERROR;
  4804.         }

  4806.         *code = (uintptr_t) NULL;
  4807.     }

  4809.     code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
  4810.     if (code == NULL) {
  4811.         return NGX_ERROR;
  4812.     }

  4814.     *code = (uintptr_t) NULL;


  4817.     hash.hash = &headers->hash;
  4818.     hash.key = ngx_hash_key_lc;
  4819.     hash.max_size = 512;
  4820.     hash.bucket_size = 64;
  4821.     hash.name = "grpc_headers_hash";
  4822.     hash.pool = cf->pool;
  4823.     hash.temp_pool = NULL;

  4825.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  4826. }


  4829. static char *
  4830. ‌ngx_http_grpc_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4831. {
  4832.     ngx_http_grpc_loc_conf_t *glcf = conf;

  4834.     size_t                      add;
  4835.     ngx_str_t                  *value, *url;
  4836.     ngx_url_t                   u;
  4837.     ngx_uint_t                  n;
  4838.     ngx_http_core_loc_conf_t   *clcf;
  4839.     ngx_http_script_compile_t   sc;

  4841.     if (glcf->upstream.upstream || glcf->grpc_lengths) {
  4842.         return "is duplicate";
  4843.     }

  4845.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  4847.     clcf->handler = ngx_http_grpc_handler;

  4849.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  4850.         clcf->auto_redirect = 1;
  4851.     }

  4853.     value = cf->args->elts;

  4855.     url = &value[1];

  4857.     n = ngx_http_script_variables_count(url);

  4859.     if (n) {

  4861.         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  4863.         sc.cf = cf;
  4864.         sc.source = url;
  4865.         sc.lengths = &glcf->grpc_lengths;
  4866.         sc.values = &glcf->grpc_values;
  4867.         sc.variables = n;
  4868.         sc.complete_lengths = 1;
  4869.         sc.complete_values = 1;

  4871.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  4872.             return NGX_CONF_ERROR;
  4873.         }

  4875. #if (NGX_HTTP_SSL)
  4876.         glcf->ssl = 1;
  4877. #endif

  4879.         return NGX_CONF_OK;
  4880.     }

  4882.     if (ngx_strncasecmp(url->data, (u_char *) "grpc://", 7) == 0) {
  4883.         add = 7;

  4885.     } else if (ngx_strncasecmp(url->data, (u_char *) "grpcs://", 8) == 0) {

  4887. #if (NGX_HTTP_SSL)
  4888.         glcf->ssl = 1;

  4890.         add = 8;
  4891. #else
  4892.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4893.                            "grpcs protocol requires SSL support");
  4894.         return NGX_CONF_ERROR;
  4895. #endif

  4897.     } else {
  4898.         add = 0;
  4899.     }

  4901.     ngx_memzero(&u, sizeof(ngx_url_t));

  4903.     u.url.len = url->len - add;
  4904.     u.url.data = url->data + add;
  4905.     u.no_resolve = 1;

  4907.     glcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  4908.     if (glcf->upstream.upstream == NULL) {
  4909.         return NGX_CONF_ERROR;
  4910.     }

  4912.     if (u.family != AF_UNIX) {

  4914.         if (u.no_port) {
  4915.             glcf->host = u.host;

  4917.         } else {
  4918.             glcf->host.len = u.host.len + 1 + u.port_text.len;
  4919.             glcf->host.data = u.host.data;
  4920.         }

  4922.     } else {
  4923.         ngx_str_set(&glcf->host, "localhost");
  4924.     }

  4926.     return NGX_CONF_OK;
  4927. }


  4930. #if (NGX_HTTP_SSL)

  4932. static char *
  4933. ‌ngx_http_grpc_ssl_certificate_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  4934.     void *conf)
  4935. {
  4936.     ngx_http_grpc_loc_conf_t *plcf = conf;

  4938.     time_t       inactive, valid;
  4939.     ngx_str_t   *value, s;
  4940.     ngx_int_t    max;
  4941.     ngx_uint_t   i;

  4943.     if (plcf->upstream.ssl_certificate_cache != NGX_CONF_UNSET_PTR) {
  4944.         return "is duplicate";
  4945.     }

  4947.     value = cf->args->elts;

  4949.     max = 0;
  4950.     inactive = 10;
  4951.     valid = 60;

  4953.     for (i = 1; i < cf->args->nelts; i++) {

  4955.         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {

  4957.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  4958.             if (max <= 0) {
  4959.                 goto failed;
  4960.             }

  4962.             continue;
  4963.         }

  4965.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  4967.             s.len = value[i].len - 9;
  4968.             s.data = value[i].data + 9;

  4970.             inactive = ngx_parse_time(&s, 1);
  4971.             if (inactive == (time_t) NGX_ERROR) {
  4972.                 goto failed;
  4973.             }

  4975.             continue;
  4976.         }

  4978.         if (ngx_strncmp(value[i].data, "valid=", 6) == 0) {

  4980.             s.len = value[i].len - 6;
  4981.             s.data = value[i].data + 6;

  4983.             valid = ngx_parse_time(&s, 1);
  4984.             if (valid == (time_t) NGX_ERROR) {
  4985.                 goto failed;
  4986.             }

  4988.             continue;
  4989.         }

  4991.         if (ngx_strcmp(value[i].data, "off") == 0) {

  4993.             plcf->upstream.ssl_certificate_cache = NULL;

  4995.             continue;
  4996.         }

  4998.     failed:

  5000.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5001.                            "invalid parameter \"%V\"", &value[i]);
  5002.         return NGX_CONF_ERROR;
  5003.     }

  5005.     if (plcf->upstream.ssl_certificate_cache == NULL) {
  5006.         return NGX_CONF_OK;
  5007.     }

  5009.     if (max == 0) {
  5010.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5011.                            "\"grpc_ssl_certificate_cache\" must have "
  5012.                            "the \"max\" parameter");
  5013.         return NGX_CONF_ERROR;
  5014.     }

  5016.     plcf->upstream.ssl_certificate_cache = ngx_ssl_cache_init(cf->pool, max,
  5017.                                                               valid, inactive);
  5018.     if (plcf->upstream.ssl_certificate_cache == NULL) {
  5019.         return NGX_CONF_ERROR;
  5020.     }

  5022.     return NGX_CONF_OK;
  5023. }


  5026. static char *
  5027. ‌ngx_http_grpc_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5028. {
  5029.     ngx_http_grpc_loc_conf_t *glcf = conf;

  5031.     ngx_str_t  *value;

  5033.     if (glcf->upstream.ssl_passwords != NGX_CONF_UNSET_PTR) {
  5034.         return "is duplicate";
  5035.     }

  5037.     value = cf->args->elts;

  5039.     glcf->upstream.ssl_passwords = ngx_ssl_read_password_file(cf, &value[1]);

  5041.     if (glcf->upstream.ssl_passwords == NULL) {
  5042.         return NGX_CONF_ERROR;
  5043.     }

  5045.     return NGX_CONF_OK;
  5046. }


  5049. static char *
  5050. ‌ngx_http_grpc_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  5051. {
  5052. #ifndef SSL_CONF_FLAG_FILE
  5053.     return "is not supported on this platform";
  5054. #else
  5055.     return NGX_CONF_OK;
  5056. #endif
  5057. }


  5060. static ngx_int_t
  5061. ‌ngx_http_grpc_merge_ssl(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *conf,
  5062.     ngx_http_grpc_loc_conf_t *prev)
  5063. {
  5064.     ngx_uint_t  preserve;

  5066.     if (conf->ssl_protocols == 0
  5067.         && conf->ssl_ciphers.data == NULL
  5068.         && conf->upstream.ssl_certificate == NGX_CONF_UNSET_PTR
  5069.         && conf->upstream.ssl_certificate_key == NGX_CONF_UNSET_PTR
  5070.         && conf->upstream.ssl_passwords == NGX_CONF_UNSET_PTR
  5071.         && conf->upstream.ssl_verify == NGX_CONF_UNSET
  5072.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  5073.         && conf->ssl_trusted_certificate.data == NULL
  5074.         && conf->ssl_crl.data == NULL
  5075.         && conf->upstream.ssl_session_reuse == NGX_CONF_UNSET
  5076.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  5077.     {
  5078.         if (prev->upstream.ssl) {
  5079.             conf->upstream.ssl = prev->upstream.ssl;
  5080.             return NGX_OK;
  5081.         }

  5083.         preserve = 1;

  5085.     } else {
  5086.         preserve = 0;
  5087.     }

  5089.     conf->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  5090.     if (conf->upstream.ssl == NULL) {
  5091.         return NGX_ERROR;
  5092.     }

  5094.     conf->upstream.ssl->log = cf->log;

  5096.     /*
  5097.      * special handling to preserve conf->upstream.ssl
  5098.      * in the "http" section to inherit it to all servers
  5099.      */

  5101.     if (preserve) {
  5102.         prev->upstream.ssl = conf->upstream.ssl;
  5103.     }

  5105.     return NGX_OK;
  5106. }


  5109. static ngx_int_t
  5110. ‌ngx_http_grpc_set_ssl(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *glcf)
  5111. {
  5112.     ngx_pool_cleanup_t  *cln;

  5114.     if (glcf->upstream.ssl->ctx) {
  5115.         return NGX_OK;
  5116.     }

  5118.     if (ngx_ssl_create(glcf->upstream.ssl, glcf->ssl_protocols, NULL)
  5119.         != NGX_OK)
  5120.     {
  5121.         return NGX_ERROR;
  5122.     }

  5124.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  5125.     if (cln == NULL) {
  5126.         ngx_ssl_cleanup_ctx(glcf->upstream.ssl);
  5127.         return NGX_ERROR;
  5128.     }

  5130.     cln->handler = ngx_ssl_cleanup_ctx;
  5131.     cln->data = glcf->upstream.ssl;

  5133.     if (ngx_ssl_ciphers(cf, glcf->upstream.ssl, &glcf->ssl_ciphers, 0)
  5134.         != NGX_OK)
  5135.     {
  5136.         return NGX_ERROR;
  5137.     }

  5139.     if (glcf->upstream.ssl_certificate
  5140.         && glcf->upstream.ssl_certificate->value.len)
  5141.     {
  5142.         if (glcf->upstream.ssl_certificate_key == NULL) {
  5143.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  5144.                           "no \"grpc_ssl_certificate_key\" is defined "
  5145.                           "for certificate \"%V\"",
  5146.                           &glcf->upstream.ssl_certificate->value);
  5147.             return NGX_ERROR;
  5148.         }

  5150.         if (glcf->upstream.ssl_certificate->lengths == NULL
  5151.             && glcf->upstream.ssl_certificate_key->lengths == NULL)
  5152.         {
  5153.             if (ngx_ssl_certificate(cf, glcf->upstream.ssl,
  5154.                                     &glcf->upstream.ssl_certificate->value,
  5155.                                     &glcf->upstream.ssl_certificate_key->value,
  5156.                                     glcf->upstream.ssl_passwords)
  5157.                 != NGX_OK)
  5158.             {
  5159.                 return NGX_ERROR;
  5160.             }
  5161.         }
  5162.     }

  5164.     if (glcf->upstream.ssl_verify) {
  5165.         if (glcf->ssl_trusted_certificate.len == 0) {
  5166.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  5167.                       "no grpc_ssl_trusted_certificate for grpc_ssl_verify");
  5168.             return NGX_ERROR;
  5169.         }

  5171.         if (ngx_ssl_trusted_certificate(cf, glcf->upstream.ssl,
  5172.                                         &glcf->ssl_trusted_certificate,
  5173.                                         glcf->ssl_verify_depth)
  5174.             != NGX_OK)
  5175.         {
  5176.             return NGX_ERROR;
  5177.         }

  5179.         if (ngx_ssl_crl(cf, glcf->upstream.ssl, &glcf->ssl_crl) != NGX_OK) {
  5180.             return NGX_ERROR;
  5181.         }
  5182.     }

  5184.     if (ngx_ssl_client_session_cache(cf, glcf->upstream.ssl,
  5185.                                      glcf->upstream.ssl_session_reuse)
  5186.         != NGX_OK)
  5187.     {
  5188.         return NGX_ERROR;
  5189.     }

  5191. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  5193.     if (SSL_CTX_set_alpn_protos(glcf->upstream.ssl->ctx,
  5194.                                 (u_char *) "\x02h2", 3)
  5195.         != 0)
  5196.     {
  5197.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  5198.                       "SSL_CTX_set_alpn_protos() failed");
  5199.         return NGX_ERROR;
  5200.     }

  5202. #endif

  5204.     if (ngx_ssl_conf_commands(cf, glcf->upstream.ssl, glcf->ssl_conf_commands)
  5205.         != NGX_OK)
  5206.     {
  5207.         return NGX_ERROR;
  5208.     }

  5210.     return NGX_OK;
  5211. }

  5213. #endif

One Level Up Top Level