One Level Up Top Level

src/http/modules/ngx_http_grpc_module.c - nginx source code

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_password_file(ngx_conf_t *cf,
  209.     ngx_command_t *cmd, void *conf);
  210. static char *ngx_http_grpc_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  211.     void *data);
  212. static ngx_int_t ngx_http_grpc_merge_ssl(ngx_conf_t *cf,
  213.     ngx_http_grpc_loc_conf_t *conf, ngx_http_grpc_loc_conf_t *prev);
  214. static ngx_int_t ngx_http_grpc_set_ssl(ngx_conf_t *cf,
  215.     ngx_http_grpc_loc_conf_t *glcf);
  216. #endif


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


  236. #if (NGX_HTTP_SSL)

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

  248. ‌static ngx_conf_post_t  ngx_http_grpc_ssl_conf_command_post =
  249.     { ngx_http_grpc_ssl_conf_command_check };

  251. #endif


  254. ‌static ngx_command_t  ngx_http_grpc_commands[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  361. #if (NGX_HTTP_SSL)

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

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

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

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

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

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

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

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

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

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

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

  440.     { ngx_string("grpc_ssl_password_file"),
  441.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  442.       ngx_http_grpc_ssl_password_file,
  443.       NGX_HTTP_LOC_CONF_OFFSET,
  444.       0,
  445.       NULL },

  447.     { ngx_string("grpc_ssl_conf_command"),
  448.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  449.       ngx_conf_set_keyval_slot,
  450.       NGX_HTTP_LOC_CONF_OFFSET,
  451.       offsetof(ngx_http_grpc_loc_conf_t, ssl_conf_commands),
  452.       &ngx_http_grpc_ssl_conf_command_post },

  454. #endif

  456.       ngx_null_command
  457. };


  460. ‌static ngx_http_module_t  ngx_http_grpc_module_ctx = {
  461.     ngx_http_grpc_add_variables,           /* preconfiguration */
  462.     NULL,                                  /* postconfiguration */

  464.     NULL,                                  /* create main configuration */
  465.     NULL,                                  /* init main configuration */

  467.     NULL,                                  /* create server configuration */
  468.     NULL,                                  /* merge server configuration */

  470.     ngx_http_grpc_create_loc_conf,         /* create location configuration */
  471.     ngx_http_grpc_merge_loc_conf           /* merge location configuration */
  472. };


  475. ‌ngx_module_t  ngx_http_grpc_module = {
  476.     NGX_MODULE_V1,
  477.     &ngx_http_grpc_module_ctx,             /* module context */
  478.     ngx_http_grpc_commands,                /* module directives */
  479.     NGX_HTTP_MODULE,                       /* module type */
  480.     NULL,                                  /* init master */
  481.     NULL,                                  /* init module */
  482.     NULL,                                  /* init process */
  483.     NULL,                                  /* init thread */
  484.     NULL,                                  /* exit thread */
  485.     NULL,                                  /* exit process */
  486.     NULL,                                  /* exit master */
  487.     NGX_MODULE_V1_PADDING
  488. };


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

  494.     "\x00\x00\x12\x04\x00\x00\x00\x00\x00"     /* settings frame */
  495.     "\x00\x01\x00\x00\x00\x00"                 /* header table size */
  496.     "\x00\x02\x00\x00\x00\x00"                 /* disable push */
  497.     "\x00\x04\x7f\xff\xff\xff"                 /* initial window */

  499.     "\x00\x00\x04\x08\x00\x00\x00\x00\x00"     /* window update frame */
  500.     "\x7f\xff\x00\x00";


  503. ‌static ngx_keyval_t  ngx_http_grpc_headers[] = {
  504.     { ngx_string("Content-Length"), ngx_string("$content_length") },
  505.     { ngx_string("TE"), ngx_string("$grpc_internal_trailers") },
  506.     { ngx_string("Host"), ngx_string("") },
  507.     { ngx_string("Connection"), ngx_string("") },
  508.     { ngx_string("Transfer-Encoding"), ngx_string("") },
  509.     { ngx_string("Keep-Alive"), ngx_string("") },
  510.     { ngx_string("Expect"), ngx_string("") },
  511.     { ngx_string("Upgrade"), ngx_string("") },
  512.     { ngx_null_string, ngx_null_string }
  513. };


  516. ‌static ngx_str_t  ngx_http_grpc_hide_headers[] = {
  517.     ngx_string("Date"),
  518.     ngx_string("Server"),
  519.     ngx_string("X-Accel-Expires"),
  520.     ngx_string("X-Accel-Redirect"),
  521.     ngx_string("X-Accel-Limit-Rate"),
  522.     ngx_string("X-Accel-Buffering"),
  523.     ngx_string("X-Accel-Charset"),
  524.     ngx_null_string
  525. };


  528. ‌static ngx_http_variable_t  ngx_http_grpc_vars[] = {

  530.     { ngx_string("grpc_internal_trailers"), NULL,
  531.       ngx_http_grpc_internal_trailers_variable, 0,
  532.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  534.       ngx_http_null_variable
  535. };


  538. static ngx_int_t
  539. ‌ngx_http_grpc_handler(ngx_http_request_t *r)
  540. {
  541.     ngx_int_t                  rc;
  542.     ngx_http_upstream_t       *u;
  543.     ngx_http_grpc_ctx_t       *ctx;
  544.     ngx_http_grpc_loc_conf_t  *glcf;

  546.     if (ngx_http_upstream_create(r) != NGX_OK) {
  547.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  548.     }

  550.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_grpc_ctx_t));
  551.     if (ctx == NULL) {
  552.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  553.     }

  555.     ctx->request = r;

  557.     ngx_http_set_ctx(r, ctx, ngx_http_grpc_module);

  559.     glcf = ngx_http_get_module_loc_conf(r, ngx_http_grpc_module);

  561.     u = r->upstream;

  563.     if (glcf->grpc_lengths == NULL) {
  564.         ctx->host = glcf->host;

  566. #if (NGX_HTTP_SSL)
  567.         u->ssl = glcf->ssl;

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

  572.         } else {
  573.             ngx_str_set(&u->schema, "grpc://");
  574.         }
  575. #else
  576.         ngx_str_set(&u->schema, "grpc://");
  577. #endif

  579.     } else {
  580.         if (ngx_http_grpc_eval(r, ctx, glcf) != NGX_OK) {
  581.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  582.         }
  583.     }

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

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

  589.     u->create_request = ngx_http_grpc_create_request;
  590.     u->reinit_request = ngx_http_grpc_reinit_request;
  591.     u->process_header = ngx_http_grpc_process_header;
  592.     u->abort_request = ngx_http_grpc_abort_request;
  593.     u->finalize_request = ngx_http_grpc_finalize_request;

  595.     u->input_filter_init = ngx_http_grpc_filter_init;
  596.     u->input_filter = ngx_http_grpc_filter;
  597.     u->input_filter_ctx = ctx;

  599.     r->request_body_no_buffering = 1;

  601.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  603.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  604.         return rc;
  605.     }

  607.     return NGX_DONE;
  608. }


  611. static ngx_int_t
  612. ‌ngx_http_grpc_eval(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  613.     ngx_http_grpc_loc_conf_t *glcf)
  614. {
  615.     size_t                add;
  616.     ngx_url_t             url;
  617.     ngx_http_upstream_t  *u;

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

  621.     if (ngx_http_script_run(r, &url.url, glcf->grpc_lengths->elts, 0,
  622.                             glcf->grpc_values->elts)
  623.         == NULL)
  624.     {
  625.         return NGX_ERROR;
  626.     }

  628.     if (url.url.len > 7
  629.         && ngx_strncasecmp(url.url.data, (u_char *) "grpc://", 7) == 0)
  630.     {
  631.         add = 7;

  633.     } else if (url.url.len > 8
  634.                && ngx_strncasecmp(url.url.data, (u_char *) "grpcs://", 8) == 0)
  635.     {

  637. #if (NGX_HTTP_SSL)
  638.         add = 8;
  639.         r->upstream->ssl = 1;
  640. #else
  641.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  642.                       "grpcs protocol requires SSL support");
  643.         return NGX_ERROR;
  644. #endif

  646.     } else {
  647.         add = 0;
  648.     }

  650.     u = r->upstream;

  652.     if (add) {
  653.         u->schema.len = add;
  654.         u->schema.data = url.url.data;

  656.         url.url.data += add;
  657.         url.url.len -= add;

  659.     } else {
  660.         ngx_str_set(&u->schema, "grpc://");
  661.     }

  663.     url.no_resolve = 1;

  665.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  666.         if (url.err) {
  667.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  668.                           "%s in upstream \"%V\"", url.err, &url.url);
  669.         }

  671.         return NGX_ERROR;
  672.     }

  674.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  675.     if (u->resolved == NULL) {
  676.         return NGX_ERROR;
  677.     }

  679.     if (url.addrs) {
  680.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  681.         u->resolved->socklen = url.addrs[0].socklen;
  682.         u->resolved->name = url.addrs[0].name;
  683.         u->resolved->naddrs = 1;
  684.     }

  686.     u->resolved->host = url.host;
  687.     u->resolved->port = url.port;
  688.     u->resolved->no_port = url.no_port;

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

  692.         if (url.no_port) {
  693.             ctx->host = url.host;

  695.         } else {
  696.             ctx->host.len = url.host.len + 1 + url.port_text.len;
  697.             ctx->host.data = url.host.data;
  698.         }

  700.     } else {
  701.         ngx_str_set(&ctx->host, "localhost");
  702.     }

  704.     return NGX_OK;
  705. }


  708. static ngx_int_t
  709. ‌ngx_http_grpc_create_request(ngx_http_request_t *r)
  710. {
  711.     u_char                       *p, *tmp, *key_tmp, *val_tmp, *headers_frame;
  712.     size_t                        len, tmp_len, key_len, val_len, uri_len;
  713.     uintptr_t                     escape;
  714.     ngx_buf_t                    *b;
  715.     ngx_uint_t                    i, next;
  716.     ngx_chain_t                  *cl, *body;
  717.     ngx_list_part_t              *part;
  718.     ngx_table_elt_t              *header;
  719.     ngx_http_grpc_ctx_t          *ctx;
  720.     ngx_http_upstream_t          *u;
  721.     ngx_http_grpc_frame_t        *f;
  722.     ngx_http_script_code_pt       code;
  723.     ngx_http_grpc_loc_conf_t     *glcf;
  724.     ngx_http_script_engine_t      e, le;
  725.     ngx_http_script_len_code_pt   lcode;

  727.     u = r->upstream;

  729.     glcf = ngx_http_get_module_loc_conf(r, ngx_http_grpc_module);

  731.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

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

  736.     /* :method header */

  738.     if (r->method == NGX_HTTP_GET || r->method == NGX_HTTP_POST) {
  739.         len += 1;
  740.         tmp_len = 0;

  742.     } else {
  743.         len += 1 + NGX_HTTP_V2_INT_OCTETS + r->method_name.len;
  744.         tmp_len = r->method_name.len;
  745.     }

  747.     /* :scheme header */

  749.     len += 1;

  751.     /* :path header */

  753.     if (r->valid_unparsed_uri) {
  754.         escape = 0;
  755.         uri_len = r->unparsed_uri.len;

  757.     } else {
  758.         escape = 2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len,
  759.                                     NGX_ESCAPE_URI);
  760.         uri_len = r->uri.len + escape + sizeof("?") - 1 + r->args.len;
  761.     }

  763.     len += 1 + NGX_HTTP_V2_INT_OCTETS + uri_len;

  765.     if (tmp_len < uri_len) {
  766.         tmp_len = uri_len;
  767.     }

  769.     /* :authority header */

  771.     if (!glcf->host_set) {
  772.         len += 1 + NGX_HTTP_V2_INT_OCTETS + ctx->host.len;

  774.         if (tmp_len < ctx->host.len) {
  775.             tmp_len = ctx->host.len;
  776.         }
  777.     }

  779.     /* other headers */

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

  784.     le.ip = glcf->headers.lengths->elts;
  785.     le.request = r;
  786.     le.flushed = 1;

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

  790.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  791.         key_len = lcode(&le);

  793.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  794.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  795.         }
  796.         le.ip += sizeof(uintptr_t);

  798.         if (val_len == 0) {
  799.             continue;
  800.         }

  802.         len += 1 + NGX_HTTP_V2_INT_OCTETS + key_len
  803.                  + NGX_HTTP_V2_INT_OCTETS + val_len;

  805.         if (tmp_len < key_len) {
  806.             tmp_len = key_len;
  807.         }

  809.         if (tmp_len < val_len) {
  810.             tmp_len = val_len;
  811.         }
  812.     }

  814.     if (glcf->upstream.pass_request_headers) {
  815.         part = &r->headers_in.headers.part;
  816.         header = part->elts;

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

  820.             if (i >= part->nelts) {
  821.                 if (part->next == NULL) {
  822.                     break;
  823.                 }

  825.                 part = part->next;
  826.                 header = part->elts;
  827.                 i = 0;
  828.             }

  830.             if (ngx_hash_find(&glcf->headers.hash, header[i].hash,
  831.                               header[i].lowcase_key, header[i].key.len))
  832.             {
  833.                 continue;
  834.             }

  836.             len += 1 + NGX_HTTP_V2_INT_OCTETS + header[i].key.len
  837.                      + NGX_HTTP_V2_INT_OCTETS + header[i].value.len;

  839.             if (tmp_len < header[i].key.len) {
  840.                 tmp_len = header[i].key.len;
  841.             }

  843.             if (tmp_len < header[i].value.len) {
  844.                 tmp_len = header[i].value.len;
  845.             }
  846.         }
  847.     }

  849.     /* continuation frames */

  851.     len += sizeof(ngx_http_grpc_frame_t)
  852.            * (len / NGX_HTTP_V2_DEFAULT_FRAME_SIZE);


  855.     b = ngx_create_temp_buf(r->pool, len);
  856.     if (b == NULL) {
  857.         return NGX_ERROR;
  858.     }

  860.     cl = ngx_alloc_chain_link(r->pool);
  861.     if (cl == NULL) {
  862.         return NGX_ERROR;
  863.     }

  865.     cl->buf = b;
  866.     cl->next = NULL;

  868.     tmp = ngx_palloc(r->pool, tmp_len * 3);
  869.     if (tmp == NULL) {
  870.         return NGX_ERROR;
  871.     }

  873.     key_tmp = tmp + tmp_len;
  874.     val_tmp = tmp + 2 * tmp_len;

  876.     /* connection preface */

  878.     b->last = ngx_copy(b->last, ngx_http_grpc_connection_start,
  879.                        sizeof(ngx_http_grpc_connection_start) - 1);

  881.     /* headers frame */

  883.     headers_frame = b->last;

  885.     f = (ngx_http_grpc_frame_t *) b->last;
  886.     b->last += sizeof(ngx_http_grpc_frame_t);

  888.     f->length_0 = 0;
  889.     f->length_1 = 0;
  890.     f->length_2 = 0;
  891.     f->type = NGX_HTTP_V2_HEADERS_FRAME;
  892.     f->flags = 0;
  893.     f->stream_id_0 = 0;
  894.     f->stream_id_1 = 0;
  895.     f->stream_id_2 = 0;
  896.     f->stream_id_3 = 1;

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

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

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

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

  910.     } else {
  911.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_METHOD_INDEX);
  912.         b->last = ngx_http_v2_write_value(b->last, r->method_name.data,
  913.                                           r->method_name.len, tmp);

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

  919. #if (NGX_HTTP_SSL)
  920.     if (u->ssl) {
  921.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTPS_INDEX);

  923.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  924.                        "grpc header: \":scheme: https\"");
  925.     } else
  926. #endif
  927.     {
  928.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTP_INDEX);

  930.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  931.                        "grpc header: \":scheme: http\"");
  932.     }

  934.     if (r->valid_unparsed_uri) {

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

  939.         } else {
  940.             *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  941.             b->last = ngx_http_v2_write_value(b->last, r->unparsed_uri.data,
  942.                                               r->unparsed_uri.len, tmp);
  943.         }

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

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

  951.         if (escape) {
  952.             p = (u_char *) ngx_escape_uri(p, r->uri.data, r->uri.len,
  953.                                           NGX_ESCAPE_URI);

  955.         } else {
  956.             p = ngx_copy(p, r->uri.data, r->uri.len);
  957.         }

  959.         if (r->args.len > 0) {
  960.             *p++ = '?';
  961.             p = ngx_copy(p, r->args.data, r->args.len);
  962.         }

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

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

  970.     } else {
  971.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  972.         b->last = ngx_http_v2_write_value(b->last, r->uri.data,
  973.                                           r->uri.len, tmp);

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

  979.     if (!glcf->host_set) {
  980.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_AUTHORITY_INDEX);
  981.         b->last = ngx_http_v2_write_value(b->last, ctx->host.data,
  982.                                           ctx->host.len, tmp);

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

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

  990.     e.ip = glcf->headers.values->elts;
  991.     e.request = r;
  992.     e.flushed = 1;

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

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

  998.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  999.         key_len = lcode(&le);

  1001.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1002.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1003.         }
  1004.         le.ip += sizeof(uintptr_t);

  1006.         if (val_len == 0) {
  1007.             e.skip = 1;

  1009.             while (*(uintptr_t *) e.ip) {
  1010.                 code = *(ngx_http_script_code_pt *) e.ip;
  1011.                 code((ngx_http_script_engine_t *) &e);
  1012.             }
  1013.             e.ip += sizeof(uintptr_t);

  1015.             e.skip = 0;

  1017.             continue;
  1018.         }

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

  1022.         e.pos = key_tmp;

  1024.         code = *(ngx_http_script_code_pt *) e.ip;
  1025.         code((ngx_http_script_engine_t *) &e);

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

  1029.         e.pos = val_tmp;

  1031.         while (*(uintptr_t *) e.ip) {
  1032.             code = *(ngx_http_script_code_pt *) e.ip;
  1033.             code((ngx_http_script_engine_t *) &e);
  1034.         }
  1035.         e.ip += sizeof(uintptr_t);

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

  1039. #if (NGX_DEBUG)
  1040.         if (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP) {
  1041.             ngx_strlow(key_tmp, key_tmp, key_len);

  1043.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1044.                            "grpc header: \"%*s: %*s\"",
  1045.                            key_len, key_tmp, val_len, val_tmp);
  1046.         }
  1047. #endif
  1048.     }

  1050.     if (glcf->upstream.pass_request_headers) {
  1051.         part = &r->headers_in.headers.part;
  1052.         header = part->elts;

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

  1056.             if (i >= part->nelts) {
  1057.                 if (part->next == NULL) {
  1058.                     break;
  1059.                 }

  1061.                 part = part->next;
  1062.                 header = part->elts;
  1063.                 i = 0;
  1064.             }

  1066.             if (ngx_hash_find(&glcf->headers.hash, header[i].hash,
  1067.                               header[i].lowcase_key, header[i].key.len))
  1068.             {
  1069.                 continue;
  1070.             }

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

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

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

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

  1084.                 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1085.                                "grpc header: \"%*s: %V\"",
  1086.                                header[i].key.len, tmp, &header[i].value);
  1087.             }
  1088. #endif
  1089.         }
  1090.     }

  1092.     /* update headers frame length */

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

  1096.     if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  1097.         len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1098.         next = 1;

  1100.     } else {
  1101.         next = 0;
  1102.     }

  1104.     f = (ngx_http_grpc_frame_t *) headers_frame;

  1106.     f->length_0 = (u_char) ((len >> 16) & 0xff);
  1107.     f->length_1 = (u_char) ((len >> 8) & 0xff);
  1108.     f->length_2 = (u_char) (len & 0xff);

  1110.     /* create additional continuation frames */

  1112.     p = headers_frame;

  1114.     while (next) {
  1115.         p += sizeof(ngx_http_grpc_frame_t) + NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1116.         len = b->last - p;

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

  1121.         if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  1122.             len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1123.             next = 1;

  1125.         } else {
  1126.             next = 0;
  1127.         }

  1129.         f = (ngx_http_grpc_frame_t *) p;

  1131.         f->length_0 = (u_char) ((len >> 16) & 0xff);
  1132.         f->length_1 = (u_char) ((len >> 8) & 0xff);
  1133.         f->length_2 = (u_char) (len & 0xff);
  1134.         f->type = NGX_HTTP_V2_CONTINUATION_FRAME;
  1135.         f->flags = 0;
  1136.         f->stream_id_0 = 0;
  1137.         f->stream_id_1 = 0;
  1138.         f->stream_id_2 = 0;
  1139.         f->stream_id_3 = 1;
  1140.     }

  1142.     f->flags |= NGX_HTTP_V2_END_HEADERS_FLAG;

  1144.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1145.                    "grpc header: %*xs%s, len: %uz",
  1146.                    (size_t) ngx_min(b->last - b->pos, 256), b->pos,
  1147.                    b->last - b->pos > 256 ? "..." : "",
  1148.                    b->last - b->pos);

  1150.     if (r->request_body_no_buffering) {

  1152.         u->request_bufs = cl;

  1154.     } else {

  1156.         body = u->request_bufs;
  1157.         u->request_bufs = cl;

  1159.         if (body == NULL) {
  1160.             f = (ngx_http_grpc_frame_t *) headers_frame;
  1161.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;
  1162.         }

  1164.         while (body) {
  1165.             b = ngx_alloc_buf(r->pool);
  1166.             if (b == NULL) {
  1167.                 return NGX_ERROR;
  1168.             }

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

  1172.             cl->next = ngx_alloc_chain_link(r->pool);
  1173.             if (cl->next == NULL) {
  1174.                 return NGX_ERROR;
  1175.             }

  1177.             cl = cl->next;
  1178.             cl->buf = b;

  1180.             body = body->next;
  1181.         }

  1183.         b->last_buf = 1;
  1184.     }

  1186.     u->output.output_filter = ngx_http_grpc_body_output_filter;
  1187.     u->output.filter_ctx = r;

  1189.     b->flush = 1;
  1190.     cl->next = NULL;

  1192.     return NGX_OK;
  1193. }


  1196. static ngx_int_t
  1197. ‌ngx_http_grpc_reinit_request(ngx_http_request_t *r)
  1198. {
  1199.     ngx_http_grpc_ctx_t  *ctx;

  1201.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

  1203.     if (ctx == NULL) {
  1204.         return NGX_OK;
  1205.     }

  1207.     ctx->state = 0;
  1208.     ctx->header_sent = 0;
  1209.     ctx->output_closed = 0;
  1210.     ctx->output_blocked = 0;
  1211.     ctx->parsing_headers = 0;
  1212.     ctx->end_stream = 0;
  1213.     ctx->done = 0;
  1214.     ctx->status = 0;
  1215.     ctx->rst = 0;
  1216.     ctx->goaway = 0;
  1217.     ctx->connection = NULL;

  1219.     return NGX_OK;
  1220. }


  1223. static ngx_int_t
  1224. ‌ngx_http_grpc_body_output_filter(void *data, ngx_chain_t *in)
  1225. {
  1226.     ngx_http_request_t  *r = data;

  1228.     off_t                   file_pos;
  1229.     u_char                 *p, *pos, *start;
  1230.     size_t                  len, limit;
  1231.     ngx_buf_t              *b;
  1232.     ngx_int_t               rc;
  1233.     ngx_uint_t              next, last;
  1234.     ngx_chain_t            *cl, *out, *ln, **ll;
  1235.     ngx_http_upstream_t    *u;
  1236.     ngx_http_grpc_ctx_t    *ctx;
  1237.     ngx_http_grpc_frame_t  *f;

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

  1242.     ctx = ngx_http_grpc_get_ctx(r);

  1244.     if (ctx == NULL) {
  1245.         return NGX_ERROR;
  1246.     }

  1248.     if (in) {
  1249.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  1250.             return NGX_ERROR;
  1251.         }
  1252.     }

  1254.     out = NULL;
  1255.     ll = &out;

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

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

  1263.         ctx->header_sent = 1;

  1265.         if (ctx->id != 1) {
  1266.             /*
  1267.              * keepalive connection: skip connection preface,
  1268.              * update stream identifiers
  1269.              */

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

  1274.             p = b->pos;

  1276.             while (p < b->last) {
  1277.                 f = (ngx_http_grpc_frame_t *) p;
  1278.                 p += sizeof(ngx_http_grpc_frame_t);

  1280.                 f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1281.                 f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1282.                 f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1283.                 f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1285.                 p += (f->length_0 << 16) + (f->length_1 << 8) + f->length_2;
  1286.             }
  1287.         }

  1289.         if (ctx->in->buf->last_buf) {
  1290.             ctx->output_closed = 1;
  1291.         }

  1293.         *ll = ctx->in;
  1294.         ll = &ctx->in->next;

  1296.         ctx->in = ctx->in->next;
  1297.     }

  1299.     if (ctx->out) {
  1300.         /* queued control frames */

  1302.         *ll = ctx->out;

  1304.         for (cl = ctx->out, ll = &cl->next; cl; cl = cl->next) {
  1305.             ll = &cl->next;
  1306.         }

  1308.         ctx->out = NULL;
  1309.     }

  1311.     f = NULL;
  1312.     last = 0;

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

  1316.     if (limit > ctx->connection->send_window) {
  1317.         limit = ctx->connection->send_window;
  1318.     }

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

  1324. #if (NGX_SUPPRESS_WARN)
  1325.     file_pos = 0;
  1326.     pos = NULL;
  1327.     cl = NULL;
  1328. #endif

  1330.     in = ctx->in;

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

  1334.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1335.                        "grpc output in  l:%d f:%d %p, pos %p, size: %z "
  1336.                        "file: %O, size: %O",
  1337.                        in->buf->last_buf,
  1338.                        in->buf->in_file,
  1339.                        in->buf->start, in->buf->pos,
  1340.                        in->buf->last - in->buf->pos,
  1341.                        in->buf->file_pos,
  1342.                        in->buf->file_last - in->buf->file_pos);

  1344.         if (ngx_buf_special(in->buf)) {
  1345.             goto next;
  1346.         }

  1348.         if (in->buf->in_file) {
  1349.             file_pos = in->buf->file_pos;

  1351.         } else {
  1352.             pos = in->buf->pos;
  1353.         }

  1355.         next = 0;

  1357.         do {

  1359.             cl = ngx_http_grpc_get_buf(r, ctx);
  1360.             if (cl == NULL) {
  1361.                 return NGX_ERROR;
  1362.             }

  1364.             b = cl->buf;

  1366.             f = (ngx_http_grpc_frame_t *) b->last;
  1367.             b->last += sizeof(ngx_http_grpc_frame_t);

  1369.             *ll = cl;
  1370.             ll = &cl->next;

  1372.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  1373.             if (cl == NULL) {
  1374.                 return NGX_ERROR;
  1375.             }

  1377.             b = cl->buf;
  1378.             start = b->start;

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

  1382.             /*
  1383.              * restore b->start to preserve memory allocated in the buffer,
  1384.              * to reuse it later for headers and control frames
  1385.              */

  1387.             b->start = start;

  1389.             if (in->buf->in_file) {
  1390.                 b->file_pos = file_pos;
  1391.                 file_pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1393.                 if (file_pos >= in->buf->file_last) {
  1394.                     file_pos = in->buf->file_last;
  1395.                     next = 1;
  1396.                 }

  1398.                 b->file_last = file_pos;
  1399.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1401.             } else {
  1402.                 b->pos = pos;
  1403.                 pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1405.                 if (pos >= in->buf->last) {
  1406.                     pos = in->buf->last;
  1407.                     next = 1;
  1408.                 }

  1410.                 b->last = pos;
  1411.                 len = (ngx_uint_t) (pos - b->pos);
  1412.             }

  1414.             b->tag = (ngx_buf_tag_t) &ngx_http_grpc_body_output_filter;
  1415.             b->shadow = in->buf;
  1416.             b->last_shadow = next;

  1418.             b->last_buf = 0;
  1419.             b->last_in_chain = 0;

  1421.             *ll = cl;
  1422.             ll = &cl->next;

  1424.             f->length_0 = (u_char) ((len >> 16) & 0xff);
  1425.             f->length_1 = (u_char) ((len >> 8) & 0xff);
  1426.             f->length_2 = (u_char) (len & 0xff);
  1427.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1428.             f->flags = 0;
  1429.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1430.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1431.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1432.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1434.             limit -= len;
  1435.             ctx->send_window -= len;
  1436.             ctx->connection->send_window -= len;

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

  1440.         if (!next) {
  1441.             /*
  1442.              * if the buffer wasn't fully sent due to flow control limits,
  1443.              * preserve position for future use
  1444.              */

  1446.             if (in->buf->in_file) {
  1447.                 in->buf->file_pos = file_pos;

  1449.             } else {
  1450.                 in->buf->pos = pos;
  1451.             }

  1453.             break;
  1454.         }

  1456.     next:

  1458.         if (in->buf->last_buf) {
  1459.             last = 1;
  1460.         }

  1462.         ln = in;
  1463.         in = in->next;

  1465.         ngx_free_chain(r->pool, ln);
  1466.     }

  1468.     ctx->in = in;

  1470.     if (last) {

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

  1475.         ctx->output_closed = 1;

  1477.         if (f) {
  1478.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1480.         } else {
  1481.             cl = ngx_http_grpc_get_buf(r, ctx);
  1482.             if (cl == NULL) {
  1483.                 return NGX_ERROR;
  1484.             }

  1486.             b = cl->buf;

  1488.             f = (ngx_http_grpc_frame_t *) b->last;
  1489.             b->last += sizeof(ngx_http_grpc_frame_t);

  1491.             f->length_0 = 0;
  1492.             f->length_1 = 0;
  1493.             f->length_2 = 0;
  1494.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1495.             f->flags = NGX_HTTP_V2_END_STREAM_FLAG;
  1496.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1497.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1498.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1499.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1501.             *ll = cl;
  1502.             ll = &cl->next;
  1503.         }

  1505.         cl->buf->last_buf = 1;
  1506.     }

  1508.     *ll = NULL;

  1510. #if (NGX_DEBUG)

  1512.     for (cl = out; cl; cl = cl->next) {
  1513.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1514.                        "grpc output out l:%d f:%d %p, pos %p, size: %z "
  1515.                        "file: %O, size: %O",
  1516.                        cl->buf->last_buf,
  1517.                        cl->buf->in_file,
  1518.                        cl->buf->start, cl->buf->pos,
  1519.                        cl->buf->last - cl->buf->pos,
  1520.                        cl->buf->file_pos,
  1521.                        cl->buf->file_last - cl->buf->file_pos);
  1522.     }

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

  1528. #endif

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

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

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

  1537.         /* mark original buffers as sent */

  1539.         if (cl->buf->shadow) {
  1540.             if (cl->buf->last_shadow) {
  1541.                 b = cl->buf->shadow;
  1542.                 b->pos = b->last;
  1543.             }

  1545.             cl->buf->shadow = NULL;
  1546.         }
  1547.     }

  1549.     if (rc == NGX_OK && ctx->in) {
  1550.         rc = NGX_AGAIN;
  1551.     }

  1553.     if (rc == NGX_AGAIN) {
  1554.         ctx->output_blocked = 1;

  1556.     } else {
  1557.         ctx->output_blocked = 0;
  1558.     }

  1560.     if (ctx->done) {

  1562.         /*
  1563.          * We have already got the response and were sending some additional
  1564.          * control frames.  Even if there is still something unsent, stop
  1565.          * here anyway.
  1566.          */

  1568.         u = r->upstream;
  1569.         u->length = 0;

  1571.         if (ctx->in == NULL
  1572.             && ctx->out == NULL
  1573.             && ctx->output_closed
  1574.             && !ctx->output_blocked
  1575.             && !ctx->goaway
  1576.             && ctx->state == ngx_http_grpc_st_start)
  1577.         {
  1578.             u->keepalive = 1;
  1579.         }

  1581.         ngx_post_event(u->peer.connection->read, &ngx_posted_events);
  1582.     }

  1584.     return rc;
  1585. }


  1588. static ngx_int_t
  1589. ‌ngx_http_grpc_process_header(ngx_http_request_t *r)
  1590. {
  1591.     ngx_str_t                      *status_line;
  1592.     ngx_int_t                       rc, status;
  1593.     ngx_buf_t                      *b;
  1594.     ngx_table_elt_t                *h;
  1595.     ngx_http_upstream_t            *u;
  1596.     ngx_http_grpc_ctx_t            *ctx;
  1597.     ngx_http_upstream_header_t     *hh;
  1598.     ngx_http_upstream_main_conf_t  *umcf;

  1600.     u = r->upstream;
  1601.     b = &u->buffer;

  1603.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1604.                    "grpc response: %*xs%s, len: %uz",
  1605.                    (size_t) ngx_min(b->last - b->pos, 256),
  1606.                    b->pos, b->last - b->pos > 256 ? "..." : "",
  1607.                    b->last - b->pos);

  1609.     ctx = ngx_http_grpc_get_ctx(r);

  1611.     if (ctx == NULL) {
  1612.         return NGX_ERROR;
  1613.     }

  1615.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1617.     for ( ;; ) {

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

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

  1623.             if (rc == NGX_AGAIN) {

  1625.                 /*
  1626.                  * there can be a lot of window update frames,
  1627.                  * so we reset buffer if it is empty and we haven't
  1628.                  * started parsing headers yet
  1629.                  */

  1631.                 if (!ctx->parsing_headers) {
  1632.                     b->pos = b->start;
  1633.                     b->last = b->pos;
  1634.                 }

  1636.                 return NGX_AGAIN;
  1637.             }

  1639.             if (rc == NGX_ERROR) {
  1640.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1641.             }

  1643.             /*
  1644.              * RFC 7540 says that implementations MUST discard frames
  1645.              * that have unknown or unsupported types.  However, extension
  1646.              * frames that appear in the middle of a header block are
  1647.              * not permitted.  Also, for obvious reasons CONTINUATION frames
  1648.              * cannot appear before headers, and DATA frames are not expected
  1649.              * to appear before all headers are parsed.
  1650.              */

  1652.             if (ctx->type == NGX_HTTP_V2_DATA_FRAME
  1653.                 || (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  1654.                     && !ctx->parsing_headers)
  1655.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  1656.                     && ctx->parsing_headers))
  1657.             {
  1658.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1659.                               "upstream sent unexpected http2 frame: %d",
  1660.                               ctx->type);
  1661.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1662.             }

  1664.             if (ctx->stream_id && ctx->stream_id != ctx->id) {
  1665.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1666.                               "upstream sent frame for unknown stream %ui",
  1667.                               ctx->stream_id);
  1668.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1669.             }
  1670.         }

  1672.         /* frame payload */

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

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

  1678.             if (rc == NGX_AGAIN) {
  1679.                 return NGX_AGAIN;
  1680.             }

  1682.             if (rc == NGX_ERROR) {
  1683.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1684.             }

  1686.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1687.                           "upstream rejected request with error %ui",
  1688.                           ctx->error);

  1690.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1691.         }

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

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

  1697.             if (rc == NGX_AGAIN) {
  1698.                 return NGX_AGAIN;
  1699.             }

  1701.             if (rc == NGX_ERROR) {
  1702.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1703.             }

  1705.             /*
  1706.              * If stream_id is lower than one we use, our
  1707.              * request won't be processed and needs to be retried.
  1708.              * If stream_id is greater or equal to the one we use,
  1709.              * we can continue normally (except we can't use this
  1710.              * connection for additional requests).  If there is
  1711.              * a real error, the connection will be closed.
  1712.              */

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

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

  1718.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1719.                               "upstream sent goaway with error %ui",
  1720.                               ctx->error);

  1722.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1723.             }

  1725.             ctx->goaway = 1;

  1727.             continue;
  1728.         }

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

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

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

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

  1742.             if (ctx->in) {
  1743.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1744.             }

  1746.             continue;
  1747.         }

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

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

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

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

  1761.             if (ctx->in) {
  1762.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1763.             }

  1765.             continue;
  1766.         }

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

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

  1772.             if (rc == NGX_AGAIN) {
  1773.                 return NGX_AGAIN;
  1774.             }

  1776.             if (rc == NGX_ERROR) {
  1777.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1778.             }

  1780.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1781.             continue;
  1782.         }

  1784.         if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  1785.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1786.                           "upstream sent unexpected push promise frame");
  1787.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1788.         }

  1790.         if (ctx->type != NGX_HTTP_V2_HEADERS_FRAME
  1791.             && ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME)
  1792.         {
  1793.             /* priority, unknown frames */

  1795.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  1796.                 ctx->rest -= b->last - b->pos;
  1797.                 b->pos = b->last;
  1798.                 return NGX_AGAIN;
  1799.             }

  1801.             b->pos += ctx->rest;
  1802.             ctx->rest = 0;
  1803.             ctx->state = ngx_http_grpc_st_start;

  1805.             continue;
  1806.         }

  1808.         /* headers */

  1810.         for ( ;; ) {

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

  1814.             if (rc == NGX_AGAIN) {
  1815.                 break;
  1816.             }

  1818.             if (rc == NGX_OK) {

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

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

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

  1828.                     if (ctx->name.len != sizeof(":status") - 1
  1829.                         || ngx_strncmp(ctx->name.data, ":status",
  1830.                                        sizeof(":status") - 1)
  1831.                            != 0)
  1832.                     {
  1833.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1834.                                       "upstream sent invalid header \"%V: %V\"",
  1835.                                       &ctx->name, &ctx->value);
  1836.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1837.                     }

  1839.                     if (ctx->status) {
  1840.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1841.                                       "upstream sent duplicate :status header");
  1842.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1843.                     }

  1845.                     status_line = &ctx->value;

  1847.                     if (status_line->len != 3) {
  1848.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1849.                                       "upstream sent invalid :status \"%V\"",
  1850.                                       status_line);
  1851.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1852.                     }

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

  1856.                     if (status == NGX_ERROR) {
  1857.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1858.                                       "upstream sent invalid :status \"%V\"",
  1859.                                       status_line);
  1860.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1861.                     }

  1863.                     if (status < NGX_HTTP_OK) {
  1864.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1865.                                       "upstream sent unexpected :status \"%V\"",
  1866.                                       status_line);
  1867.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1868.                     }

  1870.                     u->headers_in.status_n = status;

  1872.                     if (u->state && u->state->status == 0) {
  1873.                         u->state->status = status;
  1874.                     }

  1876.                     ctx->status = 1;

  1878.                     continue;

  1880.                 } else if (!ctx->status) {
  1881.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1882.                                   "upstream sent no :status header");
  1883.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1884.                 }

  1886.                 h = ngx_list_push(&u->headers_in.headers);
  1887.                 if (h == NULL) {
  1888.                     return NGX_ERROR;
  1889.                 }

  1891.                 h->key = ctx->name;
  1892.                 h->value = ctx->value;
  1893.                 h->lowcase_key = h->key.data;
  1894.                 h->hash = ngx_hash_key(h->key.data, h->key.len);

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

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

  1902.                     if (rc != NGX_OK) {
  1903.                         return rc;
  1904.                     }
  1905.                 }

  1907.                 continue;
  1908.             }

  1910.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1917.                 if (ctx->end_stream) {
  1918.                     u->headers_in.content_length_n = 0;

  1920.                     if (ctx->in == NULL
  1921.                         && ctx->out == NULL
  1922.                         && ctx->output_closed
  1923.                         && !ctx->output_blocked
  1924.                         && !ctx->goaway
  1925.                         && b->last == b->pos)
  1926.                     {
  1927.                         u->keepalive = 1;
  1928.                     }
  1929.                 }

  1931.                 return NGX_OK;
  1932.             }

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

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

  1939.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1940.         }

  1942.         /* rc == NGX_AGAIN */

  1944.         if (ctx->rest == 0) {
  1945.             ctx->state = ngx_http_grpc_st_start;
  1946.             continue;
  1947.         }

  1949.         return NGX_AGAIN;
  1950.     }
  1951. }


  1954. static ngx_int_t
  1955. ‌ngx_http_grpc_filter_init(void *data)
  1956. {
  1957.     ngx_http_grpc_ctx_t  *ctx = data;

  1959.     ngx_http_request_t   *r;
  1960.     ngx_http_upstream_t  *u;

  1962.     r = ctx->request;
  1963.     u = r->upstream;

  1965.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1966.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED
  1967.         || r->method == NGX_HTTP_HEAD)
  1968.     {
  1969.         ctx->length = 0;

  1971.     } else {
  1972.         ctx->length = u->headers_in.content_length_n;
  1973.     }

  1975.     if (ctx->end_stream) {

  1977.         if (ctx->length > 0) {
  1978.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1979.                           "upstream prematurely closed stream");
  1980.             return NGX_ERROR;
  1981.         }

  1983.         u->length = 0;
  1984.         ctx->done = 1;

  1986.     } else {
  1987.         u->length = 1;
  1988.     }

  1990.     return NGX_OK;
  1991. }


  1994. static ngx_int_t
  1995. ‌ngx_http_grpc_filter(void *data, ssize_t bytes)
  1996. {
  1997.     ngx_http_grpc_ctx_t  *ctx = data;

  1999.     ngx_int_t             rc;
  2000.     ngx_buf_t            *b, *buf;
  2001.     ngx_chain_t          *cl, **ll;
  2002.     ngx_table_elt_t      *h;
  2003.     ngx_http_request_t   *r;
  2004.     ngx_http_upstream_t  *u;

  2006.     r = ctx->request;
  2007.     u = r->upstream;
  2008.     b = &u->buffer;

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

  2013.     b->pos = b->last;
  2014.     b->last += bytes;

  2016.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  2017.         ll = &cl->next;
  2018.     }

  2020.     for ( ;; ) {

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

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

  2026.             if (rc == NGX_AGAIN) {

  2028.                 if (ctx->done) {

  2030.                     if (ctx->length > 0) {
  2031.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2032.                                       "upstream prematurely closed stream");
  2033.                         return NGX_ERROR;
  2034.                     }

  2036.                     /*
  2037.                      * We have finished parsing the response and the
  2038.                      * remaining control frames.  If there are unsent
  2039.                      * control frames, post a write event to send them.
  2040.                      */

  2042.                     if (ctx->out) {
  2043.                         ngx_post_event(u->peer.connection->write,
  2044.                                        &ngx_posted_events);
  2045.                         return NGX_AGAIN;
  2046.                     }

  2048.                     u->length = 0;

  2050.                     if (ctx->in == NULL
  2051.                         && ctx->output_closed
  2052.                         && !ctx->output_blocked
  2053.                         && !ctx->goaway
  2054.                         && ctx->state == ngx_http_grpc_st_start)
  2055.                     {
  2056.                         u->keepalive = 1;
  2057.                     }

  2059.                     break;
  2060.                 }

  2062.                 return NGX_AGAIN;
  2063.             }

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

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

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

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

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

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

  2106.                 ctx->recv_window -= ctx->rest;
  2107.                 ctx->connection->recv_window -= ctx->rest;

  2109.                 if (ctx->connection->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4
  2110.                     || ctx->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4)
  2111.                 {
  2112.                     if (ngx_http_grpc_send_window_update(r, ctx) != NGX_OK) {
  2113.                         return NGX_ERROR;
  2114.                     }

  2116.                     ngx_post_event(u->peer.connection->write,
  2117.                                    &ngx_posted_events);
  2118.                 }
  2119.             }

  2121.             if (ctx->stream_id && ctx->stream_id != ctx->id) {
  2122.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2123.                               "upstream sent frame for unknown stream %ui",
  2124.                               ctx->stream_id);
  2125.                 return NGX_ERROR;
  2126.             }

  2128.             if (ctx->stream_id && ctx->done
  2129.                 && ctx->type != NGX_HTTP_V2_RST_STREAM_FRAME
  2130.                 && ctx->type != NGX_HTTP_V2_WINDOW_UPDATE_FRAME)
  2131.             {
  2132.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2133.                               "upstream sent frame for closed stream %ui",
  2134.                               ctx->stream_id);
  2135.                 return NGX_ERROR;
  2136.             }

  2138.             ctx->padding = 0;
  2139.         }

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

  2143.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2144.                 ctx->rest -= b->last - b->pos;
  2145.                 b->pos = b->last;
  2146.                 return NGX_AGAIN;
  2147.             }

  2149.             b->pos += ctx->rest;
  2150.             ctx->rest = 0;
  2151.             ctx->state = ngx_http_grpc_st_start;

  2153.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2154.                 ctx->done = 1;
  2155.             }

  2157.             continue;
  2158.         }

  2160.         /* frame payload */

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

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

  2166.             if (rc == NGX_AGAIN) {
  2167.                 return NGX_AGAIN;
  2168.             }

  2170.             if (rc == NGX_ERROR) {
  2171.                 return NGX_ERROR;
  2172.             }

  2174.             if (ctx->error || !ctx->done) {
  2175.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2176.                               "upstream rejected request with error %ui",
  2177.                               ctx->error);
  2178.                 return NGX_ERROR;
  2179.             }

  2181.             if (ctx->rst) {
  2182.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2183.                               "upstream sent frame for closed stream %ui",
  2184.                               ctx->stream_id);
  2185.                 return NGX_ERROR;
  2186.             }

  2188.             ctx->rst = 1;

  2190.             continue;
  2191.         }

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

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

  2197.             if (rc == NGX_AGAIN) {
  2198.                 return NGX_AGAIN;
  2199.             }

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

  2205.             /*
  2206.              * If stream_id is lower than one we use, our
  2207.              * request won't be processed and needs to be retried.
  2208.              * If stream_id is greater or equal to the one we use,
  2209.              * we can continue normally (except we can't use this
  2210.              * connection for additional requests).  If there is
  2211.              * a real error, the connection will be closed.
  2212.              */

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

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

  2218.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2219.                               "upstream sent goaway with error %ui",
  2220.                               ctx->error);

  2222.                 return NGX_ERROR;
  2223.             }

  2225.             ctx->goaway = 1;

  2227.             continue;
  2228.         }

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

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

  2234.             if (rc == NGX_AGAIN) {
  2235.                 return NGX_AGAIN;
  2236.             }

  2238.             if (rc == NGX_ERROR) {
  2239.                 return NGX_ERROR;
  2240.             }

  2242.             if (ctx->in) {
  2243.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2244.             }

  2246.             continue;
  2247.         }

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

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

  2253.             if (rc == NGX_AGAIN) {
  2254.                 return NGX_AGAIN;
  2255.             }

  2257.             if (rc == NGX_ERROR) {
  2258.                 return NGX_ERROR;
  2259.             }

  2261.             if (ctx->in) {
  2262.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2263.             }

  2265.             continue;
  2266.         }

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

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

  2272.             if (rc == NGX_AGAIN) {
  2273.                 return NGX_AGAIN;
  2274.             }

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

  2280.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2281.             continue;
  2282.         }

  2284.         if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  2285.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2286.                           "upstream sent unexpected push promise frame");
  2287.             return NGX_ERROR;
  2288.         }

  2290.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME
  2291.             || ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME)
  2292.         {
  2293.             for ( ;; ) {

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

  2297.                 if (rc == NGX_AGAIN) {
  2298.                     break;
  2299.                 }

  2301.                 if (rc == NGX_OK) {

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

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

  2309.                     if (ctx->name.len && ctx->name.data[0] == ':') {
  2310.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2311.                                       "upstream sent invalid "
  2312.                                       "trailer \"%V: %V\"",
  2313.                                       &ctx->name, &ctx->value);
  2314.                         return NGX_ERROR;
  2315.                     }

  2317.                     h = ngx_list_push(&u->headers_in.trailers);
  2318.                     if (h == NULL) {
  2319.                         return NGX_ERROR;
  2320.                     }

  2322.                     h->key = ctx->name;
  2323.                     h->value = ctx->value;
  2324.                     h->lowcase_key = h->key.data;
  2325.                     h->hash = ngx_hash_key(h->key.data, h->key.len);

  2327.                     continue;
  2328.                 }

  2330.                 if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2337.                     if (ctx->end_stream) {
  2338.                         ctx->done = 1;
  2339.                         break;
  2340.                     }

  2342.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2343.                                   "upstream sent trailer without "
  2344.                                   "end stream flag");
  2345.                     return NGX_ERROR;
  2346.                 }

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

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

  2353.                 return NGX_ERROR;
  2354.             }

  2356.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2357.                 continue;
  2358.             }

  2360.             /* rc == NGX_AGAIN */

  2362.             if (ctx->rest == 0) {
  2363.                 ctx->state = ngx_http_grpc_st_start;
  2364.                 continue;
  2365.             }

  2367.             return NGX_AGAIN;
  2368.         }

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

  2372.             /* priority, unknown frames */

  2374.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2375.                 ctx->rest -= b->last - b->pos;
  2376.                 b->pos = b->last;
  2377.                 return NGX_AGAIN;
  2378.             }

  2380.             b->pos += ctx->rest;
  2381.             ctx->rest = 0;
  2382.             ctx->state = ngx_http_grpc_st_start;

  2384.             continue;
  2385.         }

  2387.         /*
  2388.          * data frame:
  2389.          *
  2390.          * +---------------+
  2391.          * |Pad Length? (8)|
  2392.          * +---------------+-----------------------------------------------+
  2393.          * |                            Data (*)                         ...
  2394.          * +---------------------------------------------------------------+
  2395.          * |                           Padding (*)                       ...
  2396.          * +---------------------------------------------------------------+
  2397.          */

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

  2401.             if (ctx->rest == 0) {
  2402.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2403.                               "upstream sent too short http2 frame");
  2404.                 return NGX_ERROR;
  2405.             }

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

  2411.             ctx->flags &= ~NGX_HTTP_V2_PADDED_FLAG;
  2412.             ctx->padding = *b->pos++;
  2413.             ctx->rest -= 1;

  2415.             if (ctx->padding > ctx->rest) {
  2416.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2417.                               "upstream sent http2 frame with too long "
  2418.                               "padding: %d in frame %uz",
  2419.                               ctx->padding, ctx->rest);
  2420.                 return NGX_ERROR;
  2421.             }

  2423.             continue;
  2424.         }

  2426.         if (ctx->rest == ctx->padding) {
  2427.             goto done;
  2428.         }

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

  2434.         cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  2435.         if (cl == NULL) {
  2436.             return NGX_ERROR;
  2437.         }

  2439.         *ll = cl;
  2440.         ll = &cl->next;

  2442.         buf = cl->buf;

  2444.         buf->flush = 1;
  2445.         buf->memory = 1;

  2447.         buf->pos = b->pos;
  2448.         buf->tag = u->output.tag;

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

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

  2455.             ctx->rest -= b->last - b->pos;
  2456.             b->pos = b->last;
  2457.             buf->last = b->pos;

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

  2461.                 if (buf->last - buf->pos > ctx->length) {
  2462.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2463.                                   "upstream sent response body larger "
  2464.                                   "than indicated content length");
  2465.                     return NGX_ERROR;
  2466.                 }

  2468.                 ctx->length -= buf->last - buf->pos;
  2469.             }

  2471.             return NGX_AGAIN;
  2472.         }

  2474.         b->pos += ctx->rest - ctx->padding;
  2475.         buf->last = b->pos;
  2476.         ctx->rest = ctx->padding;

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

  2480.             if (buf->last - buf->pos > ctx->length) {
  2481.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2482.                               "upstream sent response body larger "
  2483.                               "than indicated content length");
  2484.                 return NGX_ERROR;
  2485.             }

  2487.             ctx->length -= buf->last - buf->pos;
  2488.         }

  2490.     done:

  2492.         if (ctx->padding) {
  2493.             ctx->state = ngx_http_grpc_st_padding;
  2494.             continue;
  2495.         }

  2497.         ctx->state = ngx_http_grpc_st_start;

  2499.         if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2500.             ctx->done = 1;
  2501.         }
  2502.     }

  2504.     return NGX_OK;
  2505. }


  2508. static ngx_int_t
  2509. ‌ngx_http_grpc_parse_frame(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2510.     ngx_buf_t *b)
  2511. {
  2512.     u_char                 ch, *p;
  2513.     ngx_http_grpc_state_e  state;

  2515.     state = ctx->state;

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

  2520. #if 0
  2521.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2522.                        "grpc frame byte: %02Xd, s:%d", ch, state);
  2523. #endif

  2525.         switch (state) {

  2527.         case ngx_http_grpc_st_start:
  2528.             ctx->rest = ch << 16;
  2529.             state = ngx_http_grpc_st_length_2;
  2530.             break;

  2532.         case ngx_http_grpc_st_length_2:
  2533.             ctx->rest |= ch << 8;
  2534.             state = ngx_http_grpc_st_length_3;
  2535.             break;

  2537.         case ngx_http_grpc_st_length_3:
  2538.             ctx->rest |= ch;

  2540.             if (ctx->rest > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  2541.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2542.                               "upstream sent too large http2 frame: %uz",
  2543.                               ctx->rest);
  2544.                 return NGX_ERROR;
  2545.             }

  2547.             state = ngx_http_grpc_st_type;
  2548.             break;

  2550.         case ngx_http_grpc_st_type:
  2551.             ctx->type = ch;
  2552.             state = ngx_http_grpc_st_flags;
  2553.             break;

  2555.         case ngx_http_grpc_st_flags:
  2556.             ctx->flags = ch;
  2557.             state = ngx_http_grpc_st_stream_id;
  2558.             break;

  2560.         case ngx_http_grpc_st_stream_id:
  2561.             ctx->stream_id = (ch & 0x7f) << 24;
  2562.             state = ngx_http_grpc_st_stream_id_2;
  2563.             break;

  2565.         case ngx_http_grpc_st_stream_id_2:
  2566.             ctx->stream_id |= ch << 16;
  2567.             state = ngx_http_grpc_st_stream_id_3;
  2568.             break;

  2570.         case ngx_http_grpc_st_stream_id_3:
  2571.             ctx->stream_id |= ch << 8;
  2572.             state = ngx_http_grpc_st_stream_id_4;
  2573.             break;

  2575.         case ngx_http_grpc_st_stream_id_4:
  2576.             ctx->stream_id |= ch;

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

  2582.             b->pos = p + 1;

  2584.             ctx->state = ngx_http_grpc_st_payload;
  2585.             ctx->frame_state = 0;

  2587.             return NGX_OK;

  2589.         /* suppress warning */
  2590.         case ngx_http_grpc_st_payload:
  2591.         case ngx_http_grpc_st_padding:
  2592.             break;
  2593.         }
  2594.     }

  2596.     b->pos = p;
  2597.     ctx->state = state;

  2599.     return NGX_AGAIN;
  2600. }


  2603. static ngx_int_t
  2604. ‌ngx_http_grpc_parse_header(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2605.     ngx_buf_t *b)
  2606. {
  2607.     u_char     ch, *p, *last;
  2608.     size_t     min;
  2609.     ngx_int_t  rc;
  2610. ‌    enum {
  2611.         sw_start = 0,
  2612.         sw_padding_length,
  2613.         sw_dependency,
  2614.         sw_dependency_2,
  2615.         sw_dependency_3,
  2616.         sw_dependency_4,
  2617.         sw_weight,
  2618.         sw_fragment,
  2619.         sw_padding
  2620.     } state;

  2622.     state = ctx->frame_state;

  2624.     if (state == sw_start) {

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

  2629.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME) {
  2630.             ctx->parsing_headers = 1;
  2631.             ctx->fragment_state = 0;

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

  2636.             if (ctx->rest < min) {
  2637.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2638.                               "upstream sent headers frame "
  2639.                               "with invalid length: %uz",
  2640.                               ctx->rest);
  2641.                 return NGX_ERROR;
  2642.             }

  2644.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2645.                 ctx->end_stream = 1;
  2646.             }

  2648.             if (ctx->flags & NGX_HTTP_V2_PADDED_FLAG) {
  2649.                 state = sw_padding_length;

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

  2654.             } else {
  2655.                 state = sw_fragment;
  2656.             }

  2658.         } else if (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME) {
  2659.             state = sw_fragment;
  2660.         }

  2662.         ctx->padding = 0;
  2663.         ctx->frame_state = state;
  2664.     }

  2666.     if (state < sw_fragment) {

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

  2671.         } else {
  2672.             last = b->pos + ctx->rest;
  2673.         }

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

  2678. #if 0
  2679.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2680.                            "grpc header byte: %02Xd s:%d", ch, state);
  2681. #endif

  2683.             /*
  2684.              * headers frame:
  2685.              *
  2686.              * +---------------+
  2687.              * |Pad Length? (8)|
  2688.              * +-+-------------+----------------------------------------------+
  2689.              * |E|                 Stream Dependency? (31)                    |
  2690.              * +-+-------------+----------------------------------------------+
  2691.              * |  Weight? (8)  |
  2692.              * +-+-------------+----------------------------------------------+
  2693.              * |                   Header Block Fragment (*)                ...
  2694.              * +--------------------------------------------------------------+
  2695.              * |                           Padding (*)                      ...
  2696.              * +--------------------------------------------------------------+
  2697.              */

  2699.             switch (state) {

  2701.             case sw_padding_length:

  2703.                 ctx->padding = ch;

  2705.                 if (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG) {
  2706.                     state = sw_dependency;
  2707.                     break;
  2708.                 }

  2710.                 goto fragment;

  2712.             case sw_dependency:
  2713.                 state = sw_dependency_2;
  2714.                 break;

  2716.             case sw_dependency_2:
  2717.                 state = sw_dependency_3;
  2718.                 break;

  2720.             case sw_dependency_3:
  2721.                 state = sw_dependency_4;
  2722.                 break;

  2724.             case sw_dependency_4:
  2725.                 state = sw_weight;
  2726.                 break;

  2728.             case sw_weight:
  2729.                 goto fragment;

  2731.             /* suppress warning */
  2732.             case sw_start:
  2733.             case sw_fragment:
  2734.             case sw_padding:
  2735.                 break;
  2736.             }
  2737.         }

  2739.         ctx->rest -= p - b->pos;
  2740.         b->pos = p;

  2742.         ctx->frame_state = state;
  2743.         return NGX_AGAIN;

  2745.     fragment:

  2747.         p++;
  2748.         ctx->rest -= p - b->pos;
  2749.         b->pos = p;

  2751.         if (ctx->padding > ctx->rest) {
  2752.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2753.                           "upstream sent http2 frame with too long "
  2754.                           "padding: %d in frame %uz",
  2755.                           ctx->padding, ctx->rest);
  2756.             return NGX_ERROR;
  2757.         }

  2759.         state = sw_fragment;
  2760.         ctx->frame_state = state;
  2761.     }

  2763.     if (state == sw_fragment) {

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

  2767.         if (rc == NGX_AGAIN) {
  2768.             return NGX_AGAIN;
  2769.         }

  2771.         if (rc == NGX_ERROR) {
  2772.             return NGX_ERROR;
  2773.         }

  2775.         if (rc == NGX_OK) {
  2776.             return NGX_OK;
  2777.         }

  2779.         /* rc == NGX_DONE */

  2781.         state = sw_padding;
  2782.         ctx->frame_state = state;
  2783.     }

  2785.     if (state == sw_padding) {

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

  2789.             ctx->rest -= b->last - b->pos;
  2790.             b->pos = b->last;

  2792.             return NGX_AGAIN;
  2793.         }

  2795.         b->pos += ctx->rest;
  2796.         ctx->rest = 0;

  2798.         ctx->state = ngx_http_grpc_st_start;

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

  2802.             if (ctx->fragment_state) {
  2803.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2804.                               "upstream sent truncated http2 header");
  2805.                 return NGX_ERROR;
  2806.             }

  2808.             ctx->parsing_headers = 0;

  2810.             return NGX_HTTP_PARSE_HEADER_DONE;
  2811.         }

  2813.         return NGX_AGAIN;
  2814.     }

  2816.     /* unreachable */

  2818.     return NGX_ERROR;
  2819. }


  2822. static ngx_int_t
  2823. ‌ngx_http_grpc_parse_fragment(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2824.     ngx_buf_t *b)
  2825. {
  2826.     u_char      ch, *p, *last;
  2827.     size_t      size;
  2828.     ngx_uint_t  index, size_update;
  2829. ‌    enum {
  2830.         sw_start = 0,
  2831.         sw_index,
  2832.         sw_name_length,
  2833.         sw_name_length_2,
  2834.         sw_name_length_3,
  2835.         sw_name_length_4,
  2836.         sw_name,
  2837.         sw_name_bytes,
  2838.         sw_value_length,
  2839.         sw_value_length_2,
  2840.         sw_value_length_3,
  2841.         sw_value_length_4,
  2842.         sw_value,
  2843.         sw_value_bytes
  2844.     } state;

  2846.     /* header block fragment */

  2848. #if 0
  2849.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2850.                    "grpc header fragment %p:%p rest:%uz",
  2851.                    b->pos, b->last, ctx->rest);
  2852. #endif

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

  2857.     } else {
  2858.         last = b->pos + ctx->rest - ctx->padding;
  2859.     }

  2861.     state = ctx->fragment_state;

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

  2866. #if 0
  2867.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2868.                        "grpc header byte: %02Xd s:%d", ch, state);
  2869. #endif

  2871.         switch (state) {

  2873.         case sw_start:
  2874.             ctx->index = 0;

  2876.             if ((ch & 0x80) == 0x80) {
  2877.                 /*
  2878.                  * indexed header:
  2879.                  *
  2880.                  *   0   1   2   3   4   5   6   7
  2881.                  * +---+---+---+---+---+---+---+---+
  2882.                  * | 1 |        Index (7+)         |
  2883.                  * +---+---------------------------+
  2884.                  */

  2886.                 index = ch & ~0x80;

  2888.                 if (index == 0 || index > 61) {
  2889.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2890.                                   "upstream sent invalid http2 "
  2891.                                   "table index: %ui", index);
  2892.                     return NGX_ERROR;
  2893.                 }

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

  2898.                 ctx->index = index;
  2899.                 ctx->literal = 0;

  2901.                 goto done;

  2903.             } else if ((ch & 0xc0) == 0x40) {
  2904.                 /*
  2905.                  * literal header with incremental indexing:
  2906.                  *
  2907.                  *   0   1   2   3   4   5   6   7
  2908.                  * +---+---+---+---+---+---+---+---+
  2909.                  * | 0 | 1 |      Index (6+)       |
  2910.                  * +---+---+-----------------------+
  2911.                  * | H |     Value Length (7+)     |
  2912.                  * +---+---------------------------+
  2913.                  * | Value String (Length octets)  |
  2914.                  * +-------------------------------+
  2915.                  *
  2916.                  *   0   1   2   3   4   5   6   7
  2917.                  * +---+---+---+---+---+---+---+---+
  2918.                  * | 0 | 1 |           0           |
  2919.                  * +---+---+-----------------------+
  2920.                  * | H |     Name Length (7+)      |
  2921.                  * +---+---------------------------+
  2922.                  * |  Name String (Length octets)  |
  2923.                  * +---+---------------------------+
  2924.                  * | H |     Value Length (7+)     |
  2925.                  * +---+---------------------------+
  2926.                  * | Value String (Length octets)  |
  2927.                  * +-------------------------------+
  2928.                  */

  2930.                 index = ch & ~0xc0;

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

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

  2942.                 if (index == 0) {
  2943.                     state = sw_name_length;
  2944.                     break;
  2945.                 }

  2947.                 ctx->index = index;
  2948.                 ctx->literal = 1;

  2950.                 state = sw_value_length;
  2951.                 break;

  2953.             } else if ((ch & 0xe0) == 0x20) {
  2954.                 /*
  2955.                  * dynamic table size update:
  2956.                  *
  2957.                  *   0   1   2   3   4   5   6   7
  2958.                  * +---+---+---+---+---+---+---+---+
  2959.                  * | 0 | 0 | 1 |   Max size (5+)   |
  2960.                  * +---+---------------------------+
  2961.                  */

  2963.                 size_update = ch & ~0xe0;

  2965.                 if (size_update > 0) {
  2966.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2967.                                   "upstream sent invalid http2 "
  2968.                                   "dynamic table size update: %ui",
  2969.                                   size_update);
  2970.                     return NGX_ERROR;
  2971.                 }

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

  2976.                 break;

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

  3005.                 index = ch & ~0xf0;

  3007.                 if (index == 0x0f) {
  3008.                     ctx->index = index;
  3009.                     ctx->literal = 1;
  3010.                     state = sw_index;
  3011.                     break;
  3012.                 }

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

  3019.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3020.                                "grpc literal header never indexed: %ui",
  3021.                                index);

  3023.                 ctx->index = index;
  3024.                 ctx->literal = 1;

  3026.                 state = sw_value_length;
  3027.                 break;

  3029.             } else if ((ch & 0xf0) == 0x00) {
  3030.                 /*
  3031.                  * literal header field without indexing:
  3032.                  *
  3033.                  *   0   1   2   3   4   5   6   7
  3034.                  * +---+---+---+---+---+---+---+---+
  3035.                  * | 0 | 0 | 0 | 0 |  Index (4+)   |
  3036.                  * +---+---+-----------------------+
  3037.                  * | H |     Value Length (7+)     |
  3038.                  * +---+---------------------------+
  3039.                  * | Value String (Length octets)  |
  3040.                  * +-------------------------------+
  3041.                  *
  3042.                  *   0   1   2   3   4   5   6   7
  3043.                  * +---+---+---+---+---+---+---+---+
  3044.                  * | 0 | 0 | 0 | 0 |       0       |
  3045.                  * +---+---+-----------------------+
  3046.                  * | H |     Name Length (7+)      |
  3047.                  * +---+---------------------------+
  3048.                  * |  Name String (Length octets)  |
  3049.                  * +---+---------------------------+
  3050.                  * | H |     Value Length (7+)     |
  3051.                  * +---+---------------------------+
  3052.                  * | Value String (Length octets)  |
  3053.                  * +-------------------------------+
  3054.                  */

  3056.                 index = ch & ~0xf0;

  3058.                 if (index == 0x0f) {
  3059.                     ctx->index = index;
  3060.                     ctx->literal = 1;
  3061.                     state = sw_index;
  3062.                     break;
  3063.                 }

  3065.                 if (index == 0) {
  3066.                     state = sw_name_length;
  3067.                     break;
  3068.                 }

  3070.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3071.                                "grpc literal header without indexing: %ui",
  3072.                                index);

  3074.                 ctx->index = index;
  3075.                 ctx->literal = 1;

  3077.                 state = sw_value_length;
  3078.                 break;
  3079.             }

  3081.             /* not reached */

  3083.             return NGX_ERROR;

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

  3088.             if (ch & 0x80) {
  3089.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3090.                               "upstream sent http2 table index "
  3091.                               "with continuation flag");
  3092.                 return NGX_ERROR;
  3093.             }

  3095.             if (ctx->index > 61) {
  3096.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3097.                               "upstream sent invalid http2 "
  3098.                               "table index: %ui", ctx->index);
  3099.                 return NGX_ERROR;
  3100.             }

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

  3105.             state = sw_value_length;
  3106.             break;

  3108.         case sw_name_length:
  3109.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3110.             ctx->field_length = ch & ~0x80;

  3112.             if (ctx->field_length == 0x7f) {
  3113.                 state = sw_name_length_2;
  3114.                 break;
  3115.             }

  3117.             if (ctx->field_length == 0) {
  3118.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3119.                               "upstream sent zero http2 "
  3120.                               "header name length");
  3121.                 return NGX_ERROR;
  3122.             }

  3124.             state = sw_name;
  3125.             break;

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

  3130.             if (ch & 0x80) {
  3131.                 state = sw_name_length_3;
  3132.                 break;
  3133.             }

  3135.             state = sw_name;
  3136.             break;

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

  3141.             if (ch & 0x80) {
  3142.                 state = sw_name_length_4;
  3143.                 break;
  3144.             }

  3146.             state = sw_name;
  3147.             break;

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

  3152.             if (ch & 0x80) {
  3153.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3154.                               "upstream sent too large http2 "
  3155.                               "header name length");
  3156.                 return NGX_ERROR;
  3157.             }

  3159.             state = sw_name;
  3160.             break;

  3162.         case sw_name:
  3163.             ctx->name.len = ctx->field_huffman ?
  3164.                             ctx->field_length * 8 / 5 : ctx->field_length;

  3166.             ctx->name.data = ngx_pnalloc(r->pool, ctx->name.len + 1);
  3167.             if (ctx->name.data == NULL) {
  3168.                 return NGX_ERROR;
  3169.             }

  3171.             ctx->field_end = ctx->name.data;
  3172.             ctx->field_rest = ctx->field_length;
  3173.             ctx->field_state = 0;

  3175.             state = sw_name_bytes;

  3177.             /* fall through */

  3179.         case sw_name_bytes:

  3181.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3182.                            "grpc name: len:%uz h:%d last:%uz, rest:%uz",
  3183.                            ctx->field_length,
  3184.                            ctx->field_huffman,
  3185.                            last - p,
  3186.                            ctx->rest - (p - b->pos));

  3188.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3189.             ctx->field_rest -= size;

  3191.             if (ctx->field_huffman) {
  3192.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3193.                                          &ctx->field_end,
  3194.                                          ctx->field_rest == 0,
  3195.                                          r->connection->log)
  3196.                     != NGX_OK)
  3197.                 {
  3198.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3199.                                   "upstream sent invalid encoded header");
  3200.                     return NGX_ERROR;
  3201.                 }

  3203.                 ctx->name.len = ctx->field_end - ctx->name.data;
  3204.                 ctx->name.data[ctx->name.len] = '\0';

  3206.             } else {
  3207.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3208.                 ctx->name.data[ctx->name.len] = '\0';
  3209.             }

  3211.             p += size - 1;

  3213.             if (ctx->field_rest == 0) {
  3214.                 state = sw_value_length;
  3215.             }

  3217.             break;

  3219.         case sw_value_length:
  3220.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3221.             ctx->field_length = ch & ~0x80;

  3223.             if (ctx->field_length == 0x7f) {
  3224.                 state = sw_value_length_2;
  3225.                 break;
  3226.             }

  3228.             if (ctx->field_length == 0) {
  3229.                 ngx_str_set(&ctx->value, "");
  3230.                 goto done;
  3231.             }

  3233.             state = sw_value;
  3234.             break;

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

  3239.             if (ch & 0x80) {
  3240.                 state = sw_value_length_3;
  3241.                 break;
  3242.             }

  3244.             state = sw_value;
  3245.             break;

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

  3250.             if (ch & 0x80) {
  3251.                 state = sw_value_length_4;
  3252.                 break;
  3253.             }

  3255.             state = sw_value;
  3256.             break;

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

  3261.             if (ch & 0x80) {
  3262.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3263.                               "upstream sent too large http2 "
  3264.                               "header value length");
  3265.                 return NGX_ERROR;
  3266.             }

  3268.             state = sw_value;
  3269.             break;

  3271.         case sw_value:
  3272.             ctx->value.len = ctx->field_huffman ?
  3273.                              ctx->field_length * 8 / 5 : ctx->field_length;

  3275.             ctx->value.data = ngx_pnalloc(r->pool, ctx->value.len + 1);
  3276.             if (ctx->value.data == NULL) {
  3277.                 return NGX_ERROR;
  3278.             }

  3280.             ctx->field_end = ctx->value.data;
  3281.             ctx->field_rest = ctx->field_length;
  3282.             ctx->field_state = 0;

  3284.             state = sw_value_bytes;

  3286.             /* fall through */

  3288.         case sw_value_bytes:

  3290.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3291.                            "grpc value: len:%uz h:%d last:%uz, rest:%uz",
  3292.                            ctx->field_length,
  3293.                            ctx->field_huffman,
  3294.                            last - p,
  3295.                            ctx->rest - (p - b->pos));

  3297.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3298.             ctx->field_rest -= size;

  3300.             if (ctx->field_huffman) {
  3301.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3302.                                          &ctx->field_end,
  3303.                                          ctx->field_rest == 0,
  3304.                                          r->connection->log)
  3305.                     != NGX_OK)
  3306.                 {
  3307.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3308.                                   "upstream sent invalid encoded header");
  3309.                     return NGX_ERROR;
  3310.                 }

  3312.                 ctx->value.len = ctx->field_end - ctx->value.data;
  3313.                 ctx->value.data[ctx->value.len] = '\0';

  3315.             } else {
  3316.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3317.                 ctx->value.data[ctx->value.len] = '\0';
  3318.             }

  3320.             p += size - 1;

  3322.             if (ctx->field_rest == 0) {
  3323.                 goto done;
  3324.             }

  3326.             break;
  3327.         }

  3329.         continue;

  3331.     done:

  3333.         p++;
  3334.         ctx->rest -= p - b->pos;
  3335.         ctx->fragment_state = sw_start;
  3336.         b->pos = p;

  3338.         if (ctx->index) {
  3339.             ctx->name = *ngx_http_v2_get_static_name(ctx->index);
  3340.         }

  3342.         if (ctx->index && !ctx->literal) {
  3343.             ctx->value = *ngx_http_v2_get_static_value(ctx->index);
  3344.         }

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

  3355.         if (!ctx->index || ctx->literal) {
  3356.             if (ngx_http_grpc_validate_header_value(r, &ctx->value) != NGX_OK) {
  3357.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3358.                               "upstream sent invalid header: \"%V: %V\"",
  3359.                               &ctx->name, &ctx->value);
  3360.                 return NGX_ERROR;
  3361.             }
  3362.         }

  3364.         return NGX_OK;
  3365.     }

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

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

  3375.     return NGX_DONE;
  3376. }


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

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

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

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

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

  3401.     return NGX_OK;
  3402. }


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

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

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

  3419.     return NGX_OK;
  3420. }


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

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

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

  3442.     state = ctx->frame_state;

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

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

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

  3462.         switch (state) {

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

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

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

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

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

  3486.             break;
  3487.         }
  3488.     }

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

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

  3498.     ctx->state = ngx_http_grpc_st_start;

  3500.     return NGX_OK;
  3501. }


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

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

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

  3528.     state = ctx->frame_state;

  3530.     if (state == sw_start) {

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

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

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

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

  3557.         switch (state) {

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

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

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

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

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

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

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

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

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

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

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

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

  3616.     ctx->state = ngx_http_grpc_st_start;

  3618.     return NGX_OK;
  3619. }


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

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

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

  3641.     state = ctx->frame_state;

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

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

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

  3661.         switch (state) {

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

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

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

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

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

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

  3693.     ctx->state = ngx_http_grpc_st_start;

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

  3698.     if (ctx->stream_id) {

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

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

  3710.     } else {

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

  3720.         ctx->connection->send_window += ctx->window_update;
  3721.     }

  3723.     return NGX_OK;
  3724. }


  3727. static ngx_int_t
  3728. ‌ngx_http_grpc_parse_settings(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  3729.     ngx_buf_t *b)
  3730. {
  3731.     u_char   ch, *p, *last;
  3732.     ssize_t  window_update;
  3733. ‌    enum {
  3734.         sw_start = 0,
  3735.         sw_id,
  3736.         sw_id_2,
  3737.         sw_value,
  3738.         sw_value_2,
  3739.         sw_value_3,
  3740.         sw_value_4
  3741.     } state;

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

  3746.     } else {
  3747.         last = b->pos + ctx->rest;
  3748.     }

  3750.     state = ctx->frame_state;

  3752.     if (state == sw_start) {

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

  3762.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  3763.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3764.                            "grpc settings ack");

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

  3774.             ctx->state = ngx_http_grpc_st_start;

  3776.             return NGX_OK;
  3777.         }

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

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

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

  3797. #if 0
  3798.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3799.                        "grpc settings byte: %02Xd s:%d", ch, state);
  3800. #endif

  3802.         switch (state) {

  3804.         case sw_start:
  3805.         case sw_id:
  3806.             ctx->setting_id = ch << 8;
  3807.             state = sw_id_2;
  3808.             break;

  3810.         case sw_id_2:
  3811.             ctx->setting_id |= ch;
  3812.             state = sw_value;
  3813.             break;

  3815.         case sw_value:
  3816.             ctx->setting_value = (ngx_uint_t) ch << 24;
  3817.             state = sw_value_2;
  3818.             break;

  3820.         case sw_value_2:
  3821.             ctx->setting_value |= ch << 16;
  3822.             state = sw_value_3;
  3823.             break;

  3825.         case sw_value_3:
  3826.             ctx->setting_value |= ch << 8;
  3827.             state = sw_value_4;
  3828.             break;

  3830.         case sw_value_4:
  3831.             ctx->setting_value |= ch;
  3832.             state = sw_id;

  3834.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3835.                            "grpc setting: %ui %ui",
  3836.                            ctx->setting_id, ctx->setting_value);

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

  3849.             if (ctx->setting_id == 0x04) {
  3850.                 /* SETTINGS_INITIAL_WINDOW_SIZE */

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

  3860.                 window_update = ctx->setting_value
  3861.                                 - ctx->connection->init_window;
  3862.                 ctx->connection->init_window = ctx->setting_value;

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

  3875.                 ctx->send_window += window_update;
  3876.             }

  3878.             break;
  3879.         }
  3880.     }

  3882.     ctx->rest -= p - b->pos;
  3883.     ctx->frame_state = state;
  3884.     b->pos = p;

  3886.     if (ctx->rest > 0) {
  3887.         return NGX_AGAIN;
  3888.     }

  3890.     ctx->state = ngx_http_grpc_st_start;

  3892.     return ngx_http_grpc_send_settings_ack(r, ctx);
  3893. }


  3896. static ngx_int_t
  3897. ‌ngx_http_grpc_parse_ping(ngx_http_request_t *r,
  3898.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b)
  3899. {
  3900.     u_char  ch, *p, *last;
  3901. ‌    enum {
  3902.         sw_start = 0,
  3903.         sw_data_2,
  3904.         sw_data_3,
  3905.         sw_data_4,
  3906.         sw_data_5,
  3907.         sw_data_6,
  3908.         sw_data_7,
  3909.         sw_data_8
  3910.     } state;

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

  3915.     } else {
  3916.         last = b->pos + ctx->rest;
  3917.     }

  3919.     state = ctx->frame_state;

  3921.     if (state == sw_start) {

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

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

  3939.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  3940.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3941.                           "upstream sent ping frame with ack flag");
  3942.             return NGX_ERROR;
  3943.         }

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

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

  3955. #if 0
  3956.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3957.                        "grpc ping byte: %02Xd s:%d", ch, state);
  3958. #endif

  3960.         if (state < sw_data_8) {
  3961.             ctx->ping_data[state] = ch;
  3962.             state++;

  3964.         } else {
  3965.             ctx->ping_data[7] = ch;
  3966.             state = sw_start;

  3968.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3969.                            "grpc ping");
  3970.         }
  3971.     }

  3973.     ctx->rest -= p - b->pos;
  3974.     ctx->frame_state = state;
  3975.     b->pos = p;

  3977.     if (ctx->rest > 0) {
  3978.         return NGX_AGAIN;
  3979.     }

  3981.     ctx->state = ngx_http_grpc_st_start;

  3983.     return ngx_http_grpc_send_ping_ack(r, ctx);
  3984. }


  3987. static ngx_int_t
  3988. ‌ngx_http_grpc_send_settings_ack(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  3989. {
  3990.     ngx_chain_t            *cl, **ll;
  3991.     ngx_http_grpc_frame_t  *f;

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

  3996.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  3997.         ll = &cl->next;
  3998.     }

  4000.     cl = ngx_http_grpc_get_buf(r, ctx);
  4001.     if (cl == NULL) {
  4002.         return NGX_ERROR;
  4003.     }

  4005.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4006.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4008.     f->length_0 = 0;
  4009.     f->length_1 = 0;
  4010.     f->length_2 = 0;
  4011.     f->type = NGX_HTTP_V2_SETTINGS_FRAME;
  4012.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  4013.     f->stream_id_0 = 0;
  4014.     f->stream_id_1 = 0;
  4015.     f->stream_id_2 = 0;
  4016.     f->stream_id_3 = 0;

  4018.     *ll = cl;

  4020.     return NGX_OK;
  4021. }


  4024. static ngx_int_t
  4025. ‌ngx_http_grpc_send_ping_ack(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  4026. {
  4027.     ngx_chain_t            *cl, **ll;
  4028.     ngx_http_grpc_frame_t  *f;

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

  4033.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4034.         ll = &cl->next;
  4035.     }

  4037.     cl = ngx_http_grpc_get_buf(r, ctx);
  4038.     if (cl == NULL) {
  4039.         return NGX_ERROR;
  4040.     }

  4042.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4043.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4045.     f->length_0 = 0;
  4046.     f->length_1 = 0;
  4047.     f->length_2 = 8;
  4048.     f->type = NGX_HTTP_V2_PING_FRAME;
  4049.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  4050.     f->stream_id_0 = 0;
  4051.     f->stream_id_1 = 0;
  4052.     f->stream_id_2 = 0;
  4053.     f->stream_id_3 = 0;

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

  4057.     *ll = cl;

  4059.     return NGX_OK;
  4060. }


  4063. static ngx_int_t
  4064. ‌ngx_http_grpc_send_window_update(ngx_http_request_t *r,
  4065.     ngx_http_grpc_ctx_t *ctx)
  4066. {
  4067.     size_t                  n;
  4068.     ngx_chain_t            *cl, **ll;
  4069.     ngx_http_grpc_frame_t  *f;

  4071.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4072.                    "grpc send window update: %uz %uz",
  4073.                    ctx->connection->recv_window, ctx->recv_window);

  4075.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4076.         ll = &cl->next;
  4077.     }

  4079.     cl = ngx_http_grpc_get_buf(r, ctx);
  4080.     if (cl == NULL) {
  4081.         return NGX_ERROR;
  4082.     }

  4084.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4085.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4087.     f->length_0 = 0;
  4088.     f->length_1 = 0;
  4089.     f->length_2 = 4;
  4090.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4091.     f->flags = 0;
  4092.     f->stream_id_0 = 0;
  4093.     f->stream_id_1 = 0;
  4094.     f->stream_id_2 = 0;
  4095.     f->stream_id_3 = 0;

  4097.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->connection->recv_window;
  4098.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4100.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4101.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4102.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4103.     *cl->buf->last++ = (u_char) (n & 0xff);

  4105.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4106.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4108.     f->length_0 = 0;
  4109.     f->length_1 = 0;
  4110.     f->length_2 = 4;
  4111.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4112.     f->flags = 0;
  4113.     f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  4114.     f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  4115.     f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  4116.     f->stream_id_3 = (u_char) (ctx->id & 0xff);

  4118.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->recv_window;
  4119.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4121.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4122.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4123.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4124.     *cl->buf->last++ = (u_char) (n & 0xff);

  4126.     *ll = cl;

  4128.     return NGX_OK;
  4129. }


  4132. static ngx_chain_t *
  4133. ‌ngx_http_grpc_get_buf(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  4134. {
  4135.     u_char       *start;
  4136.     ngx_buf_t    *b;
  4137.     ngx_chain_t  *cl;

  4139.     cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  4140.     if (cl == NULL) {
  4141.         return NULL;
  4142.     }

  4144.     b = cl->buf;
  4145.     start = b->start;

  4147.     if (start == NULL) {

  4149.         /*
  4150.          * each buffer is large enough to hold two window update
  4151.          * frames in a row
  4152.          */

  4154.         start = ngx_palloc(r->pool, 2 * sizeof(ngx_http_grpc_frame_t) + 8);
  4155.         if (start == NULL) {
  4156.             return NULL;
  4157.         }

  4159.     }

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

  4163.     b->start = start;
  4164.     b->pos = start;
  4165.     b->last = start;
  4166.     b->end = start + 2 * sizeof(ngx_http_grpc_frame_t) + 8;

  4168.     b->tag = (ngx_buf_tag_t) &ngx_http_grpc_body_output_filter;
  4169.     b->temporary = 1;
  4170.     b->flush = 1;

  4172.     return cl;
  4173. }


  4176. static ngx_http_grpc_ctx_t *
  4177. ‌ngx_http_grpc_get_ctx(ngx_http_request_t *r)
  4178. {
  4179.     ngx_http_grpc_ctx_t  *ctx;
  4180.     ngx_http_upstream_t  *u;

  4182.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

  4184.     if (ctx->connection == NULL) {
  4185.         u = r->upstream;

  4187.         if (ngx_http_grpc_get_connection_data(r, ctx, &u->peer) != NGX_OK) {
  4188.             return NULL;
  4189.         }
  4190.     }

  4192.     return ctx;
  4193. }


  4196. static ngx_int_t
  4197. ‌ngx_http_grpc_get_connection_data(ngx_http_request_t *r,
  4198.     ngx_http_grpc_ctx_t *ctx, ngx_peer_connection_t *pc)
  4199. {
  4200.     ngx_connection_t    *c;
  4201.     ngx_pool_cleanup_t  *cln;

  4203.     c = pc->connection;

  4205.     if (pc->cached) {

  4207.         /*
  4208.          * for cached connections, connection data can be found
  4209.          * in the cleanup handler
  4210.          */

  4212.         for (cln = c->pool->cleanup; cln; cln = cln->next) {
  4213.             if (cln->handler == ngx_http_grpc_cleanup) {
  4214.                 ctx->connection = cln->data;
  4215.                 break;
  4216.             }
  4217.         }

  4219.         if (ctx->connection == NULL) {
  4220.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  4221.                           "no connection data found for "
  4222.                           "keepalive http2 connection");
  4223.             return NGX_ERROR;
  4224.         }

  4226.         ctx->send_window = ctx->connection->init_window;
  4227.         ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4229.         ctx->connection->last_stream_id += 2;
  4230.         ctx->id = ctx->connection->last_stream_id;

  4232.         return NGX_OK;
  4233.     }

  4235.     cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_grpc_conn_t));
  4236.     if (cln == NULL) {
  4237.         return NGX_ERROR;
  4238.     }

  4240.     cln->handler = ngx_http_grpc_cleanup;
  4241.     ctx->connection = cln->data;

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

  4247.     ctx->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4248.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4250.     ctx->id = 1;
  4251.     ctx->connection->last_stream_id = 1;

  4253.     return NGX_OK;
  4254. }


  4257. static void
  4258. ‌ngx_http_grpc_cleanup(void *data)
  4259. {
  4260. #if 0
  4261.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  4262.                    "grpc cleanup");
  4263. #endif
  4264.     return;
  4265. }


  4268. static void
  4269. ‌ngx_http_grpc_abort_request(ngx_http_request_t *r)
  4270. {
  4271.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4272.                    "abort grpc request");
  4273.     return;
  4274. }


  4277. static void
  4278. ‌ngx_http_grpc_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  4279. {
  4280.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4281.                    "finalize grpc request");
  4282.     return;
  4283. }


  4286. static ngx_int_t
  4287. ‌ngx_http_grpc_internal_trailers_variable(ngx_http_request_t *r,
  4288.     ngx_http_variable_value_t *v, uintptr_t data)
  4289. {
  4290.     ngx_table_elt_t  *te;

  4292.     te = r->headers_in.te;

  4294.     if (te == NULL) {
  4295.         v->not_found = 1;
  4296.         return NGX_OK;
  4297.     }

  4299.     if (ngx_strlcasestrn(te->value.data, te->value.data + te->value.len,
  4300.                          (u_char *) "trailers", 8 - 1)
  4301.         == NULL)
  4302.     {
  4303.         v->not_found = 1;
  4304.         return NGX_OK;
  4305.     }

  4307.     v->valid = 1;
  4308.     v->no_cacheable = 0;
  4309.     v->not_found = 0;

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

  4314.     return NGX_OK;
  4315. }


  4318. static ngx_int_t
  4319. ‌ngx_http_grpc_add_variables(ngx_conf_t *cf)
  4320. {
  4321.     ngx_http_variable_t  *var, *v;

  4323.     for (v = ngx_http_grpc_vars; v->name.len; v++) {
  4324.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  4325.         if (var == NULL) {
  4326.             return NGX_ERROR;
  4327.         }

  4329.         var->get_handler = v->get_handler;
  4330.         var->data = v->data;
  4331.     }

  4333.     return NGX_OK;
  4334. }


  4337. static void *
  4338. ‌ngx_http_grpc_create_loc_conf(ngx_conf_t *cf)
  4339. {
  4340.     ngx_http_grpc_loc_conf_t  *conf;

  4342.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_grpc_loc_conf_t));
  4343.     if (conf == NULL) {
  4344.         return NULL;
  4345.     }

  4347.     /*
  4348.      * set by ngx_pcalloc():
  4349.      *
  4350.      *     conf->upstream.ignore_headers = 0;
  4351.      *     conf->upstream.next_upstream = 0;
  4352.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  4353.      *
  4354.      *     conf->headers.lengths = NULL;
  4355.      *     conf->headers.values = NULL;
  4356.      *     conf->headers.hash = { NULL, 0 };
  4357.      *     conf->host = { 0, NULL };
  4358.      *     conf->host_set = 0;
  4359.      *     conf->ssl = 0;
  4360.      *     conf->ssl_protocols = 0;
  4361.      *     conf->ssl_ciphers = { 0, NULL };
  4362.      *     conf->ssl_trusted_certificate = { 0, NULL };
  4363.      *     conf->ssl_crl = { 0, NULL };
  4364.      */

  4366.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  4367.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;
  4368.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  4369.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  4370.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  4371.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  4372.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  4374.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;

  4376.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  4377.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  4379.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  4381. #if (NGX_HTTP_SSL)
  4382.     conf->upstream.ssl_session_reuse = NGX_CONF_UNSET;
  4383.     conf->upstream.ssl_name = NGX_CONF_UNSET_PTR;
  4384.     conf->upstream.ssl_server_name = NGX_CONF_UNSET;
  4385.     conf->upstream.ssl_verify = NGX_CONF_UNSET;
  4386.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  4387.     conf->upstream.ssl_certificate = NGX_CONF_UNSET_PTR;
  4388.     conf->upstream.ssl_certificate_key = NGX_CONF_UNSET_PTR;
  4389.     conf->upstream.ssl_passwords = NGX_CONF_UNSET_PTR;
  4390.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  4391. #endif

  4393.     /* the hardcoded values */
  4394.     conf->upstream.cyclic_temp_file = 0;
  4395.     conf->upstream.buffering = 0;
  4396.     conf->upstream.ignore_client_abort = 0;
  4397.     conf->upstream.send_lowat = 0;
  4398.     conf->upstream.bufs.num = 0;
  4399.     conf->upstream.busy_buffers_size = 0;
  4400.     conf->upstream.max_temp_file_size = 0;
  4401.     conf->upstream.temp_file_write_size = 0;
  4402.     conf->upstream.pass_request_headers = 1;
  4403.     conf->upstream.pass_request_body = 1;
  4404.     conf->upstream.force_ranges = 0;
  4405.     conf->upstream.pass_trailers = 1;
  4406.     conf->upstream.preserve_output = 1;

  4408.     conf->headers_source = NGX_CONF_UNSET_PTR;

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

  4412.     return conf;
  4413. }


  4416. static char *
  4417. ‌ngx_http_grpc_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  4418. {
  4419.     ngx_http_grpc_loc_conf_t *prev = parent;
  4420.     ngx_http_grpc_loc_conf_t *conf = child;

  4422.     ngx_int_t                  rc;
  4423.     ngx_hash_init_t            hash;
  4424.     ngx_http_core_loc_conf_t  *clcf;

  4426.     ngx_conf_merge_ptr_value(conf->upstream.local,
  4427.                               prev->upstream.local, NULL);

  4429.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  4430.                               prev->upstream.socket_keepalive, 0);

  4432.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  4433.                               prev->upstream.next_upstream_tries, 0);

  4435.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  4436.                               prev->upstream.connect_timeout, 60000);

  4438.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  4439.                               prev->upstream.send_timeout, 60000);

  4441.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  4442.                               prev->upstream.read_timeout, 60000);

  4444.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  4445.                               prev->upstream.next_upstream_timeout, 0);

  4447.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  4448.                               prev->upstream.buffer_size,
  4449.                               (size_t) ngx_pagesize);

  4451.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  4452.                               prev->upstream.ignore_headers,
  4453.                               NGX_CONF_BITMASK_SET);

  4455.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  4456.                               prev->upstream.next_upstream,
  4457.                               (NGX_CONF_BITMASK_SET
  4458.                                |NGX_HTTP_UPSTREAM_FT_ERROR
  4459.                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  4461.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  4462.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  4463.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  4464.     }

  4466.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  4467.                               prev->upstream.intercept_errors, 0);

  4469. #if (NGX_HTTP_SSL)

  4471.     if (ngx_http_grpc_merge_ssl(cf, conf, prev) != NGX_OK) {
  4472.         return NGX_CONF_ERROR;
  4473.     }

  4475.     ngx_conf_merge_value(conf->upstream.ssl_session_reuse,
  4476.                               prev->upstream.ssl_session_reuse, 1);

  4478.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  4479.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  4481.     ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers,
  4482.                              "DEFAULT");

  4484.     ngx_conf_merge_ptr_value(conf->upstream.ssl_name,
  4485.                               prev->upstream.ssl_name, NULL);
  4486.     ngx_conf_merge_value(conf->upstream.ssl_server_name,
  4487.                               prev->upstream.ssl_server_name, 0);
  4488.     ngx_conf_merge_value(conf->upstream.ssl_verify,
  4489.                               prev->upstream.ssl_verify, 0);
  4490.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  4491.                               prev->ssl_verify_depth, 1);
  4492.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  4493.                               prev->ssl_trusted_certificate, "");
  4494.     ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");

  4496.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate,
  4497.                               prev->upstream.ssl_certificate, NULL);
  4498.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_key,
  4499.                               prev->upstream.ssl_certificate_key, NULL);
  4500.     ngx_conf_merge_ptr_value(conf->upstream.ssl_passwords,
  4501.                               prev->upstream.ssl_passwords, NULL);

  4503.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  4504.                               prev->ssl_conf_commands, NULL);

  4506.     if (conf->ssl && ngx_http_grpc_set_ssl(cf, conf) != NGX_OK) {
  4507.         return NGX_CONF_ERROR;
  4508.     }

  4510. #endif

  4512.     hash.max_size = 512;
  4513.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  4514.     hash.name = "grpc_headers_hash";

  4516.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  4517.             &prev->upstream, ngx_http_grpc_hide_headers, &hash)
  4518.         != NGX_OK)
  4519.     {
  4520.         return NGX_CONF_ERROR;
  4521.     }

  4523.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  4525.     if (clcf->noname
  4526.         && conf->upstream.upstream == NULL && conf->grpc_lengths == NULL)
  4527.     {
  4528.         conf->upstream.upstream = prev->upstream.upstream;
  4529.         conf->host = prev->host;

  4531.         conf->grpc_lengths = prev->grpc_lengths;
  4532.         conf->grpc_values = prev->grpc_values;

  4534. #if (NGX_HTTP_SSL)
  4535.         conf->ssl = prev->ssl;
  4536. #endif
  4537.     }

  4539.     if (clcf->lmt_excpt && clcf->handler == NULL
  4540.         && (conf->upstream.upstream || conf->grpc_lengths))
  4541.     {
  4542.         clcf->handler = ngx_http_grpc_handler;
  4543.     }

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

  4547.     if (conf->headers_source == prev->headers_source) {
  4548.         conf->headers = prev->headers;
  4549.         conf->host_set = prev->host_set;
  4550.     }

  4552.     rc = ngx_http_grpc_init_headers(cf, conf, &conf->headers,
  4553.                                     ngx_http_grpc_headers);
  4554.     if (rc != NGX_OK) {
  4555.         return NGX_CONF_ERROR;
  4556.     }

  4558.     /*
  4559.      * special handling to preserve conf->headers in the "http" section
  4560.      * to inherit it to all servers
  4561.      */

  4563.     if (prev->headers.hash.buckets == NULL
  4564.         && conf->headers_source == prev->headers_source)
  4565.     {
  4566.         prev->headers = conf->headers;
  4567.         prev->host_set = conf->host_set;
  4568.     }

  4570.     return NGX_CONF_OK;
  4571. }


  4574. static ngx_int_t
  4575. ‌ngx_http_grpc_init_headers(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *conf,
  4576.     ngx_http_grpc_headers_t *headers, ngx_keyval_t *default_headers)
  4577. {
  4578.     u_char                       *p;
  4579.     size_t                        size;
  4580.     uintptr_t                    *code;
  4581.     ngx_uint_t                    i;
  4582.     ngx_array_t                   headers_names, headers_merged;
  4583.     ngx_keyval_t                 *src, *s, *h;
  4584.     ngx_hash_key_t               *hk;
  4585.     ngx_hash_init_t               hash;
  4586.     ngx_http_script_compile_t     sc;
  4587.     ngx_http_script_copy_code_t  *copy;

  4589.     if (headers->hash.buckets) {
  4590.         return NGX_OK;
  4591.     }

  4593.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  4594.         != NGX_OK)
  4595.     {
  4596.         return NGX_ERROR;
  4597.     }

  4599.     if (ngx_array_init(&headers_merged, cf->temp_pool, 4, sizeof(ngx_keyval_t))
  4600.         != NGX_OK)
  4601.     {
  4602.         return NGX_ERROR;
  4603.     }

  4605.     headers->lengths = ngx_array_create(cf->pool, 64, 1);
  4606.     if (headers->lengths == NULL) {
  4607.         return NGX_ERROR;
  4608.     }

  4610.     headers->values = ngx_array_create(cf->pool, 512, 1);
  4611.     if (headers->values == NULL) {
  4612.         return NGX_ERROR;
  4613.     }

  4615.     if (conf->headers_source) {

  4617.         src = conf->headers_source->elts;
  4618.         for (i = 0; i < conf->headers_source->nelts; i++) {

  4620.             if (src[i].key.len == 4
  4621.                 && ngx_strncasecmp(src[i].key.data, (u_char *) "Host", 4) == 0)
  4622.             {
  4623.                 conf->host_set = 1;
  4624.             }

  4626.             s = ngx_array_push(&headers_merged);
  4627.             if (s == NULL) {
  4628.                 return NGX_ERROR;
  4629.             }

  4631.             *s = src[i];
  4632.         }
  4633.     }

  4635.     h = default_headers;

  4637.     while (h->key.len) {

  4639.         src = headers_merged.elts;
  4640.         for (i = 0; i < headers_merged.nelts; i++) {
  4641.             if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  4642.                 goto next;
  4643.             }
  4644.         }

  4646.         s = ngx_array_push(&headers_merged);
  4647.         if (s == NULL) {
  4648.             return NGX_ERROR;
  4649.         }

  4651.         *s = *h;

  4653.     next:

  4655.         h++;
  4656.     }


  4659.     src = headers_merged.elts;
  4660.     for (i = 0; i < headers_merged.nelts; i++) {

  4662.         hk = ngx_array_push(&headers_names);
  4663.         if (hk == NULL) {
  4664.             return NGX_ERROR;
  4665.         }

  4667.         hk->key = src[i].key;
  4668.         hk->key_hash = ngx_hash_key_lc(src[i].key.data, src[i].key.len);
  4669.         hk->value = (void *) 1;

  4671.         if (src[i].value.len == 0) {
  4672.             continue;
  4673.         }

  4675.         copy = ngx_array_push_n(headers->lengths,
  4676.                                 sizeof(ngx_http_script_copy_code_t));
  4677.         if (copy == NULL) {
  4678.             return NGX_ERROR;
  4679.         }

  4681.         copy->code = (ngx_http_script_code_pt) (void *)
  4682.                                                  ngx_http_script_copy_len_code;
  4683.         copy->len = src[i].key.len;

  4685.         size = (sizeof(ngx_http_script_copy_code_t)
  4686.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  4687.                & ~(sizeof(uintptr_t) - 1);

  4689.         copy = ngx_array_push_n(headers->values, size);
  4690.         if (copy == NULL) {
  4691.             return NGX_ERROR;
  4692.         }

  4694.         copy->code = ngx_http_script_copy_code;
  4695.         copy->len = src[i].key.len;

  4697.         p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
  4698.         ngx_memcpy(p, src[i].key.data, src[i].key.len);

  4700.         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  4702.         sc.cf = cf;
  4703.         sc.source = &src[i].value;
  4704.         sc.flushes = &headers->flushes;
  4705.         sc.lengths = &headers->lengths;
  4706.         sc.values = &headers->values;

  4708.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  4709.             return NGX_ERROR;
  4710.         }

  4712.         code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
  4713.         if (code == NULL) {
  4714.             return NGX_ERROR;
  4715.         }

  4717.         *code = (uintptr_t) NULL;

  4719.         code = ngx_array_push_n(headers->values, sizeof(uintptr_t));
  4720.         if (code == NULL) {
  4721.             return NGX_ERROR;
  4722.         }

  4724.         *code = (uintptr_t) NULL;
  4725.     }

  4727.     code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
  4728.     if (code == NULL) {
  4729.         return NGX_ERROR;
  4730.     }

  4732.     *code = (uintptr_t) NULL;


  4735.     hash.hash = &headers->hash;
  4736.     hash.key = ngx_hash_key_lc;
  4737.     hash.max_size = 512;
  4738.     hash.bucket_size = 64;
  4739.     hash.name = "grpc_headers_hash";
  4740.     hash.pool = cf->pool;
  4741.     hash.temp_pool = NULL;

  4743.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  4744. }


  4747. static char *
  4748. ‌ngx_http_grpc_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4749. {
  4750.     ngx_http_grpc_loc_conf_t *glcf = conf;

  4752.     size_t                      add;
  4753.     ngx_str_t                  *value, *url;
  4754.     ngx_url_t                   u;
  4755.     ngx_uint_t                  n;
  4756.     ngx_http_core_loc_conf_t   *clcf;
  4757.     ngx_http_script_compile_t   sc;

  4759.     if (glcf->upstream.upstream || glcf->grpc_lengths) {
  4760.         return "is duplicate";
  4761.     }

  4763.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  4765.     clcf->handler = ngx_http_grpc_handler;

  4767.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  4768.         clcf->auto_redirect = 1;
  4769.     }

  4771.     value = cf->args->elts;

  4773.     url = &value[1];

  4775.     n = ngx_http_script_variables_count(url);

  4777.     if (n) {

  4779.         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  4781.         sc.cf = cf;
  4782.         sc.source = url;
  4783.         sc.lengths = &glcf->grpc_lengths;
  4784.         sc.values = &glcf->grpc_values;
  4785.         sc.variables = n;
  4786.         sc.complete_lengths = 1;
  4787.         sc.complete_values = 1;

  4789.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  4790.             return NGX_CONF_ERROR;
  4791.         }

  4793. #if (NGX_HTTP_SSL)
  4794.         glcf->ssl = 1;
  4795. #endif

  4797.         return NGX_CONF_OK;
  4798.     }

  4800.     if (ngx_strncasecmp(url->data, (u_char *) "grpc://", 7) == 0) {
  4801.         add = 7;

  4803.     } else if (ngx_strncasecmp(url->data, (u_char *) "grpcs://", 8) == 0) {

  4805. #if (NGX_HTTP_SSL)
  4806.         glcf->ssl = 1;

  4808.         add = 8;
  4809. #else
  4810.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4811.                            "grpcs protocol requires SSL support");
  4812.         return NGX_CONF_ERROR;
  4813. #endif

  4815.     } else {
  4816.         add = 0;
  4817.     }

  4819.     ngx_memzero(&u, sizeof(ngx_url_t));

  4821.     u.url.len = url->len - add;
  4822.     u.url.data = url->data + add;
  4823.     u.no_resolve = 1;

  4825.     glcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  4826.     if (glcf->upstream.upstream == NULL) {
  4827.         return NGX_CONF_ERROR;
  4828.     }

  4830.     if (u.family != AF_UNIX) {

  4832.         if (u.no_port) {
  4833.             glcf->host = u.host;

  4835.         } else {
  4836.             glcf->host.len = u.host.len + 1 + u.port_text.len;
  4837.             glcf->host.data = u.host.data;
  4838.         }

  4840.     } else {
  4841.         ngx_str_set(&glcf->host, "localhost");
  4842.     }

  4844.     return NGX_CONF_OK;
  4845. }


  4848. #if (NGX_HTTP_SSL)

  4850. static char *
  4851. ‌ngx_http_grpc_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4852. {
  4853.     ngx_http_grpc_loc_conf_t *glcf = conf;

  4855.     ngx_str_t  *value;

  4857.     if (glcf->upstream.ssl_passwords != NGX_CONF_UNSET_PTR) {
  4858.         return "is duplicate";
  4859.     }

  4861.     value = cf->args->elts;

  4863.     glcf->upstream.ssl_passwords = ngx_ssl_read_password_file(cf, &value[1]);

  4865.     if (glcf->upstream.ssl_passwords == NULL) {
  4866.         return NGX_CONF_ERROR;
  4867.     }

  4869.     return NGX_CONF_OK;
  4870. }


  4873. static char *
  4874. ‌ngx_http_grpc_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  4875. {
  4876. #ifndef SSL_CONF_FLAG_FILE
  4877.     return "is not supported on this platform";
  4878. #else
  4879.     return NGX_CONF_OK;
  4880. #endif
  4881. }


  4884. static ngx_int_t
  4885. ‌ngx_http_grpc_merge_ssl(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *conf,
  4886.     ngx_http_grpc_loc_conf_t *prev)
  4887. {
  4888.     ngx_uint_t  preserve;

  4890.     if (conf->ssl_protocols == 0
  4891.         && conf->ssl_ciphers.data == NULL
  4892.         && conf->upstream.ssl_certificate == NGX_CONF_UNSET_PTR
  4893.         && conf->upstream.ssl_certificate_key == NGX_CONF_UNSET_PTR
  4894.         && conf->upstream.ssl_passwords == NGX_CONF_UNSET_PTR
  4895.         && conf->upstream.ssl_verify == NGX_CONF_UNSET
  4896.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  4897.         && conf->ssl_trusted_certificate.data == NULL
  4898.         && conf->ssl_crl.data == NULL
  4899.         && conf->upstream.ssl_session_reuse == NGX_CONF_UNSET
  4900.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  4901.     {
  4902.         if (prev->upstream.ssl) {
  4903.             conf->upstream.ssl = prev->upstream.ssl;
  4904.             return NGX_OK;
  4905.         }

  4907.         preserve = 1;

  4909.     } else {
  4910.         preserve = 0;
  4911.     }

  4913.     conf->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  4914.     if (conf->upstream.ssl == NULL) {
  4915.         return NGX_ERROR;
  4916.     }

  4918.     conf->upstream.ssl->log = cf->log;

  4920.     /*
  4921.      * special handling to preserve conf->upstream.ssl
  4922.      * in the "http" section to inherit it to all servers
  4923.      */

  4925.     if (preserve) {
  4926.         prev->upstream.ssl = conf->upstream.ssl;
  4927.     }

  4929.     return NGX_OK;
  4930. }


  4933. static ngx_int_t
  4934. ‌ngx_http_grpc_set_ssl(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *glcf)
  4935. {
  4936.     ngx_pool_cleanup_t  *cln;

  4938.     if (glcf->upstream.ssl->ctx) {
  4939.         return NGX_OK;
  4940.     }

  4942.     if (ngx_ssl_create(glcf->upstream.ssl, glcf->ssl_protocols, NULL)
  4943.         != NGX_OK)
  4944.     {
  4945.         return NGX_ERROR;
  4946.     }

  4948.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  4949.     if (cln == NULL) {
  4950.         ngx_ssl_cleanup_ctx(glcf->upstream.ssl);
  4951.         return NGX_ERROR;
  4952.     }

  4954.     cln->handler = ngx_ssl_cleanup_ctx;
  4955.     cln->data = glcf->upstream.ssl;

  4957.     if (ngx_ssl_ciphers(cf, glcf->upstream.ssl, &glcf->ssl_ciphers, 0)
  4958.         != NGX_OK)
  4959.     {
  4960.         return NGX_ERROR;
  4961.     }

  4963.     if (glcf->upstream.ssl_certificate
  4964.         && glcf->upstream.ssl_certificate->value.len)
  4965.     {
  4966.         if (glcf->upstream.ssl_certificate_key == NULL) {
  4967.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  4968.                           "no \"grpc_ssl_certificate_key\" is defined "
  4969.                           "for certificate \"%V\"",
  4970.                           &glcf->upstream.ssl_certificate->value);
  4971.             return NGX_ERROR;
  4972.         }

  4974.         if (glcf->upstream.ssl_certificate->lengths
  4975.             || glcf->upstream.ssl_certificate_key->lengths)
  4976.         {
  4977.             glcf->upstream.ssl_passwords =
  4978.                   ngx_ssl_preserve_passwords(cf, glcf->upstream.ssl_passwords);
  4979.             if (glcf->upstream.ssl_passwords == NULL) {
  4980.                 return NGX_ERROR;
  4981.             }

  4983.         } else {
  4984.             if (ngx_ssl_certificate(cf, glcf->upstream.ssl,
  4985.                                     &glcf->upstream.ssl_certificate->value,
  4986.                                     &glcf->upstream.ssl_certificate_key->value,
  4987.                                     glcf->upstream.ssl_passwords)
  4988.                 != NGX_OK)
  4989.             {
  4990.                 return NGX_ERROR;
  4991.             }
  4992.         }
  4993.     }

  4995.     if (glcf->upstream.ssl_verify) {
  4996.         if (glcf->ssl_trusted_certificate.len == 0) {
  4997.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  4998.                       "no grpc_ssl_trusted_certificate for grpc_ssl_verify");
  4999.             return NGX_ERROR;
  5000.         }

  5002.         if (ngx_ssl_trusted_certificate(cf, glcf->upstream.ssl,
  5003.                                         &glcf->ssl_trusted_certificate,
  5004.                                         glcf->ssl_verify_depth)
  5005.             != NGX_OK)
  5006.         {
  5007.             return NGX_ERROR;
  5008.         }

  5010.         if (ngx_ssl_crl(cf, glcf->upstream.ssl, &glcf->ssl_crl) != NGX_OK) {
  5011.             return NGX_ERROR;
  5012.         }
  5013.     }

  5015.     if (ngx_ssl_client_session_cache(cf, glcf->upstream.ssl,
  5016.                                      glcf->upstream.ssl_session_reuse)
  5017.         != NGX_OK)
  5018.     {
  5019.         return NGX_ERROR;
  5020.     }

  5022. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  5024.     if (SSL_CTX_set_alpn_protos(glcf->upstream.ssl->ctx,
  5025.                                 (u_char *) "\x02h2", 3)
  5026.         != 0)
  5027.     {
  5028.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  5029.                       "SSL_CTX_set_alpn_protos() failed");
  5030.         return NGX_ERROR;
  5031.     }

  5033. #endif

  5035.     if (ngx_ssl_conf_commands(cf, glcf->upstream.ssl, glcf->ssl_conf_commands)
  5036.         != NGX_OK)
  5037.     {
  5038.         return NGX_ERROR;
  5039.     }

  5041.     return NGX_OK;
  5042. }

  5044. #endif

One Level Up Top Level