One Level Up Top Level

src/http/modules/ngx_http_grpc_module.c - nginx-1.31.4 nginx/ @ 8d9666701

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_http_complex_value_t  *host_value;

  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                     header_limit;
  110.     size_t                     field_length;
  111.     size_t                     field_rest;
  112.     u_char                     field_state;

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

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

  127.     ngx_http_request_t        *request;

  129.     ngx_str_t                  host;
  130. ‌} ngx_http_grpc_ctx_t;


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


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

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

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

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

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

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

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

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

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


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


  239. #if (NGX_HTTP_SSL)

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

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

  254. #endif


  257. ‌static ngx_command_t  ngx_http_grpc_commands[] = {

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

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

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

  280.     { ngx_string("grpc_socket_rcvbuf"),
  281.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  282.       ngx_conf_set_size_slot,
  283.       NGX_HTTP_LOC_CONF_OFFSET,
  284.       offsetof(ngx_http_grpc_loc_conf_t, upstream.socket_rcvbuf),
  285.       NULL },

  287.     { ngx_string("grpc_socket_sndbuf"),
  288.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  289.       ngx_conf_set_size_slot,
  290.       NGX_HTTP_LOC_CONF_OFFSET,
  291.       offsetof(ngx_http_grpc_loc_conf_t, upstream.socket_sndbuf),
  292.       NULL },

  294.     { ngx_string("grpc_connect_timeout"),
  295.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  296.       ngx_conf_set_msec_slot,
  297.       NGX_HTTP_LOC_CONF_OFFSET,
  298.       offsetof(ngx_http_grpc_loc_conf_t, upstream.connect_timeout),
  299.       NULL },

  301.     { ngx_string("grpc_send_timeout"),
  302.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  303.       ngx_conf_set_msec_slot,
  304.       NGX_HTTP_LOC_CONF_OFFSET,
  305.       offsetof(ngx_http_grpc_loc_conf_t, upstream.send_timeout),
  306.       NULL },

  308.     { ngx_string("grpc_intercept_errors"),
  309.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  310.       ngx_conf_set_flag_slot,
  311.       NGX_HTTP_LOC_CONF_OFFSET,
  312.       offsetof(ngx_http_grpc_loc_conf_t, upstream.intercept_errors),
  313.       NULL },

  315.     { ngx_string("grpc_buffer_size"),
  316.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  317.       ngx_conf_set_size_slot,
  318.       NGX_HTTP_LOC_CONF_OFFSET,
  319.       offsetof(ngx_http_grpc_loc_conf_t, upstream.buffer_size),
  320.       NULL },

  322.     { ngx_string("grpc_read_timeout"),
  323.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  324.       ngx_conf_set_msec_slot,
  325.       NGX_HTTP_LOC_CONF_OFFSET,
  326.       offsetof(ngx_http_grpc_loc_conf_t, upstream.read_timeout),
  327.       NULL },

  329.     { ngx_string("grpc_next_upstream"),
  330.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  331.       ngx_conf_set_bitmask_slot,
  332.       NGX_HTTP_LOC_CONF_OFFSET,
  333.       offsetof(ngx_http_grpc_loc_conf_t, upstream.next_upstream),
  334.       &ngx_http_grpc_next_upstream_masks },

  336.     { ngx_string("grpc_next_upstream_tries"),
  337.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  338.       ngx_conf_set_num_slot,
  339.       NGX_HTTP_LOC_CONF_OFFSET,
  340.       offsetof(ngx_http_grpc_loc_conf_t, upstream.next_upstream_tries),
  341.       NULL },

  343.     { ngx_string("grpc_next_upstream_timeout"),
  344.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  345.       ngx_conf_set_msec_slot,
  346.       NGX_HTTP_LOC_CONF_OFFSET,
  347.       offsetof(ngx_http_grpc_loc_conf_t, upstream.next_upstream_timeout),
  348.       NULL },

  350.     { ngx_string("grpc_set_header"),
  351.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  352.       ngx_conf_set_keyval_slot,
  353.       NGX_HTTP_LOC_CONF_OFFSET,
  354.       offsetof(ngx_http_grpc_loc_conf_t, headers_source),
  355.       NULL },

  357.     { ngx_string("grpc_pass_header"),
  358.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  359.       ngx_conf_set_str_array_slot,
  360.       NGX_HTTP_LOC_CONF_OFFSET,
  361.       offsetof(ngx_http_grpc_loc_conf_t, upstream.pass_headers),
  362.       NULL },

  364.     { ngx_string("grpc_hide_header"),
  365.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  366.       ngx_conf_set_str_array_slot,
  367.       NGX_HTTP_LOC_CONF_OFFSET,
  368.       offsetof(ngx_http_grpc_loc_conf_t, upstream.hide_headers),
  369.       NULL },

  371.     { ngx_string("grpc_ignore_headers"),
  372.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  373.       ngx_conf_set_bitmask_slot,
  374.       NGX_HTTP_LOC_CONF_OFFSET,
  375.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ignore_headers),
  376.       &ngx_http_upstream_ignore_headers_masks },

  378. #if (NGX_HTTP_SSL)

  380.     { ngx_string("grpc_ssl_session_reuse"),
  381.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  382.       ngx_conf_set_flag_slot,
  383.       NGX_HTTP_LOC_CONF_OFFSET,
  384.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_session_reuse),
  385.       NULL },

  387.     { ngx_string("grpc_ssl_protocols"),
  388.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  389.       ngx_conf_set_bitmask_slot,
  390.       NGX_HTTP_LOC_CONF_OFFSET,
  391.       offsetof(ngx_http_grpc_loc_conf_t, ssl_protocols),
  392.       &ngx_http_grpc_ssl_protocols },

  394.     { ngx_string("grpc_ssl_ciphers"),
  395.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  396.       ngx_conf_set_str_slot,
  397.       NGX_HTTP_LOC_CONF_OFFSET,
  398.       offsetof(ngx_http_grpc_loc_conf_t, ssl_ciphers),
  399.       NULL },

  401.     { ngx_string("grpc_ssl_name"),
  402.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  403.       ngx_http_set_complex_value_slot,
  404.       NGX_HTTP_LOC_CONF_OFFSET,
  405.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_name),
  406.       NULL },

  408.     { ngx_string("grpc_ssl_server_name"),
  409.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  410.       ngx_conf_set_flag_slot,
  411.       NGX_HTTP_LOC_CONF_OFFSET,
  412.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_server_name),
  413.       NULL },

  415.     { ngx_string("grpc_ssl_verify"),
  416.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  417.       ngx_conf_set_flag_slot,
  418.       NGX_HTTP_LOC_CONF_OFFSET,
  419.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_verify),
  420.       NULL },

  422.     { ngx_string("grpc_ssl_verify_depth"),
  423.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  424.       ngx_conf_set_num_slot,
  425.       NGX_HTTP_LOC_CONF_OFFSET,
  426.       offsetof(ngx_http_grpc_loc_conf_t, ssl_verify_depth),
  427.       NULL },

  429.     { ngx_string("grpc_ssl_trusted_certificate"),
  430.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  431.       ngx_conf_set_str_slot,
  432.       NGX_HTTP_LOC_CONF_OFFSET,
  433.       offsetof(ngx_http_grpc_loc_conf_t, ssl_trusted_certificate),
  434.       NULL },

  436.     { ngx_string("grpc_ssl_crl"),
  437.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  438.       ngx_conf_set_str_slot,
  439.       NGX_HTTP_LOC_CONF_OFFSET,
  440.       offsetof(ngx_http_grpc_loc_conf_t, ssl_crl),
  441.       NULL },

  443.     { ngx_string("grpc_ssl_certificate"),
  444.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  445.       ngx_http_set_complex_value_zero_slot,
  446.       NGX_HTTP_LOC_CONF_OFFSET,
  447.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_certificate),
  448.       NULL },

  450.     { ngx_string("grpc_ssl_certificate_key"),
  451.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  452.       ngx_http_set_complex_value_zero_slot,
  453.       NGX_HTTP_LOC_CONF_OFFSET,
  454.       offsetof(ngx_http_grpc_loc_conf_t, upstream.ssl_certificate_key),
  455.       NULL },

  457.     { ngx_string("grpc_ssl_certificate_cache"),
  458.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  459.       ngx_http_grpc_ssl_certificate_cache,
  460.       NGX_HTTP_LOC_CONF_OFFSET,
  461.       0,
  462.       NULL },

  464.     { ngx_string("grpc_ssl_password_file"),
  465.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  466.       ngx_http_grpc_ssl_password_file,
  467.       NGX_HTTP_LOC_CONF_OFFSET,
  468.       0,
  469.       NULL },

  471.     { ngx_string("grpc_ssl_conf_command"),
  472.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  473.       ngx_conf_set_keyval_slot,
  474.       NGX_HTTP_LOC_CONF_OFFSET,
  475.       offsetof(ngx_http_grpc_loc_conf_t, ssl_conf_commands),
  476.       &ngx_http_grpc_ssl_conf_command_post },

  478. #endif

  480.       ngx_null_command
  481. };


  484. ‌static ngx_http_module_t  ngx_http_grpc_module_ctx = {
  485.     ngx_http_grpc_add_variables,           /* preconfiguration */
  486.     NULL,                                  /* postconfiguration */

  488.     NULL,                                  /* create main configuration */
  489.     NULL,                                  /* init main configuration */

  491.     NULL,                                  /* create server configuration */
  492.     NULL,                                  /* merge server configuration */

  494.     ngx_http_grpc_create_loc_conf,         /* create location configuration */
  495.     ngx_http_grpc_merge_loc_conf           /* merge location configuration */
  496. };


  499. ‌ngx_module_t  ngx_http_grpc_module = {
  500.     NGX_MODULE_V1,
  501.     &ngx_http_grpc_module_ctx,             /* module context */
  502.     ngx_http_grpc_commands,                /* module directives */
  503.     NGX_HTTP_MODULE,                       /* module type */
  504.     NULL,                                  /* init master */
  505.     NULL,                                  /* init module */
  506.     NULL,                                  /* init process */
  507.     NULL,                                  /* init thread */
  508.     NULL,                                  /* exit thread */
  509.     NULL,                                  /* exit process */
  510.     NULL,                                  /* exit master */
  511.     NGX_MODULE_V1_PADDING
  512. };


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

  518.     "\x00\x00\x12\x04\x00\x00\x00\x00\x00"     /* settings frame */
  519.     "\x00\x01\x00\x00\x00\x00"                 /* header table size */
  520.     "\x00\x02\x00\x00\x00\x00"                 /* disable push */
  521.     "\x00\x04\x7f\xff\xff\xff"                 /* initial window */

  523.     "\x00\x00\x04\x08\x00\x00\x00\x00\x00"     /* window update frame */
  524.     "\x7f\xff\x00\x00";


  527. ‌static ngx_keyval_t  ngx_http_grpc_headers[] = {
  528.     { ngx_string("Content-Length"), ngx_string("$content_length") },
  529.     { ngx_string("TE"), ngx_string("$grpc_internal_trailers") },
  530.     { ngx_string("Host"), ngx_string("") },
  531.     { ngx_string("Connection"), ngx_string("") },
  532.     { ngx_string("Proxy-Connection"), ngx_string("") },
  533.     { ngx_string("Transfer-Encoding"), ngx_string("") },
  534.     { ngx_string("Keep-Alive"), ngx_string("") },
  535.     { ngx_string("Expect"), ngx_string("") },
  536.     { ngx_string("Upgrade"), ngx_string("") },
  537.     { ngx_null_string, ngx_null_string }
  538. };


  541. ‌static ngx_str_t  ngx_http_grpc_hide_headers[] = {
  542.     ngx_string("Date"),
  543.     ngx_string("Server"),
  544.     ngx_string("X-Accel-Expires"),
  545.     ngx_string("X-Accel-Redirect"),
  546.     ngx_string("X-Accel-Limit-Rate"),
  547.     ngx_string("X-Accel-Buffering"),
  548.     ngx_string("X-Accel-Charset"),
  549.     ngx_null_string
  550. };


  553. ‌static ngx_http_variable_t  ngx_http_grpc_vars[] = {

  555.     { ngx_string("grpc_internal_trailers"), NULL,
  556.       ngx_http_grpc_internal_trailers_variable, 0,
  557.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  559.       ngx_http_null_variable
  560. };


  563. static ngx_int_t
  564. ‌ngx_http_grpc_handler(ngx_http_request_t *r)
  565. {
  566.     ngx_int_t                  rc;
  567.     ngx_http_upstream_t       *u;
  568.     ngx_http_grpc_ctx_t       *ctx;
  569.     ngx_http_grpc_loc_conf_t  *glcf;

  571.     if (ngx_http_upstream_create(r) != NGX_OK) {
  572.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  573.     }

  575.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_grpc_ctx_t));
  576.     if (ctx == NULL) {
  577.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  578.     }

  580.     ctx->request = r;

  582.     ngx_http_set_ctx(r, ctx, ngx_http_grpc_module);

  584.     glcf = ngx_http_get_module_loc_conf(r, ngx_http_grpc_module);

  586.     u = r->upstream;

  588.     if (glcf->grpc_lengths == NULL) {
  589.         ctx->host = glcf->host;

  591. #if (NGX_HTTP_SSL)
  592.         u->ssl = glcf->ssl;

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

  597.         } else {
  598.             ngx_str_set(&u->schema, "grpc://");
  599.         }
  600. #else
  601.         ngx_str_set(&u->schema, "grpc://");
  602. #endif

  604.     } else {
  605.         if (ngx_http_grpc_eval(r, ctx, glcf) != NGX_OK) {
  606.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  607.         }
  608.     }

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

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

  614.     u->create_request = ngx_http_grpc_create_request;
  615.     u->reinit_request = ngx_http_grpc_reinit_request;
  616.     u->process_header = ngx_http_grpc_process_header;
  617.     u->abort_request = ngx_http_grpc_abort_request;
  618.     u->finalize_request = ngx_http_grpc_finalize_request;

  620.     u->input_filter_init = ngx_http_grpc_filter_init;
  621.     u->input_filter = ngx_http_grpc_filter;
  622.     u->input_filter_ctx = ctx;

  624.     r->request_body_no_buffering = 1;

  626.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  628.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  629.         return rc;
  630.     }

  632.     return NGX_DONE;
  633. }


  636. static ngx_int_t
  637. ‌ngx_http_grpc_eval(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  638.     ngx_http_grpc_loc_conf_t *glcf)
  639. {
  640.     size_t                add;
  641.     ngx_url_t             url;
  642.     ngx_http_upstream_t  *u;

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

  646.     if (ngx_http_script_run(r, &url.url, glcf->grpc_lengths->elts, 0,
  647.                             glcf->grpc_values->elts)
  648.         == NULL)
  649.     {
  650.         return NGX_ERROR;
  651.     }

  653.     if (url.url.len > 7
  654.         && ngx_strncasecmp(url.url.data, (u_char *) "grpc://", 7) == 0)
  655.     {
  656.         add = 7;

  658.     } else if (url.url.len > 8
  659.                && ngx_strncasecmp(url.url.data, (u_char *) "grpcs://", 8) == 0)
  660.     {

  662. #if (NGX_HTTP_SSL)
  663.         add = 8;
  664.         r->upstream->ssl = 1;
  665. #else
  666.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  667.                       "grpcs protocol requires SSL support");
  668.         return NGX_ERROR;
  669. #endif

  671.     } else {
  672.         add = 0;
  673.     }

  675.     u = r->upstream;

  677.     if (add) {
  678.         u->schema.len = add;
  679.         u->schema.data = url.url.data;

  681.         url.url.data += add;
  682.         url.url.len -= add;

  684.     } else {
  685.         ngx_str_set(&u->schema, "grpc://");
  686.     }

  688.     url.no_resolve = 1;

  690.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  691.         if (url.err) {
  692.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  693.                           "%s in upstream \"%V\"", url.err, &url.url);
  694.         }

  696.         return NGX_ERROR;
  697.     }

  699.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  700.     if (u->resolved == NULL) {
  701.         return NGX_ERROR;
  702.     }

  704.     if (url.addrs) {
  705.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  706.         u->resolved->socklen = url.addrs[0].socklen;
  707.         u->resolved->name = url.addrs[0].name;
  708.         u->resolved->naddrs = 1;
  709.     }

  711.     u->resolved->host = url.host;
  712.     u->resolved->port = url.port;
  713.     u->resolved->no_port = url.no_port;

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

  717.         if (url.no_port) {
  718.             ctx->host = url.host;

  720.         } else {
  721.             ctx->host.len = url.host.len + 1 + url.port_text.len;
  722.             ctx->host.data = url.host.data;
  723.         }

  725.     } else {
  726.         ngx_str_set(&ctx->host, "localhost");
  727.     }

  729.     return NGX_OK;
  730. }


  733. static ngx_int_t
  734. ‌ngx_http_grpc_create_request(ngx_http_request_t *r)
  735. {
  736.     u_char                       *p, *tmp, *key_tmp, *val_tmp, *headers_frame,
  737.                                  *headers_end;
  738.     size_t                        len, headers_len, tmp_len,
  739.                                   key_len, val_len, uri_len;
  740.     uintptr_t                     escape;
  741.     ngx_buf_t                    *b;
  742.     ngx_str_t                     host;
  743.     ngx_uint_t                    i, next;
  744.     ngx_chain_t                  *cl, *body;
  745.     ngx_list_part_t              *part;
  746.     ngx_table_elt_t              *header;
  747.     ngx_http_grpc_ctx_t          *ctx;
  748.     ngx_http_upstream_t          *u;
  749.     ngx_http_grpc_frame_t        *f;
  750.     ngx_http_script_code_pt       code;
  751.     ngx_http_grpc_loc_conf_t     *glcf;
  752.     ngx_http_script_engine_t      e, le;
  753.     ngx_http_script_len_code_pt   lcode;

  755.     u = r->upstream;

  757.     glcf = ngx_http_get_module_loc_conf(r, ngx_http_grpc_module);

  759.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

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

  764.     headers_len = 0;

  766.     /* :method header */

  768.     if (r->method == NGX_HTTP_GET || r->method == NGX_HTTP_POST) {
  769.         len += 1;
  770.         tmp_len = 0;

  772.     } else {
  773.         if (r->method_name.len > NGX_HTTP_V2_MAX_FIELD) {
  774.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  775.                           "too long http2 method: \"%V\"", &r->method_name);
  776.             return NGX_ERROR;
  777.         }

  779.         len += 1 + NGX_HTTP_V2_INT_OCTETS + r->method_name.len;
  780.         tmp_len = r->method_name.len;
  781.     }

  783.     /* :scheme header */

  785.     len += 1;

  787.     /* :path header */

  789.     if (r->valid_unparsed_uri) {
  790.         escape = 0;
  791.         uri_len = r->unparsed_uri.len;

  793.     } else {
  794.         escape = 2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len,
  795.                                     NGX_ESCAPE_URI);
  796.         uri_len = r->uri.len + escape + sizeof("?") - 1 + r->args.len;
  797.     }

  799.     if (uri_len > NGX_HTTP_V2_MAX_FIELD) {
  800.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  801.                       "too long http2 URI");
  802.         return NGX_ERROR;
  803.     }

  805.     len += 1 + NGX_HTTP_V2_INT_OCTETS + uri_len;

  807.     if (tmp_len < uri_len) {
  808.         tmp_len = uri_len;
  809.     }

  811.     /* :authority header */

  813.     host.len = 0;
  814. #if (NGX_SUPPRESS_WARN)
  815.     host.data = NULL;
  816. #endif

  818.     if (glcf->host_value
  819.         && ngx_http_complex_value(r, glcf->host_value, &host) != NGX_OK)
  820.     {
  821.         return NGX_ERROR;
  822.     }

  824.     if (host.len == 0) {
  825.         host = ctx->host;
  826.     }

  828.     if (host.len > NGX_HTTP_V2_MAX_FIELD) {
  829.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  830.                       "too long http2 host: \"%V\"", &host);
  831.         return NGX_ERROR;
  832.     }

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

  836.     if (tmp_len < host.len) {
  837.         tmp_len = host.len;
  838.     }

  840.     /* other headers */

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

  845.     le.ip = glcf->headers.lengths->elts;
  846.     le.request = r;
  847.     le.flushed = 1;

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

  851.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  852.         key_len = lcode(&le);

  854.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  855.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  856.         }
  857.         le.ip += sizeof(uintptr_t);

  859.         if (val_len == 0) {
  860.             continue;
  861.         }

  863.         if (key_len > NGX_HTTP_V2_MAX_FIELD) {
  864.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  865.                           "too long http2 header name");
  866.             return NGX_ERROR;
  867.         }

  869.         if (val_len > NGX_HTTP_V2_MAX_FIELD) {
  870.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  871.                           "too long http2 header value");
  872.             return NGX_ERROR;
  873.         }

  875.         headers_len += 1 + NGX_HTTP_V2_INT_OCTETS + key_len
  876.                          + NGX_HTTP_V2_INT_OCTETS + val_len;

  878.         if (tmp_len < key_len) {
  879.             tmp_len = key_len;
  880.         }

  882.         if (tmp_len < val_len) {
  883.             tmp_len = val_len;
  884.         }
  885.     }

  887.     len += headers_len;

  889.     if (glcf->upstream.pass_request_headers) {
  890.         part = &r->headers_in.headers.part;
  891.         header = part->elts;

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

  895.             if (i >= part->nelts) {
  896.                 if (part->next == NULL) {
  897.                     break;
  898.                 }

  900.                 part = part->next;
  901.                 header = part->elts;
  902.                 i = 0;
  903.             }

  905.             if (ngx_hash_find(&glcf->headers.hash, header[i].hash,
  906.                               header[i].lowcase_key, header[i].key.len))
  907.             {
  908.                 continue;
  909.             }

  911.             if (header[i].key.len > NGX_HTTP_V2_MAX_FIELD) {
  912.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  913.                               "too long http2 header name: \"%V\"",
  914.                               &header[i].key);
  915.                 return NGX_ERROR;
  916.             }

  918.             if (header[i].value.len > NGX_HTTP_V2_MAX_FIELD) {
  919.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  920.                               "too long http2 header value: \"%V: %V\"",
  921.                               &header[i].key, &header[i].value);
  922.                 return NGX_ERROR;
  923.             }

  925.             len += 1 + NGX_HTTP_V2_INT_OCTETS + header[i].key.len
  926.                      + NGX_HTTP_V2_INT_OCTETS + header[i].value.len;

  928.             if (tmp_len < header[i].key.len) {
  929.                 tmp_len = header[i].key.len;
  930.             }

  932.             if (tmp_len < header[i].value.len) {
  933.                 tmp_len = header[i].value.len;
  934.             }
  935.         }
  936.     }

  938.     /* continuation frames */

  940.     len += sizeof(ngx_http_grpc_frame_t)
  941.            * (len / NGX_HTTP_V2_DEFAULT_FRAME_SIZE);


  944.     b = ngx_create_temp_buf(r->pool, len);
  945.     if (b == NULL) {
  946.         return NGX_ERROR;
  947.     }

  949.     cl = ngx_alloc_chain_link(r->pool);
  950.     if (cl == NULL) {
  951.         return NGX_ERROR;
  952.     }

  954.     cl->buf = b;
  955.     cl->next = NULL;

  957.     tmp = ngx_palloc(r->pool, tmp_len * 3);
  958.     if (tmp == NULL) {
  959.         return NGX_ERROR;
  960.     }

  962.     key_tmp = tmp + tmp_len;
  963.     val_tmp = tmp + 2 * tmp_len;

  965.     /* connection preface */

  967.     b->last = ngx_copy(b->last, ngx_http_grpc_connection_start,
  968.                        sizeof(ngx_http_grpc_connection_start) - 1);

  970.     /* headers frame */

  972.     headers_frame = b->last;

  974.     f = (ngx_http_grpc_frame_t *) b->last;
  975.     b->last += sizeof(ngx_http_grpc_frame_t);

  977.     f->length_0 = 0;
  978.     f->length_1 = 0;
  979.     f->length_2 = 0;
  980.     f->type = NGX_HTTP_V2_HEADERS_FRAME;
  981.     f->flags = 0;
  982.     f->stream_id_0 = 0;
  983.     f->stream_id_1 = 0;
  984.     f->stream_id_2 = 0;
  985.     f->stream_id_3 = 1;

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

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

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

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

  999.     } else {
  1000.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_METHOD_INDEX);
  1001.         b->last = ngx_http_v2_write_value(b->last, r->method_name.data,
  1002.                                           r->method_name.len, tmp);

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

  1008. #if (NGX_HTTP_SSL)
  1009.     if (u->ssl) {
  1010.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTPS_INDEX);

  1012.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1013.                        "grpc header: \":scheme: https\"");
  1014.     } else
  1015. #endif
  1016.     {
  1017.         *b->last++ = ngx_http_v2_indexed(NGX_HTTP_V2_SCHEME_HTTP_INDEX);

  1019.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1020.                        "grpc header: \":scheme: http\"");
  1021.     }

  1023.     if (r->valid_unparsed_uri) {

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

  1028.         } else {
  1029.             *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  1030.             b->last = ngx_http_v2_write_value(b->last, r->unparsed_uri.data,
  1031.                                               r->unparsed_uri.len, tmp);
  1032.         }

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

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

  1040.         if (escape) {
  1041.             p = (u_char *) ngx_escape_uri(p, r->uri.data, r->uri.len,
  1042.                                           NGX_ESCAPE_URI);

  1044.         } else {
  1045.             p = ngx_copy(p, r->uri.data, r->uri.len);
  1046.         }

  1048.         if (r->args.len > 0) {
  1049.             *p++ = '?';
  1050.             p = ngx_copy(p, r->args.data, r->args.len);
  1051.         }

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

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

  1059.     } else {
  1060.         *b->last++ = ngx_http_v2_inc_indexed(NGX_HTTP_V2_PATH_INDEX);
  1061.         b->last = ngx_http_v2_write_value(b->last, r->uri.data,
  1062.                                           r->uri.len, tmp);

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

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

  1071.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1072.                    "grpc header: \":authority: %V\"", &host);

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

  1076.     e.ip = glcf->headers.values->elts;
  1077.     e.request = r;
  1078.     e.flushed = 1;

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

  1082.     headers_end = b->last + headers_len;

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

  1086.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1087.         key_len = lcode(&le);

  1089.         for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1090.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1091.         }
  1092.         le.ip += sizeof(uintptr_t);

  1094.         if (val_len == 0) {
  1095.             e.skip = 1;

  1097.             while (*(uintptr_t *) e.ip) {
  1098.                 code = *(ngx_http_script_code_pt *) e.ip;
  1099.                 code((ngx_http_script_engine_t *) &e);
  1100.             }
  1101.             e.ip += sizeof(uintptr_t);

  1103.             e.skip = 0;

  1105.             continue;
  1106.         }

  1108.         if (headers_end - b->last < 1) {
  1109.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1110.                           "no buffer space in grpc create request");
  1111.             return NGX_ERROR;
  1112.         }

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

  1116.         e.pos = key_tmp;
  1117.         e.end = key_tmp + tmp_len;

  1119.         code = *(ngx_http_script_code_pt *) e.ip;
  1120.         code((ngx_http_script_engine_t *) &e);

  1122.         if (e.status) {
  1123.             return NGX_ERROR;
  1124.         }

  1126.         key_len = e.pos - key_tmp;

  1128.         if (headers_end - b->last
  1129.             < (ssize_t) (NGX_HTTP_V2_INT_OCTETS + key_len))
  1130.         {
  1131.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1132.                           "no buffer space in grpc create request");
  1133.             return NGX_ERROR;
  1134.         }

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

  1138.         e.pos = val_tmp;
  1139.         e.end = val_tmp + tmp_len;

  1141.         while (*(uintptr_t *) e.ip) {
  1142.             code = *(ngx_http_script_code_pt *) e.ip;
  1143.             code((ngx_http_script_engine_t *) &e);
  1144.         }
  1145.         e.ip += sizeof(uintptr_t);

  1147.         if (e.status) {
  1148.             return NGX_ERROR;
  1149.         }

  1151.         val_len = e.pos - val_tmp;

  1153.         if (headers_end - b->last
  1154.             < (ssize_t) (NGX_HTTP_V2_INT_OCTETS + val_len))
  1155.         {
  1156.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1157.                           "no buffer space in grpc create request");
  1158.             return NGX_ERROR;
  1159.         }

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

  1163. #if (NGX_DEBUG)
  1164.         if (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP) {
  1165.             ngx_strlow(key_tmp, key_tmp, key_len);

  1167.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1168.                            "grpc header: \"%*s: %*s\"",
  1169.                            key_len, key_tmp, val_len, val_tmp);
  1170.         }
  1171. #endif
  1172.     }

  1174.     if (glcf->upstream.pass_request_headers) {
  1175.         part = &r->headers_in.headers.part;
  1176.         header = part->elts;

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

  1180.             if (i >= part->nelts) {
  1181.                 if (part->next == NULL) {
  1182.                     break;
  1183.                 }

  1185.                 part = part->next;
  1186.                 header = part->elts;
  1187.                 i = 0;
  1188.             }

  1190.             if (ngx_hash_find(&glcf->headers.hash, header[i].hash,
  1191.                               header[i].lowcase_key, header[i].key.len))
  1192.             {
  1193.                 continue;
  1194.             }

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

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

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

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

  1208.                 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1209.                                "grpc header: \"%*s: %V\"",
  1210.                                header[i].key.len, tmp, &header[i].value);
  1211.             }
  1212. #endif
  1213.         }
  1214.     }

  1216.     /* update headers frame length */

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

  1220.     if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  1221.         len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1222.         next = 1;

  1224.     } else {
  1225.         next = 0;
  1226.     }

  1228.     f = (ngx_http_grpc_frame_t *) headers_frame;

  1230.     f->length_0 = (u_char) ((len >> 16) & 0xff);
  1231.     f->length_1 = (u_char) ((len >> 8) & 0xff);
  1232.     f->length_2 = (u_char) (len & 0xff);

  1234.     /* create additional continuation frames */

  1236.     p = headers_frame;

  1238.     while (next) {
  1239.         p += sizeof(ngx_http_grpc_frame_t) + NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1240.         len = b->last - p;

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

  1245.         if (len > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  1246.             len = NGX_HTTP_V2_DEFAULT_FRAME_SIZE;
  1247.             next = 1;

  1249.         } else {
  1250.             next = 0;
  1251.         }

  1253.         f = (ngx_http_grpc_frame_t *) p;

  1255.         f->length_0 = (u_char) ((len >> 16) & 0xff);
  1256.         f->length_1 = (u_char) ((len >> 8) & 0xff);
  1257.         f->length_2 = (u_char) (len & 0xff);
  1258.         f->type = NGX_HTTP_V2_CONTINUATION_FRAME;
  1259.         f->flags = 0;
  1260.         f->stream_id_0 = 0;
  1261.         f->stream_id_1 = 0;
  1262.         f->stream_id_2 = 0;
  1263.         f->stream_id_3 = 1;
  1264.     }

  1266.     f->flags |= NGX_HTTP_V2_END_HEADERS_FLAG;

  1268.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1269.                    "grpc header: %*xs%s, len: %uz",
  1270.                    (size_t) ngx_min(b->last - b->pos, 256), b->pos,
  1271.                    b->last - b->pos > 256 ? "..." : "",
  1272.                    b->last - b->pos);

  1274.     if (r->request_body_no_buffering) {

  1276.         u->request_bufs = cl;

  1278.     } else {

  1280.         body = u->request_bufs;
  1281.         u->request_bufs = cl;

  1283.         if (body == NULL) {
  1284.             f = (ngx_http_grpc_frame_t *) headers_frame;
  1285.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;
  1286.         }

  1288.         while (body) {
  1289.             b = ngx_alloc_buf(r->pool);
  1290.             if (b == NULL) {
  1291.                 return NGX_ERROR;
  1292.             }

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

  1296.             cl->next = ngx_alloc_chain_link(r->pool);
  1297.             if (cl->next == NULL) {
  1298.                 return NGX_ERROR;
  1299.             }

  1301.             cl = cl->next;
  1302.             cl->buf = b;

  1304.             body = body->next;
  1305.         }

  1307.         b->last_buf = 1;
  1308.     }

  1310.     u->output.output_filter = ngx_http_grpc_body_output_filter;
  1311.     u->output.filter_ctx = r;

  1313.     b->flush = 1;
  1314.     cl->next = NULL;

  1316.     return NGX_OK;
  1317. }


  1320. static ngx_int_t
  1321. ‌ngx_http_grpc_reinit_request(ngx_http_request_t *r)
  1322. {
  1323.     ngx_http_grpc_ctx_t  *ctx;

  1325.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

  1327.     if (ctx == NULL) {
  1328.         return NGX_OK;
  1329.     }

  1331.     ctx->state = 0;
  1332.     ctx->header_sent = 0;
  1333.     ctx->output_closed = 0;
  1334.     ctx->output_blocked = 0;
  1335.     ctx->parsing_headers = 0;
  1336.     ctx->end_stream = 0;
  1337.     ctx->done = 0;
  1338.     ctx->status = 0;
  1339.     ctx->rst = 0;
  1340.     ctx->goaway = 0;
  1341.     ctx->connection = NULL;
  1342.     ctx->in = NULL;
  1343.     ctx->busy = NULL;
  1344.     ctx->out = NULL;

  1346.     return NGX_OK;
  1347. }


  1350. static ngx_int_t
  1351. ‌ngx_http_grpc_body_output_filter(void *data, ngx_chain_t *in)
  1352. {
  1353.     ngx_http_request_t  *r = data;

  1355.     off_t                   file_pos;
  1356.     u_char                 *p, *pos, *start;
  1357.     size_t                  len, limit;
  1358.     ngx_buf_t              *b;
  1359.     ngx_int_t               rc;
  1360.     ngx_uint_t              next, last;
  1361.     ngx_chain_t            *cl, *out, *ln, **ll;
  1362.     ngx_http_upstream_t    *u;
  1363.     ngx_http_grpc_ctx_t    *ctx;
  1364.     ngx_http_grpc_frame_t  *f;

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

  1369.     ctx = ngx_http_grpc_get_ctx(r);

  1371.     if (ctx == NULL) {
  1372.         return NGX_ERROR;
  1373.     }

  1375.     if (in) {
  1376.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  1377.             return NGX_ERROR;
  1378.         }
  1379.     }

  1381.     out = NULL;
  1382.     ll = &out;

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

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

  1390.         ctx->header_sent = 1;

  1392.         if (ctx->id != 1) {
  1393.             /*
  1394.              * keepalive connection: skip connection preface,
  1395.              * update stream identifiers
  1396.              */

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

  1401.             p = b->pos;

  1403.             while (p < b->last) {
  1404.                 f = (ngx_http_grpc_frame_t *) p;
  1405.                 p += sizeof(ngx_http_grpc_frame_t);

  1407.                 f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1408.                 f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1409.                 f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1410.                 f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1412.                 p += (f->length_0 << 16) + (f->length_1 << 8) + f->length_2;
  1413.             }
  1414.         }

  1416.         if (ctx->in->buf->last_buf) {
  1417.             ctx->output_closed = 1;
  1418.         }

  1420.         *ll = ctx->in;
  1421.         ll = &ctx->in->next;

  1423.         ctx->in = ctx->in->next;
  1424.     }

  1426.     if (ctx->out) {
  1427.         /* queued control frames */

  1429.         *ll = ctx->out;

  1431.         for (cl = ctx->out, ll = &cl->next; cl; cl = cl->next) {
  1432.             ll = &cl->next;
  1433.         }

  1435.         ctx->out = NULL;
  1436.     }

  1438.     f = NULL;
  1439.     last = 0;

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

  1443.     if (limit > ctx->connection->send_window) {
  1444.         limit = ctx->connection->send_window;
  1445.     }

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

  1451. #if (NGX_SUPPRESS_WARN)
  1452.     file_pos = 0;
  1453.     pos = NULL;
  1454.     cl = NULL;
  1455. #endif

  1457.     in = ctx->in;

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

  1461.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1462.                        "grpc output in  l:%d f:%d %p, pos %p, size: %z "
  1463.                        "file: %O, size: %O",
  1464.                        in->buf->last_buf,
  1465.                        in->buf->in_file,
  1466.                        in->buf->start, in->buf->pos,
  1467.                        in->buf->last - in->buf->pos,
  1468.                        in->buf->file_pos,
  1469.                        in->buf->file_last - in->buf->file_pos);

  1471.         if (ngx_buf_special(in->buf)) {
  1472.             goto next;
  1473.         }

  1475.         if (in->buf->in_file) {
  1476.             file_pos = in->buf->file_pos;

  1478.         } else {
  1479.             pos = in->buf->pos;
  1480.         }

  1482.         next = 0;

  1484.         do {

  1486.             cl = ngx_http_grpc_get_buf(r, ctx);
  1487.             if (cl == NULL) {
  1488.                 return NGX_ERROR;
  1489.             }

  1491.             b = cl->buf;

  1493.             f = (ngx_http_grpc_frame_t *) b->last;
  1494.             b->last += sizeof(ngx_http_grpc_frame_t);

  1496.             *ll = cl;
  1497.             ll = &cl->next;

  1499.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  1500.             if (cl == NULL) {
  1501.                 return NGX_ERROR;
  1502.             }

  1504.             b = cl->buf;
  1505.             start = b->start;

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

  1509.             /*
  1510.              * restore b->start to preserve memory allocated in the buffer,
  1511.              * to reuse it later for headers and control frames
  1512.              */

  1514.             b->start = start;

  1516.             if (in->buf->in_file) {
  1517.                 b->file_pos = file_pos;
  1518.                 file_pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1520.                 if (file_pos >= in->buf->file_last) {
  1521.                     file_pos = in->buf->file_last;
  1522.                     next = 1;
  1523.                 }

  1525.                 b->file_last = file_pos;
  1526.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1528.             } else {
  1529.                 b->pos = pos;
  1530.                 pos += ngx_min(NGX_HTTP_V2_DEFAULT_FRAME_SIZE, limit);

  1532.                 if (pos >= in->buf->last) {
  1533.                     pos = in->buf->last;
  1534.                     next = 1;
  1535.                 }

  1537.                 b->last = pos;
  1538.                 len = (ngx_uint_t) (pos - b->pos);
  1539.             }

  1541.             b->tag = (ngx_buf_tag_t) &ngx_http_grpc_body_output_filter;
  1542.             b->shadow = in->buf;
  1543.             b->last_shadow = next;

  1545.             b->last_buf = 0;
  1546.             b->last_in_chain = 0;

  1548.             *ll = cl;
  1549.             ll = &cl->next;

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

  1561.             limit -= len;
  1562.             ctx->send_window -= len;
  1563.             ctx->connection->send_window -= len;

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

  1567.         if (!next) {
  1568.             /*
  1569.              * if the buffer wasn't fully sent due to flow control limits,
  1570.              * preserve position for future use
  1571.              */

  1573.             if (in->buf->in_file) {
  1574.                 in->buf->file_pos = file_pos;

  1576.             } else {
  1577.                 in->buf->pos = pos;
  1578.             }

  1580.             break;
  1581.         }

  1583.     next:

  1585.         if (in->buf->last_buf) {
  1586.             last = 1;
  1587.         }

  1589.         ln = in;
  1590.         in = in->next;

  1592.         ngx_free_chain(r->pool, ln);
  1593.     }

  1595.     ctx->in = in;

  1597.     if (last) {

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

  1602.         ctx->output_closed = 1;

  1604.         if (f) {
  1605.             f->flags |= NGX_HTTP_V2_END_STREAM_FLAG;

  1607.         } else {
  1608.             cl = ngx_http_grpc_get_buf(r, ctx);
  1609.             if (cl == NULL) {
  1610.                 return NGX_ERROR;
  1611.             }

  1613.             b = cl->buf;

  1615.             f = (ngx_http_grpc_frame_t *) b->last;
  1616.             b->last += sizeof(ngx_http_grpc_frame_t);

  1618.             f->length_0 = 0;
  1619.             f->length_1 = 0;
  1620.             f->length_2 = 0;
  1621.             f->type = NGX_HTTP_V2_DATA_FRAME;
  1622.             f->flags = NGX_HTTP_V2_END_STREAM_FLAG;
  1623.             f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  1624.             f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  1625.             f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  1626.             f->stream_id_3 = (u_char) (ctx->id & 0xff);

  1628.             *ll = cl;
  1629.             ll = &cl->next;
  1630.         }

  1632.         cl->buf->last_buf = 1;
  1633.     }

  1635.     *ll = NULL;

  1637. #if (NGX_DEBUG)

  1639.     for (cl = out; cl; cl = cl->next) {
  1640.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1641.                        "grpc output out l:%d f:%d %p, pos %p, size: %z "
  1642.                        "file: %O, size: %O",
  1643.                        cl->buf->last_buf,
  1644.                        cl->buf->in_file,
  1645.                        cl->buf->start, cl->buf->pos,
  1646.                        cl->buf->last - cl->buf->pos,
  1647.                        cl->buf->file_pos,
  1648.                        cl->buf->file_last - cl->buf->file_pos);
  1649.     }

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

  1655. #endif

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

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

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

  1664.         /* mark original buffers as sent */

  1666.         if (cl->buf->shadow) {
  1667.             if (cl->buf->last_shadow) {
  1668.                 b = cl->buf->shadow;
  1669.                 b->pos = b->last;
  1670.             }

  1672.             cl->buf->shadow = NULL;
  1673.         }
  1674.     }

  1676.     if (rc == NGX_OK && ctx->in) {
  1677.         rc = NGX_AGAIN;
  1678.     }

  1680.     if (rc == NGX_AGAIN) {
  1681.         ctx->output_blocked = 1;

  1683.     } else {
  1684.         ctx->output_blocked = 0;
  1685.     }

  1687.     if (ctx->done) {

  1689.         /*
  1690.          * We have already got the response and were sending some additional
  1691.          * control frames.  Even if there is still something unsent, stop
  1692.          * here anyway.
  1693.          */

  1695.         u = r->upstream;
  1696.         u->length = 0;

  1698.         if (ctx->in == NULL
  1699.             && ctx->out == NULL
  1700.             && ctx->output_closed
  1701.             && !ctx->output_blocked
  1702.             && !ctx->goaway
  1703.             && ctx->state == ngx_http_grpc_st_start)
  1704.         {
  1705.             u->keepalive = 1;
  1706.         }

  1708.         ngx_post_event(u->peer.connection->read, &ngx_posted_events);
  1709.     }

  1711.     return rc;
  1712. }


  1715. static ngx_int_t
  1716. ‌ngx_http_grpc_process_header(ngx_http_request_t *r)
  1717. {
  1718.     ngx_str_t                      *status_line;
  1719.     ngx_int_t                       rc, status;
  1720.     ngx_buf_t                      *b;
  1721.     ngx_table_elt_t                *h;
  1722.     ngx_http_upstream_t            *u;
  1723.     ngx_http_grpc_ctx_t            *ctx;
  1724.     ngx_http_upstream_header_t     *hh;
  1725.     ngx_http_upstream_main_conf_t  *umcf;

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

  1730.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1731.                    "grpc response: %*xs%s, len: %uz",
  1732.                    (size_t) ngx_min(b->last - b->pos, 256),
  1733.                    b->pos, b->last - b->pos > 256 ? "..." : "",
  1734.                    b->last - b->pos);

  1736.     ctx = ngx_http_grpc_get_ctx(r);

  1738.     if (ctx == NULL) {
  1739.         return NGX_ERROR;
  1740.     }

  1742.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1744.     for ( ;; ) {

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

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

  1750.             if (rc == NGX_AGAIN) {

  1752.                 /*
  1753.                  * there can be a lot of window update frames,
  1754.                  * so we reset buffer if it is empty and we haven't
  1755.                  * started parsing headers yet
  1756.                  */

  1758.                 if (!ctx->parsing_headers) {
  1759.                     b->pos = b->start;
  1760.                     b->last = b->pos;
  1761.                 }

  1763.                 return NGX_AGAIN;
  1764.             }

  1766.             if (rc == NGX_ERROR) {
  1767.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1768.             }

  1770.             /*
  1771.              * RFC 7540 says that implementations MUST discard frames
  1772.              * that have unknown or unsupported types.  However, extension
  1773.              * frames that appear in the middle of a header block are
  1774.              * not permitted.  Also, for obvious reasons CONTINUATION frames
  1775.              * cannot appear before headers, and DATA frames are not expected
  1776.              * to appear before all headers are parsed.
  1777.              */

  1779.             if (ctx->type == NGX_HTTP_V2_DATA_FRAME
  1780.                 || (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  1781.                     && !ctx->parsing_headers)
  1782.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  1783.                     && ctx->parsing_headers))
  1784.             {
  1785.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1786.                               "upstream sent unexpected http2 frame: %d",
  1787.                               ctx->type);
  1788.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1789.             }

  1791.             if (ctx->stream_id && ctx->stream_id != ctx->id) {
  1792.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1793.                               "upstream sent frame for unknown stream %ui",
  1794.                               ctx->stream_id);
  1795.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1796.             }
  1797.         }

  1799.         /* frame payload */

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

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

  1805.             if (rc == NGX_AGAIN) {
  1806.                 return NGX_AGAIN;
  1807.             }

  1809.             if (rc == NGX_ERROR) {
  1810.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1811.             }

  1813.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1814.                           "upstream rejected request with error %ui",
  1815.                           ctx->error);

  1817.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1818.         }

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

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

  1824.             if (rc == NGX_AGAIN) {
  1825.                 return NGX_AGAIN;
  1826.             }

  1828.             if (rc == NGX_ERROR) {
  1829.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1830.             }

  1832.             /*
  1833.              * If stream_id is lower than one we use, our
  1834.              * request won't be processed and needs to be retried.
  1835.              * If stream_id is greater or equal to the one we use,
  1836.              * we can continue normally (except we can't use this
  1837.              * connection for additional requests).  If there is
  1838.              * a real error, the connection will be closed.
  1839.              */

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

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

  1845.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1846.                               "upstream sent goaway with error %ui",
  1847.                               ctx->error);

  1849.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1850.             }

  1852.             ctx->goaway = 1;

  1854.             continue;
  1855.         }

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

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

  1861.             if (rc == NGX_AGAIN) {
  1862.                 return NGX_AGAIN;
  1863.             }

  1865.             if (rc == NGX_ERROR) {
  1866.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1867.             }

  1869.             if (ctx->in) {
  1870.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1871.             }

  1873.             continue;
  1874.         }

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

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

  1880.             if (rc == NGX_AGAIN) {
  1881.                 return NGX_AGAIN;
  1882.             }

  1884.             if (rc == NGX_ERROR) {
  1885.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1886.             }

  1888.             if (ctx->in) {
  1889.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1890.             }

  1892.             continue;
  1893.         }

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

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

  1899.             if (rc == NGX_AGAIN) {
  1900.                 return NGX_AGAIN;
  1901.             }

  1903.             if (rc == NGX_ERROR) {
  1904.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1905.             }

  1907.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  1908.             continue;
  1909.         }

  1911.         if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  1912.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1913.                           "upstream sent unexpected push promise frame");
  1914.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1915.         }

  1917.         if (ctx->type != NGX_HTTP_V2_HEADERS_FRAME
  1918.             && ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME)
  1919.         {
  1920.             /* priority, unknown frames */

  1922.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  1923.                 ctx->rest -= b->last - b->pos;
  1924.                 b->pos = b->last;
  1925.                 return NGX_AGAIN;
  1926.             }

  1928.             b->pos += ctx->rest;
  1929.             ctx->rest = 0;
  1930.             ctx->state = ngx_http_grpc_st_start;

  1932.             continue;
  1933.         }

  1935.         /* headers */

  1937.         for ( ;; ) {

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

  1941.             if (rc == NGX_AGAIN) {
  1942.                 break;
  1943.             }

  1945.             if (rc == NGX_OK) {

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

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

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

  1955.                     if (ctx->name.len != sizeof(":status") - 1
  1956.                         || ngx_strncmp(ctx->name.data, ":status",
  1957.                                        sizeof(":status") - 1)
  1958.                            != 0)
  1959.                     {
  1960.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1961.                                       "upstream sent invalid header \"%V: %V\"",
  1962.                                       &ctx->name, &ctx->value);
  1963.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1964.                     }

  1966.                     if (ctx->status) {
  1967.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1968.                                       "upstream sent duplicate :status header");
  1969.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1970.                     }

  1972.                     status_line = &ctx->value;

  1974.                     if (status_line->len != 3) {
  1975.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1976.                                       "upstream sent invalid :status \"%V\"",
  1977.                                       status_line);
  1978.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1979.                     }

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

  1983.                     if (status == NGX_ERROR) {
  1984.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1985.                                       "upstream sent invalid :status \"%V\"",
  1986.                                       status_line);
  1987.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1988.                     }

  1990.                     if (status < NGX_HTTP_OK && status != NGX_HTTP_EARLY_HINTS)
  1991.                     {
  1992.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1993.                                       "upstream sent unexpected :status \"%V\"",
  1994.                                       status_line);
  1995.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1996.                     }

  1998.                     u->headers_in.status_n = status;

  2000.                     if (u->state && u->state->status == 0) {
  2001.                         u->state->status = status;
  2002.                     }

  2004.                     ctx->status = 1;

  2006.                     continue;

  2008.                 } else if (!ctx->status) {
  2009.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2010.                                   "upstream sent no :status header");
  2011.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2012.                 }

  2014.                 h = ngx_list_push(&u->headers_in.headers);
  2015.                 if (h == NULL) {
  2016.                     return NGX_ERROR;
  2017.                 }

  2019.                 h->key = ctx->name;
  2020.                 h->value = ctx->value;
  2021.                 h->lowcase_key = h->key.data;
  2022.                 h->hash = ngx_hash_key(h->key.data, h->key.len);

  2024.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  2025.                     continue;
  2026.                 }

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

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

  2034.                     if (rc != NGX_OK) {
  2035.                         return rc;
  2036.                     }
  2037.                 }

  2039.                 continue;
  2040.             }

  2042.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2049.                 if (u->headers_in.status_n == NGX_HTTP_EARLY_HINTS) {
  2050.                     if (ctx->end_stream) {
  2051.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2052.                                       "upstream prematurely closed stream");
  2053.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2054.                     }

  2056.                     ctx->status = 0;
  2057.                     return NGX_HTTP_UPSTREAM_EARLY_HINTS;
  2058.                 }

  2060.                 if (ctx->end_stream) {

  2062.                     if (u->headers_in.content_length_n == -1) {
  2063.                         u->headers_in.content_length_n = 0;
  2064.                     }

  2066.                     if (ctx->in == NULL
  2067.                         && ctx->out == NULL
  2068.                         && ctx->output_closed
  2069.                         && !ctx->output_blocked
  2070.                         && !ctx->goaway
  2071.                         && b->last == b->pos)
  2072.                     {
  2073.                         u->keepalive = 1;
  2074.                     }
  2075.                 }

  2077.                 return NGX_OK;
  2078.             }

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

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

  2085.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2086.         }

  2088.         /* rc == NGX_AGAIN */

  2090.         if (ctx->rest == 0) {
  2091.             ctx->state = ngx_http_grpc_st_start;
  2092.             continue;
  2093.         }

  2095.         return NGX_AGAIN;
  2096.     }
  2097. }


  2100. static ngx_int_t
  2101. ‌ngx_http_grpc_filter_init(void *data)
  2102. {
  2103.     ngx_http_grpc_ctx_t  *ctx = data;

  2105.     ngx_http_request_t   *r;
  2106.     ngx_http_upstream_t  *u;

  2108.     r = ctx->request;
  2109.     u = r->upstream;

  2111.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  2112.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED
  2113.         || r->method == NGX_HTTP_HEAD)
  2114.     {
  2115.         ctx->length = 0;

  2117.     } else {
  2118.         ctx->length = u->headers_in.content_length_n;
  2119.     }

  2121.     if (ctx->end_stream) {

  2123.         if (ctx->length > 0) {
  2124.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2125.                           "upstream prematurely closed stream");
  2126.             return NGX_ERROR;
  2127.         }

  2129.         u->length = 0;
  2130.         ctx->done = 1;

  2132.     } else {
  2133.         u->length = 1;
  2134.     }

  2136.     return NGX_OK;
  2137. }


  2140. static ngx_int_t
  2141. ‌ngx_http_grpc_filter(void *data, ssize_t bytes)
  2142. {
  2143.     ngx_http_grpc_ctx_t  *ctx = data;

  2145.     ngx_int_t             rc;
  2146.     ngx_buf_t            *b, *buf;
  2147.     ngx_chain_t          *cl, **ll;
  2148.     ngx_table_elt_t      *h;
  2149.     ngx_http_request_t   *r;
  2150.     ngx_http_upstream_t  *u;

  2152.     r = ctx->request;
  2153.     u = r->upstream;
  2154.     b = &u->buffer;

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

  2159.     b->pos = b->last;
  2160.     b->last += bytes;

  2162.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  2163.         ll = &cl->next;
  2164.     }

  2166.     for ( ;; ) {

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

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

  2172.             if (rc == NGX_AGAIN) {

  2174.                 if (ctx->done) {

  2176.                     if (ctx->length > 0) {
  2177.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2178.                                       "upstream prematurely closed stream");
  2179.                         return NGX_ERROR;
  2180.                     }

  2182.                     /*
  2183.                      * We have finished parsing the response and the
  2184.                      * remaining control frames.  If there are unsent
  2185.                      * control frames, post a write event to send them.
  2186.                      */

  2188.                     if (ctx->out) {
  2189.                         ngx_post_event(u->peer.connection->write,
  2190.                                        &ngx_posted_events);
  2191.                         return NGX_AGAIN;
  2192.                     }

  2194.                     u->length = 0;

  2196.                     if (ctx->in == NULL
  2197.                         && ctx->output_closed
  2198.                         && !ctx->output_blocked
  2199.                         && !ctx->goaway
  2200.                         && ctx->state == ngx_http_grpc_st_start)
  2201.                     {
  2202.                         u->keepalive = 1;
  2203.                     }

  2205.                     break;
  2206.                 }

  2208.                 return NGX_AGAIN;
  2209.             }

  2211.             if (rc == NGX_ERROR) {
  2212.                 return NGX_ERROR;
  2213.             }

  2215.             if ((ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME
  2216.                  && !ctx->parsing_headers)
  2217.                 || (ctx->type != NGX_HTTP_V2_CONTINUATION_FRAME
  2218.                     && ctx->parsing_headers))
  2219.             {
  2220.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2221.                               "upstream sent unexpected http2 frame: %d",
  2222.                               ctx->type);
  2223.                 return NGX_ERROR;
  2224.             }

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

  2228.                 if (ctx->stream_id != ctx->id) {
  2229.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2230.                                   "upstream sent data frame "
  2231.                                   "for unknown stream %ui",
  2232.                                   ctx->stream_id);
  2233.                     return NGX_ERROR;
  2234.                 }

  2236.                 if (ctx->rest > ctx->recv_window) {
  2237.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2238.                                   "upstream violated stream flow control, "
  2239.                                   "received %uz data frame with window %uz",
  2240.                                   ctx->rest, ctx->recv_window);
  2241.                     return NGX_ERROR;
  2242.                 }

  2244.                 if (ctx->rest > ctx->connection->recv_window) {
  2245.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2246.                                   "upstream violated connection flow control, "
  2247.                                   "received %uz data frame with window %uz",
  2248.                                   ctx->rest, ctx->connection->recv_window);
  2249.                     return NGX_ERROR;
  2250.                 }

  2252.                 ctx->recv_window -= ctx->rest;
  2253.                 ctx->connection->recv_window -= ctx->rest;

  2255.                 if (ctx->connection->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4
  2256.                     || ctx->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4)
  2257.                 {
  2258.                     if (ngx_http_grpc_send_window_update(r, ctx) != NGX_OK) {
  2259.                         return NGX_ERROR;
  2260.                     }

  2262.                     ngx_post_event(u->peer.connection->write,
  2263.                                    &ngx_posted_events);
  2264.                 }
  2265.             }

  2267.             if (ctx->stream_id && ctx->stream_id != ctx->id) {
  2268.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2269.                               "upstream sent frame for unknown stream %ui",
  2270.                               ctx->stream_id);
  2271.                 return NGX_ERROR;
  2272.             }

  2274.             if (ctx->stream_id && ctx->done
  2275.                 && ctx->type != NGX_HTTP_V2_RST_STREAM_FRAME
  2276.                 && ctx->type != NGX_HTTP_V2_WINDOW_UPDATE_FRAME)
  2277.             {
  2278.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2279.                               "upstream sent frame for closed stream %ui",
  2280.                               ctx->stream_id);
  2281.                 return NGX_ERROR;
  2282.             }

  2284.             ctx->padding = 0;
  2285.         }

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

  2289.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2290.                 ctx->rest -= b->last - b->pos;
  2291.                 b->pos = b->last;
  2292.                 return NGX_AGAIN;
  2293.             }

  2295.             b->pos += ctx->rest;
  2296.             ctx->rest = 0;
  2297.             ctx->state = ngx_http_grpc_st_start;

  2299.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2300.                 ctx->done = 1;
  2301.             }

  2303.             continue;
  2304.         }

  2306.         /* frame payload */

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

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

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

  2316.             if (rc == NGX_ERROR) {
  2317.                 return NGX_ERROR;
  2318.             }

  2320.             if (ctx->error || !ctx->done) {
  2321.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2322.                               "upstream rejected request with error %ui",
  2323.                               ctx->error);
  2324.                 return NGX_ERROR;
  2325.             }

  2327.             if (ctx->rst) {
  2328.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2329.                               "upstream sent frame for closed stream %ui",
  2330.                               ctx->stream_id);
  2331.                 return NGX_ERROR;
  2332.             }

  2334.             ctx->rst = 1;

  2336.             continue;
  2337.         }

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

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

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

  2347.             if (rc == NGX_ERROR) {
  2348.                 return NGX_ERROR;
  2349.             }

  2351.             /*
  2352.              * If stream_id is lower than one we use, our
  2353.              * request won't be processed and needs to be retried.
  2354.              * If stream_id is greater or equal to the one we use,
  2355.              * we can continue normally (except we can't use this
  2356.              * connection for additional requests).  If there is
  2357.              * a real error, the connection will be closed.
  2358.              */

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

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

  2364.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2365.                               "upstream sent goaway with error %ui",
  2366.                               ctx->error);

  2368.                 return NGX_ERROR;
  2369.             }

  2371.             ctx->goaway = 1;

  2373.             continue;
  2374.         }

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

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

  2380.             if (rc == NGX_AGAIN) {
  2381.                 return NGX_AGAIN;
  2382.             }

  2384.             if (rc == NGX_ERROR) {
  2385.                 return NGX_ERROR;
  2386.             }

  2388.             if (ctx->in) {
  2389.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2390.             }

  2392.             continue;
  2393.         }

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

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

  2399.             if (rc == NGX_AGAIN) {
  2400.                 return NGX_AGAIN;
  2401.             }

  2403.             if (rc == NGX_ERROR) {
  2404.                 return NGX_ERROR;
  2405.             }

  2407.             if (ctx->in) {
  2408.                 ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2409.             }

  2411.             continue;
  2412.         }

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

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

  2418.             if (rc == NGX_AGAIN) {
  2419.                 return NGX_AGAIN;
  2420.             }

  2422.             if (rc == NGX_ERROR) {
  2423.                 return NGX_ERROR;
  2424.             }

  2426.             ngx_post_event(u->peer.connection->write, &ngx_posted_events);
  2427.             continue;
  2428.         }

  2430.         if (ctx->type == NGX_HTTP_V2_PUSH_PROMISE_FRAME) {
  2431.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2432.                           "upstream sent unexpected push promise frame");
  2433.             return NGX_ERROR;
  2434.         }

  2436.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME
  2437.             || ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME)
  2438.         {
  2439.             for ( ;; ) {

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

  2443.                 if (rc == NGX_AGAIN) {
  2444.                     break;
  2445.                 }

  2447.                 if (rc == NGX_OK) {

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

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

  2455.                     if (ctx->name.len && ctx->name.data[0] == ':') {
  2456.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2457.                                       "upstream sent invalid "
  2458.                                       "trailer \"%V: %V\"",
  2459.                                       &ctx->name, &ctx->value);
  2460.                         return NGX_ERROR;
  2461.                     }

  2463.                     h = ngx_list_push(&u->headers_in.trailers);
  2464.                     if (h == NULL) {
  2465.                         return NGX_ERROR;
  2466.                     }

  2468.                     h->key = ctx->name;
  2469.                     h->value = ctx->value;
  2470.                     h->lowcase_key = h->key.data;
  2471.                     h->hash = ngx_hash_key(h->key.data, h->key.len);

  2473.                     continue;
  2474.                 }

  2476.                 if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2483.                     if (ctx->end_stream) {
  2484.                         ctx->done = 1;
  2485.                         break;
  2486.                     }

  2488.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2489.                                   "upstream sent trailer without "
  2490.                                   "end stream flag");
  2491.                     return NGX_ERROR;
  2492.                 }

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

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

  2499.                 return NGX_ERROR;
  2500.             }

  2502.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2503.                 continue;
  2504.             }

  2506.             /* rc == NGX_AGAIN */

  2508.             if (ctx->rest == 0) {
  2509.                 ctx->state = ngx_http_grpc_st_start;
  2510.                 continue;
  2511.             }

  2513.             return NGX_AGAIN;
  2514.         }

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

  2518.             /* priority, unknown frames */

  2520.             if (b->last - b->pos < (ssize_t) ctx->rest) {
  2521.                 ctx->rest -= b->last - b->pos;
  2522.                 b->pos = b->last;
  2523.                 return NGX_AGAIN;
  2524.             }

  2526.             b->pos += ctx->rest;
  2527.             ctx->rest = 0;
  2528.             ctx->state = ngx_http_grpc_st_start;

  2530.             continue;
  2531.         }

  2533.         /*
  2534.          * data frame:
  2535.          *
  2536.          * +---------------+
  2537.          * |Pad Length? (8)|
  2538.          * +---------------+-----------------------------------------------+
  2539.          * |                            Data (*)                         ...
  2540.          * +---------------------------------------------------------------+
  2541.          * |                           Padding (*)                       ...
  2542.          * +---------------------------------------------------------------+
  2543.          */

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

  2547.             if (ctx->rest == 0) {
  2548.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2549.                               "upstream sent too short http2 frame");
  2550.                 return NGX_ERROR;
  2551.             }

  2553.             if (b->pos == b->last) {
  2554.                 return NGX_AGAIN;
  2555.             }

  2557.             ctx->flags &= ~NGX_HTTP_V2_PADDED_FLAG;
  2558.             ctx->padding = *b->pos++;
  2559.             ctx->rest -= 1;

  2561.             if (ctx->padding > ctx->rest) {
  2562.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2563.                               "upstream sent http2 frame with too long "
  2564.                               "padding: %d in frame %uz",
  2565.                               ctx->padding, ctx->rest);
  2566.                 return NGX_ERROR;
  2567.             }

  2569.             continue;
  2570.         }

  2572.         if (ctx->rest == ctx->padding) {
  2573.             goto done;
  2574.         }

  2576.         if (b->pos == b->last) {
  2577.             return NGX_AGAIN;
  2578.         }

  2580.         cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  2581.         if (cl == NULL) {
  2582.             return NGX_ERROR;
  2583.         }

  2585.         *ll = cl;
  2586.         ll = &cl->next;

  2588.         buf = cl->buf;

  2590.         buf->flush = 1;
  2591.         buf->memory = 1;

  2593.         buf->pos = b->pos;
  2594.         buf->tag = u->output.tag;

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

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

  2601.             ctx->rest -= b->last - b->pos;
  2602.             b->pos = b->last;
  2603.             buf->last = b->pos;

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

  2607.                 if (buf->last - buf->pos > ctx->length) {
  2608.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2609.                                   "upstream sent response body larger "
  2610.                                   "than indicated content length");
  2611.                     return NGX_ERROR;
  2612.                 }

  2614.                 ctx->length -= buf->last - buf->pos;
  2615.             }

  2617.             return NGX_AGAIN;
  2618.         }

  2620.         b->pos += ctx->rest - ctx->padding;
  2621.         buf->last = b->pos;
  2622.         ctx->rest = ctx->padding;

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

  2626.             if (buf->last - buf->pos > ctx->length) {
  2627.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2628.                               "upstream sent response body larger "
  2629.                               "than indicated content length");
  2630.                 return NGX_ERROR;
  2631.             }

  2633.             ctx->length -= buf->last - buf->pos;
  2634.         }

  2636.     done:

  2638.         if (ctx->padding) {
  2639.             ctx->state = ngx_http_grpc_st_padding;
  2640.             continue;
  2641.         }

  2643.         ctx->state = ngx_http_grpc_st_start;

  2645.         if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2646.             ctx->done = 1;
  2647.         }
  2648.     }

  2650.     return NGX_OK;
  2651. }


  2654. static ngx_int_t
  2655. ‌ngx_http_grpc_parse_frame(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2656.     ngx_buf_t *b)
  2657. {
  2658.     u_char                 ch, *p;
  2659.     ngx_http_grpc_state_e  state;

  2661.     state = ctx->state;

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

  2666. #if 0
  2667.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2668.                        "grpc frame byte: %02Xd, s:%d", ch, state);
  2669. #endif

  2671.         switch (state) {

  2673.         case ngx_http_grpc_st_start:
  2674.             ctx->rest = ch << 16;
  2675.             state = ngx_http_grpc_st_length_2;
  2676.             break;

  2678.         case ngx_http_grpc_st_length_2:
  2679.             ctx->rest |= ch << 8;
  2680.             state = ngx_http_grpc_st_length_3;
  2681.             break;

  2683.         case ngx_http_grpc_st_length_3:
  2684.             ctx->rest |= ch;

  2686.             if (ctx->rest > NGX_HTTP_V2_DEFAULT_FRAME_SIZE) {
  2687.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2688.                               "upstream sent too large http2 frame: %uz",
  2689.                               ctx->rest);
  2690.                 return NGX_ERROR;
  2691.             }

  2693.             state = ngx_http_grpc_st_type;
  2694.             break;

  2696.         case ngx_http_grpc_st_type:
  2697.             ctx->type = ch;
  2698.             state = ngx_http_grpc_st_flags;
  2699.             break;

  2701.         case ngx_http_grpc_st_flags:
  2702.             ctx->flags = ch;
  2703.             state = ngx_http_grpc_st_stream_id;
  2704.             break;

  2706.         case ngx_http_grpc_st_stream_id:
  2707.             ctx->stream_id = (ch & 0x7f) << 24;
  2708.             state = ngx_http_grpc_st_stream_id_2;
  2709.             break;

  2711.         case ngx_http_grpc_st_stream_id_2:
  2712.             ctx->stream_id |= ch << 16;
  2713.             state = ngx_http_grpc_st_stream_id_3;
  2714.             break;

  2716.         case ngx_http_grpc_st_stream_id_3:
  2717.             ctx->stream_id |= ch << 8;
  2718.             state = ngx_http_grpc_st_stream_id_4;
  2719.             break;

  2721.         case ngx_http_grpc_st_stream_id_4:
  2722.             ctx->stream_id |= ch;

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

  2728.             b->pos = p + 1;

  2730.             ctx->state = ngx_http_grpc_st_payload;
  2731.             ctx->frame_state = 0;

  2733.             return NGX_OK;

  2735.         /* suppress warning */
  2736.         case ngx_http_grpc_st_payload:
  2737.         case ngx_http_grpc_st_padding:
  2738.             break;
  2739.         }
  2740.     }

  2742.     b->pos = p;
  2743.     ctx->state = state;

  2745.     return NGX_AGAIN;
  2746. }


  2749. static ngx_int_t
  2750. ‌ngx_http_grpc_parse_header(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2751.     ngx_buf_t *b)
  2752. {
  2753.     u_char     ch, *p, *last;
  2754.     size_t     min;
  2755.     ngx_int_t  rc;
  2756. ‌    enum {
  2757.         sw_start = 0,
  2758.         sw_padding_length,
  2759.         sw_dependency,
  2760.         sw_dependency_2,
  2761.         sw_dependency_3,
  2762.         sw_dependency_4,
  2763.         sw_weight,
  2764.         sw_fragment,
  2765.         sw_padding
  2766.     } state;

  2768.     state = ctx->frame_state;

  2770.     if (state == sw_start) {

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

  2775.         if (ctx->type == NGX_HTTP_V2_HEADERS_FRAME) {
  2776.             ctx->parsing_headers = 1;
  2777.             ctx->fragment_state = 0;
  2778.             ctx->header_limit = r->upstream->conf->buffer_size;

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

  2783.             if (ctx->rest < min) {
  2784.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2785.                               "upstream sent headers frame "
  2786.                               "with invalid length: %uz",
  2787.                               ctx->rest);
  2788.                 return NGX_ERROR;
  2789.             }

  2791.             if (ctx->flags & NGX_HTTP_V2_END_STREAM_FLAG) {
  2792.                 ctx->end_stream = 1;
  2793.             }

  2795.             if (ctx->flags & NGX_HTTP_V2_PADDED_FLAG) {
  2796.                 state = sw_padding_length;

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

  2801.             } else {
  2802.                 state = sw_fragment;
  2803.             }

  2805.         } else if (ctx->type == NGX_HTTP_V2_CONTINUATION_FRAME) {
  2806.             state = sw_fragment;
  2807.         }

  2809.         ctx->padding = 0;
  2810.         ctx->frame_state = state;
  2811.     }

  2813.     if (state < sw_fragment) {

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

  2818.         } else {
  2819.             last = b->pos + ctx->rest;
  2820.         }

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

  2825. #if 0
  2826.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2827.                            "grpc header byte: %02Xd s:%d", ch, state);
  2828. #endif

  2830.             /*
  2831.              * headers frame:
  2832.              *
  2833.              * +---------------+
  2834.              * |Pad Length? (8)|
  2835.              * +-+-------------+----------------------------------------------+
  2836.              * |E|                 Stream Dependency? (31)                    |
  2837.              * +-+-------------+----------------------------------------------+
  2838.              * |  Weight? (8)  |
  2839.              * +-+-------------+----------------------------------------------+
  2840.              * |                   Header Block Fragment (*)                ...
  2841.              * +--------------------------------------------------------------+
  2842.              * |                           Padding (*)                      ...
  2843.              * +--------------------------------------------------------------+
  2844.              */

  2846.             switch (state) {

  2848.             case sw_padding_length:

  2850.                 ctx->padding = ch;

  2852.                 if (ctx->flags & NGX_HTTP_V2_PRIORITY_FLAG) {
  2853.                     state = sw_dependency;
  2854.                     break;
  2855.                 }

  2857.                 goto fragment;

  2859.             case sw_dependency:
  2860.                 state = sw_dependency_2;
  2861.                 break;

  2863.             case sw_dependency_2:
  2864.                 state = sw_dependency_3;
  2865.                 break;

  2867.             case sw_dependency_3:
  2868.                 state = sw_dependency_4;
  2869.                 break;

  2871.             case sw_dependency_4:
  2872.                 state = sw_weight;
  2873.                 break;

  2875.             case sw_weight:
  2876.                 goto fragment;

  2878.             /* suppress warning */
  2879.             case sw_start:
  2880.             case sw_fragment:
  2881.             case sw_padding:
  2882.                 break;
  2883.             }
  2884.         }

  2886.         ctx->rest -= p - b->pos;
  2887.         b->pos = p;

  2889.         ctx->frame_state = state;
  2890.         return NGX_AGAIN;

  2892.     fragment:

  2894.         p++;
  2895.         ctx->rest -= p - b->pos;
  2896.         b->pos = p;

  2898.         if (ctx->padding > ctx->rest) {
  2899.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2900.                           "upstream sent http2 frame with too long "
  2901.                           "padding: %d in frame %uz",
  2902.                           ctx->padding, ctx->rest);
  2903.             return NGX_ERROR;
  2904.         }

  2906.         state = sw_fragment;
  2907.         ctx->frame_state = state;
  2908.     }

  2910.     if (state == sw_fragment) {

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

  2914.         if (rc == NGX_AGAIN) {
  2915.             return NGX_AGAIN;
  2916.         }

  2918.         if (rc == NGX_ERROR) {
  2919.             return NGX_ERROR;
  2920.         }

  2922.         if (rc == NGX_OK) {
  2923.             return NGX_OK;
  2924.         }

  2926.         /* rc == NGX_DONE */

  2928.         state = sw_padding;
  2929.         ctx->frame_state = state;
  2930.     }

  2932.     if (state == sw_padding) {

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

  2936.             ctx->rest -= b->last - b->pos;
  2937.             b->pos = b->last;

  2939.             return NGX_AGAIN;
  2940.         }

  2942.         b->pos += ctx->rest;
  2943.         ctx->rest = 0;

  2945.         ctx->state = ngx_http_grpc_st_start;

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

  2949.             if (ctx->fragment_state) {
  2950.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2951.                               "upstream sent truncated http2 header");
  2952.                 return NGX_ERROR;
  2953.             }

  2955.             ctx->parsing_headers = 0;

  2957.             return NGX_HTTP_PARSE_HEADER_DONE;
  2958.         }

  2960.         return NGX_AGAIN;
  2961.     }

  2963.     /* unreachable */

  2965.     return NGX_ERROR;
  2966. }


  2969. static ngx_int_t
  2970. ‌ngx_http_grpc_parse_fragment(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  2971.     ngx_buf_t *b)
  2972. {
  2973.     u_char      ch, *p, *last;
  2974.     size_t      len, size;
  2975.     ngx_uint_t  index, size_update;
  2976. ‌    enum {
  2977.         sw_start = 0,
  2978.         sw_index,
  2979.         sw_name_length,
  2980.         sw_name_length_2,
  2981.         sw_name_length_3,
  2982.         sw_name_length_4,
  2983.         sw_name,
  2984.         sw_name_bytes,
  2985.         sw_value_length,
  2986.         sw_value_length_2,
  2987.         sw_value_length_3,
  2988.         sw_value_length_4,
  2989.         sw_value,
  2990.         sw_value_bytes
  2991.     } state;

  2993.     /* header block fragment */

  2995. #if 0
  2996.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2997.                    "grpc header fragment %p:%p rest:%uz",
  2998.                    b->pos, b->last, ctx->rest);
  2999. #endif

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

  3004.     } else {
  3005.         last = b->pos + ctx->rest - ctx->padding;
  3006.     }

  3008.     state = ctx->fragment_state;

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

  3013. #if 0
  3014.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3015.                        "grpc header byte: %02Xd s:%d", ch, state);
  3016. #endif

  3018.         switch (state) {

  3020.         case sw_start:
  3021.             ctx->index = 0;

  3023.             if ((ch & 0x80) == 0x80) {
  3024.                 /*
  3025.                  * indexed header:
  3026.                  *
  3027.                  *   0   1   2   3   4   5   6   7
  3028.                  * +---+---+---+---+---+---+---+---+
  3029.                  * | 1 |        Index (7+)         |
  3030.                  * +---+---------------------------+
  3031.                  */

  3033.                 index = ch & ~0x80;

  3035.                 if (index == 0 || index > 61) {
  3036.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3037.                                   "upstream sent invalid http2 "
  3038.                                   "table index: %ui", index);
  3039.                     return NGX_ERROR;
  3040.                 }

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

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

  3048.                 goto done;

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

  3077.                 index = ch & ~0xc0;

  3079.                 if (index > 61) {
  3080.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3081.                                   "upstream sent invalid http2 "
  3082.                                   "table index: %ui", index);
  3083.                     return NGX_ERROR;
  3084.                 }

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

  3089.                 if (index == 0) {
  3090.                     state = sw_name_length;
  3091.                     break;
  3092.                 }

  3094.                 ctx->index = index;
  3095.                 ctx->literal = 1;

  3097.                 state = sw_value_length;
  3098.                 break;

  3100.             } else if ((ch & 0xe0) == 0x20) {
  3101.                 /*
  3102.                  * dynamic table size update:
  3103.                  *
  3104.                  *   0   1   2   3   4   5   6   7
  3105.                  * +---+---+---+---+---+---+---+---+
  3106.                  * | 0 | 0 | 1 |   Max size (5+)   |
  3107.                  * +---+---------------------------+
  3108.                  */

  3110.                 size_update = ch & ~0xe0;

  3112.                 if (size_update > 0) {
  3113.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3114.                                   "upstream sent invalid http2 "
  3115.                                   "dynamic table size update: %ui",
  3116.                                   size_update);
  3117.                     return NGX_ERROR;
  3118.                 }

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

  3123.                 break;

  3125.             } else if ((ch & 0xf0) == 0x10) {
  3126.                 /*
  3127.                  *  literal header field never indexed:
  3128.                  *
  3129.                  *   0   1   2   3   4   5   6   7
  3130.                  * +---+---+---+---+---+---+---+---+
  3131.                  * | 0 | 0 | 0 | 1 |  Index (4+)   |
  3132.                  * +---+---+-----------------------+
  3133.                  * | H |     Value Length (7+)     |
  3134.                  * +---+---------------------------+
  3135.                  * | Value String (Length octets)  |
  3136.                  * +-------------------------------+
  3137.                  *
  3138.                  *   0   1   2   3   4   5   6   7
  3139.                  * +---+---+---+---+---+---+---+---+
  3140.                  * | 0 | 0 | 0 | 1 |       0       |
  3141.                  * +---+---+-----------------------+
  3142.                  * | H |     Name Length (7+)      |
  3143.                  * +---+---------------------------+
  3144.                  * |  Name String (Length octets)  |
  3145.                  * +---+---------------------------+
  3146.                  * | H |     Value Length (7+)     |
  3147.                  * +---+---------------------------+
  3148.                  * | Value String (Length octets)  |
  3149.                  * +-------------------------------+
  3150.                  */

  3152.                 index = ch & ~0xf0;

  3154.                 if (index == 0x0f) {
  3155.                     ctx->index = index;
  3156.                     ctx->literal = 1;
  3157.                     state = sw_index;
  3158.                     break;
  3159.                 }

  3161.                 if (index == 0) {
  3162.                     state = sw_name_length;
  3163.                     break;
  3164.                 }

  3166.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3167.                                "grpc literal header never indexed: %ui",
  3168.                                index);

  3170.                 ctx->index = index;
  3171.                 ctx->literal = 1;

  3173.                 state = sw_value_length;
  3174.                 break;

  3176.             } else if ((ch & 0xf0) == 0x00) {
  3177.                 /*
  3178.                  * literal header field without indexing:
  3179.                  *
  3180.                  *   0   1   2   3   4   5   6   7
  3181.                  * +---+---+---+---+---+---+---+---+
  3182.                  * | 0 | 0 | 0 | 0 |  Index (4+)   |
  3183.                  * +---+---+-----------------------+
  3184.                  * | H |     Value Length (7+)     |
  3185.                  * +---+---------------------------+
  3186.                  * | Value String (Length octets)  |
  3187.                  * +-------------------------------+
  3188.                  *
  3189.                  *   0   1   2   3   4   5   6   7
  3190.                  * +---+---+---+---+---+---+---+---+
  3191.                  * | 0 | 0 | 0 | 0 |       0       |
  3192.                  * +---+---+-----------------------+
  3193.                  * | H |     Name Length (7+)      |
  3194.                  * +---+---------------------------+
  3195.                  * |  Name String (Length octets)  |
  3196.                  * +---+---------------------------+
  3197.                  * | H |     Value Length (7+)     |
  3198.                  * +---+---------------------------+
  3199.                  * | Value String (Length octets)  |
  3200.                  * +-------------------------------+
  3201.                  */

  3203.                 index = ch & ~0xf0;

  3205.                 if (index == 0x0f) {
  3206.                     ctx->index = index;
  3207.                     ctx->literal = 1;
  3208.                     state = sw_index;
  3209.                     break;
  3210.                 }

  3212.                 if (index == 0) {
  3213.                     state = sw_name_length;
  3214.                     break;
  3215.                 }

  3217.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3218.                                "grpc literal header without indexing: %ui",
  3219.                                index);

  3221.                 ctx->index = index;
  3222.                 ctx->literal = 1;

  3224.                 state = sw_value_length;
  3225.                 break;
  3226.             }

  3228.             /* not reached */

  3230.             return NGX_ERROR;

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

  3235.             if (ch & 0x80) {
  3236.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3237.                               "upstream sent http2 table index "
  3238.                               "with continuation flag");
  3239.                 return NGX_ERROR;
  3240.             }

  3242.             if (ctx->index > 61) {
  3243.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3244.                               "upstream sent invalid http2 "
  3245.                               "table index: %ui", ctx->index);
  3246.                 return NGX_ERROR;
  3247.             }

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

  3252.             state = sw_value_length;
  3253.             break;

  3255.         case sw_name_length:
  3256.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3257.             ctx->field_length = ch & ~0x80;

  3259.             if (ctx->field_length == 0x7f) {
  3260.                 state = sw_name_length_2;
  3261.                 break;
  3262.             }

  3264.             if (ctx->field_length == 0) {
  3265.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3266.                               "upstream sent zero http2 "
  3267.                               "header name length");
  3268.                 return NGX_ERROR;
  3269.             }

  3271.             state = sw_name;
  3272.             break;

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

  3277.             if (ch & 0x80) {
  3278.                 state = sw_name_length_3;
  3279.                 break;
  3280.             }

  3282.             state = sw_name;
  3283.             break;

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

  3288.             if (ch & 0x80) {
  3289.                 state = sw_name_length_4;
  3290.                 break;
  3291.             }

  3293.             state = sw_name;
  3294.             break;

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

  3299.             if (ch & 0x80) {
  3300.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3301.                               "upstream sent too large http2 "
  3302.                               "header name length");
  3303.                 return NGX_ERROR;
  3304.             }

  3306.             state = sw_name;
  3307.             break;

  3309.         case sw_name:
  3310.             ctx->name.len = ctx->field_huffman ?
  3311.                             ctx->field_length * 8 / 5 : ctx->field_length;

  3313.             if (ctx->name.len > ctx->header_limit) {
  3314.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3315.                               "upstream sent too large http2 "
  3316.                               "header name length: %uz",
  3317.                               ctx->name.len);
  3318.                 return NGX_ERROR;
  3319.             }

  3321.             ctx->name.data = ngx_pnalloc(r->pool, ctx->name.len + 1);
  3322.             if (ctx->name.data == NULL) {
  3323.                 return NGX_ERROR;
  3324.             }

  3326.             ctx->field_end = ctx->name.data;
  3327.             ctx->field_rest = ctx->field_length;
  3328.             ctx->field_state = 0;

  3330.             state = sw_name_bytes;

  3332.             /* fall through */

  3334.         case sw_name_bytes:

  3336.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3337.                            "grpc name: len:%uz h:%d last:%uz, rest:%uz",
  3338.                            ctx->field_length,
  3339.                            ctx->field_huffman,
  3340.                            last - p,
  3341.                            ctx->rest - (p - b->pos));

  3343.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3344.             ctx->field_rest -= size;

  3346.             if (ctx->field_huffman) {
  3347.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3348.                                          &ctx->field_end,
  3349.                                          ctx->field_rest == 0,
  3350.                                          r->connection->log)
  3351.                     != NGX_OK)
  3352.                 {
  3353.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3354.                                   "upstream sent invalid encoded header");
  3355.                     return NGX_ERROR;
  3356.                 }

  3358.                 ctx->name.len = ctx->field_end - ctx->name.data;
  3359.                 ctx->name.data[ctx->name.len] = '\0';

  3361.             } else {
  3362.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3363.                 ctx->name.data[ctx->name.len] = '\0';
  3364.             }

  3366.             p += size - 1;

  3368.             if (ctx->field_rest == 0) {
  3369.                 state = sw_value_length;
  3370.             }

  3372.             break;

  3374.         case sw_value_length:
  3375.             ctx->field_huffman = ch & 0x80 ? 1 : 0;
  3376.             ctx->field_length = ch & ~0x80;

  3378.             if (ctx->field_length == 0x7f) {
  3379.                 state = sw_value_length_2;
  3380.                 break;
  3381.             }

  3383.             if (ctx->field_length == 0) {
  3384.                 ngx_str_set(&ctx->value, "");
  3385.                 goto done;
  3386.             }

  3388.             state = sw_value;
  3389.             break;

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

  3394.             if (ch & 0x80) {
  3395.                 state = sw_value_length_3;
  3396.                 break;
  3397.             }

  3399.             state = sw_value;
  3400.             break;

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

  3405.             if (ch & 0x80) {
  3406.                 state = sw_value_length_4;
  3407.                 break;
  3408.             }

  3410.             state = sw_value;
  3411.             break;

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

  3416.             if (ch & 0x80) {
  3417.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3418.                               "upstream sent too large http2 "
  3419.                               "header value length");
  3420.                 return NGX_ERROR;
  3421.             }

  3423.             state = sw_value;
  3424.             break;

  3426.         case sw_value:
  3427.             ctx->value.len = ctx->field_huffman ?
  3428.                              ctx->field_length * 8 / 5 : ctx->field_length;

  3430.             if (ctx->value.len > ctx->header_limit) {
  3431.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3432.                               "upstream sent too large http2 "
  3433.                               "header value length: %uz",
  3434.                               ctx->value.len);
  3435.                 return NGX_ERROR;
  3436.             }

  3438.             ctx->value.data = ngx_pnalloc(r->pool, ctx->value.len + 1);
  3439.             if (ctx->value.data == NULL) {
  3440.                 return NGX_ERROR;
  3441.             }

  3443.             ctx->field_end = ctx->value.data;
  3444.             ctx->field_rest = ctx->field_length;
  3445.             ctx->field_state = 0;

  3447.             state = sw_value_bytes;

  3449.             /* fall through */

  3451.         case sw_value_bytes:

  3453.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3454.                            "grpc value: len:%uz h:%d last:%uz, rest:%uz",
  3455.                            ctx->field_length,
  3456.                            ctx->field_huffman,
  3457.                            last - p,
  3458.                            ctx->rest - (p - b->pos));

  3460.             size = ngx_min(last - p, (ssize_t) ctx->field_rest);
  3461.             ctx->field_rest -= size;

  3463.             if (ctx->field_huffman) {
  3464.                 if (ngx_http_huff_decode(&ctx->field_state, p, size,
  3465.                                          &ctx->field_end,
  3466.                                          ctx->field_rest == 0,
  3467.                                          r->connection->log)
  3468.                     != NGX_OK)
  3469.                 {
  3470.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3471.                                   "upstream sent invalid encoded header");
  3472.                     return NGX_ERROR;
  3473.                 }

  3475.                 ctx->value.len = ctx->field_end - ctx->value.data;
  3476.                 ctx->value.data[ctx->value.len] = '\0';

  3478.             } else {
  3479.                 ctx->field_end = ngx_cpymem(ctx->field_end, p, size);
  3480.                 ctx->value.data[ctx->value.len] = '\0';
  3481.             }

  3483.             p += size - 1;

  3485.             if (ctx->field_rest == 0) {
  3486.                 goto done;
  3487.             }

  3489.             break;
  3490.         }

  3492.         continue;

  3494.     done:

  3496.         p++;
  3497.         ctx->rest -= p - b->pos;
  3498.         ctx->fragment_state = sw_start;
  3499.         b->pos = p;

  3501.         if (ctx->index) {
  3502.             ctx->name = *ngx_http_v2_get_static_name(ctx->index);
  3503.         }

  3505.         if (ctx->index && !ctx->literal) {
  3506.             ctx->value = *ngx_http_v2_get_static_value(ctx->index);
  3507.         }

  3509.         if (!ctx->index) {
  3510.             if (ngx_http_grpc_validate_header_name(r, &ctx->name) != NGX_OK) {
  3511.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3512.                               "upstream sent invalid header: \"%V: %V\"",
  3513.                               &ctx->name, &ctx->value);
  3514.                 return NGX_ERROR;
  3515.             }
  3516.         }

  3518.         if (!ctx->index || ctx->literal) {
  3519.             if (ngx_http_grpc_validate_header_value(r, &ctx->value) != NGX_OK) {
  3520.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3521.                               "upstream sent invalid header: \"%V: %V\"",
  3522.                               &ctx->name, &ctx->value);
  3523.                 return NGX_ERROR;
  3524.             }
  3525.         }

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

  3529.         if (len > ctx->header_limit) {
  3530.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3531.                           "upstream sent too large http2 header");
  3532.             return NGX_ERROR;
  3533.         }

  3535.         ctx->header_limit -= len;

  3537.         return NGX_OK;
  3538.     }

  3540.     ctx->rest -= p - b->pos;
  3541.     ctx->fragment_state = state;
  3542.     b->pos = p;

  3544.     if (ctx->rest > ctx->padding) {
  3545.         return NGX_AGAIN;
  3546.     }

  3548.     return NGX_DONE;
  3549. }


  3552. static ngx_int_t
  3553. ‌ngx_http_grpc_validate_header_name(ngx_http_request_t *r, ngx_str_t *s)
  3554. {
  3555.     u_char      ch;
  3556.     ngx_uint_t  i;

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

  3561.         if (ch == ':' && i > 0) {
  3562.             return NGX_ERROR;
  3563.         }

  3565.         if (ch >= 'A' && ch <= 'Z') {
  3566.             return NGX_ERROR;
  3567.         }

  3569.         if (ch <= 0x20 || ch == 0x7f) {
  3570.             return NGX_ERROR;
  3571.         }
  3572.     }

  3574.     return NGX_OK;
  3575. }


  3578. static ngx_int_t
  3579. ‌ngx_http_grpc_validate_header_value(ngx_http_request_t *r, ngx_str_t *s)
  3580. {
  3581.     u_char      ch;
  3582.     ngx_uint_t  i;

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

  3587.         if (ch == '\0' || ch == CR || ch == LF) {
  3588.             return NGX_ERROR;
  3589.         }
  3590.     }

  3592.     return NGX_OK;
  3593. }


  3596. static ngx_int_t
  3597. ‌ngx_http_grpc_parse_rst_stream(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  3598.     ngx_buf_t *b)
  3599. {
  3600.     u_char  ch, *p, *last;
  3601. ‌    enum {
  3602.         sw_start = 0,
  3603.         sw_error_2,
  3604.         sw_error_3,
  3605.         sw_error_4
  3606.     } state;

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

  3611.     } else {
  3612.         last = b->pos + ctx->rest;
  3613.     }

  3615.     state = ctx->frame_state;

  3617.     if (state == sw_start) {
  3618.         if (ctx->rest != 4) {
  3619.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3620.                           "upstream sent rst stream frame "
  3621.                           "with invalid length: %uz",
  3622.                           ctx->rest);
  3623.             return NGX_ERROR;
  3624.         }
  3625.     }

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

  3630. #if 0
  3631.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3632.                        "grpc rst byte: %02Xd s:%d", ch, state);
  3633. #endif

  3635.         switch (state) {

  3637.         case sw_start:
  3638.             ctx->error = (ngx_uint_t) ch << 24;
  3639.             state = sw_error_2;
  3640.             break;

  3642.         case sw_error_2:
  3643.             ctx->error |= ch << 16;
  3644.             state = sw_error_3;
  3645.             break;

  3647.         case sw_error_3:
  3648.             ctx->error |= ch << 8;
  3649.             state = sw_error_4;
  3650.             break;

  3652.         case sw_error_4:
  3653.             ctx->error |= ch;
  3654.             state = sw_start;

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

  3659.             break;
  3660.         }
  3661.     }

  3663.     ctx->rest -= p - b->pos;
  3664.     ctx->frame_state = state;
  3665.     b->pos = p;

  3667.     if (ctx->rest > 0) {
  3668.         return NGX_AGAIN;
  3669.     }

  3671.     ctx->state = ngx_http_grpc_st_start;

  3673.     return NGX_OK;
  3674. }


  3677. static ngx_int_t
  3678. ‌ngx_http_grpc_parse_goaway(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  3679.     ngx_buf_t *b)
  3680. {
  3681.     u_char  ch, *p, *last;
  3682. ‌    enum {
  3683.         sw_start = 0,
  3684.         sw_last_stream_id_2,
  3685.         sw_last_stream_id_3,
  3686.         sw_last_stream_id_4,
  3687.         sw_error,
  3688.         sw_error_2,
  3689.         sw_error_3,
  3690.         sw_error_4,
  3691.         sw_debug
  3692.     } state;

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

  3697.     } else {
  3698.         last = b->pos + ctx->rest;
  3699.     }

  3701.     state = ctx->frame_state;

  3703.     if (state == sw_start) {

  3705.         if (ctx->stream_id) {
  3706.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3707.                           "upstream sent goaway frame "
  3708.                           "with non-zero stream id: %ui",
  3709.                           ctx->stream_id);
  3710.             return NGX_ERROR;
  3711.         }

  3713.         if (ctx->rest < 8) {
  3714.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3715.                           "upstream sent goaway frame "
  3716.                           "with invalid length: %uz",
  3717.                           ctx->rest);
  3718.             return NGX_ERROR;
  3719.         }
  3720.     }

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

  3725. #if 0
  3726.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3727.                        "grpc goaway byte: %02Xd s:%d", ch, state);
  3728. #endif

  3730.         switch (state) {

  3732.         case sw_start:
  3733.             ctx->stream_id = (ch & 0x7f) << 24;
  3734.             state = sw_last_stream_id_2;
  3735.             break;

  3737.         case sw_last_stream_id_2:
  3738.             ctx->stream_id |= ch << 16;
  3739.             state = sw_last_stream_id_3;
  3740.             break;

  3742.         case sw_last_stream_id_3:
  3743.             ctx->stream_id |= ch << 8;
  3744.             state = sw_last_stream_id_4;
  3745.             break;

  3747.         case sw_last_stream_id_4:
  3748.             ctx->stream_id |= ch;
  3749.             state = sw_error;
  3750.             break;

  3752.         case sw_error:
  3753.             ctx->error = (ngx_uint_t) ch << 24;
  3754.             state = sw_error_2;
  3755.             break;

  3757.         case sw_error_2:
  3758.             ctx->error |= ch << 16;
  3759.             state = sw_error_3;
  3760.             break;

  3762.         case sw_error_3:
  3763.             ctx->error |= ch << 8;
  3764.             state = sw_error_4;
  3765.             break;

  3767.         case sw_error_4:
  3768.             ctx->error |= ch;
  3769.             state = sw_debug;
  3770.             break;

  3772.         case sw_debug:
  3773.             break;
  3774.         }
  3775.     }

  3777.     ctx->rest -= p - b->pos;
  3778.     ctx->frame_state = state;
  3779.     b->pos = p;

  3781.     if (ctx->rest > 0) {
  3782.         return NGX_AGAIN;
  3783.     }

  3785.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3786.                    "grpc goaway: %ui, stream %ui",
  3787.                    ctx->error, ctx->stream_id);

  3789.     ctx->state = ngx_http_grpc_st_start;

  3791.     return NGX_OK;
  3792. }


  3795. static ngx_int_t
  3796. ‌ngx_http_grpc_parse_window_update(ngx_http_request_t *r,
  3797.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b)
  3798. {
  3799.     u_char  ch, *p, *last;
  3800. ‌    enum {
  3801.         sw_start = 0,
  3802.         sw_size_2,
  3803.         sw_size_3,
  3804.         sw_size_4
  3805.     } state;

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

  3810.     } else {
  3811.         last = b->pos + ctx->rest;
  3812.     }

  3814.     state = ctx->frame_state;

  3816.     if (state == sw_start) {
  3817.         if (ctx->rest != 4) {
  3818.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3819.                           "upstream sent window update frame "
  3820.                           "with invalid length: %uz",
  3821.                           ctx->rest);
  3822.             return NGX_ERROR;
  3823.         }
  3824.     }

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

  3829. #if 0
  3830.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3831.                        "grpc window update byte: %02Xd s:%d", ch, state);
  3832. #endif

  3834.         switch (state) {

  3836.         case sw_start:
  3837.             ctx->window_update = (ch & 0x7f) << 24;
  3838.             state = sw_size_2;
  3839.             break;

  3841.         case sw_size_2:
  3842.             ctx->window_update |= ch << 16;
  3843.             state = sw_size_3;
  3844.             break;

  3846.         case sw_size_3:
  3847.             ctx->window_update |= ch << 8;
  3848.             state = sw_size_4;
  3849.             break;

  3851.         case sw_size_4:
  3852.             ctx->window_update |= ch;
  3853.             state = sw_start;
  3854.             break;
  3855.         }
  3856.     }

  3858.     ctx->rest -= p - b->pos;
  3859.     ctx->frame_state = state;
  3860.     b->pos = p;

  3862.     if (ctx->rest > 0) {
  3863.         return NGX_AGAIN;
  3864.     }

  3866.     ctx->state = ngx_http_grpc_st_start;

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

  3871.     if (ctx->window_update == 0) {
  3872.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3873.                       "upstream sent zero window update");
  3874.         return NGX_ERROR;
  3875.     }

  3877.     if (ctx->stream_id) {

  3879.         if (ctx->window_update > (size_t) NGX_HTTP_V2_MAX_WINDOW
  3880.                                  - ctx->send_window)
  3881.         {
  3882.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3883.                           "upstream sent too large window update");
  3884.             return NGX_ERROR;
  3885.         }

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

  3889.     } else {

  3891.         if (ctx->window_update > NGX_HTTP_V2_MAX_WINDOW
  3892.                                  - ctx->connection->send_window)
  3893.         {
  3894.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3895.                           "upstream sent too large window update");
  3896.             return NGX_ERROR;
  3897.         }

  3899.         ctx->connection->send_window += ctx->window_update;
  3900.     }

  3902.     return NGX_OK;
  3903. }


  3906. static ngx_int_t
  3907. ‌ngx_http_grpc_parse_settings(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx,
  3908.     ngx_buf_t *b)
  3909. {
  3910.     u_char   ch, *p, *last;
  3911.     ssize_t  window_update;
  3912. ‌    enum {
  3913.         sw_start = 0,
  3914.         sw_id,
  3915.         sw_id_2,
  3916.         sw_value,
  3917.         sw_value_2,
  3918.         sw_value_3,
  3919.         sw_value_4
  3920.     } state;

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

  3925.     } else {
  3926.         last = b->pos + ctx->rest;
  3927.     }

  3929.     state = ctx->frame_state;

  3931.     if (state == sw_start) {

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

  3941.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  3942.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3943.                            "grpc settings ack");

  3945.             if (ctx->rest != 0) {
  3946.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3947.                               "upstream sent settings frame "
  3948.                               "with ack flag and non-zero length: %uz",
  3949.                               ctx->rest);
  3950.                 return NGX_ERROR;
  3951.             }

  3953.             ctx->state = ngx_http_grpc_st_start;

  3955.             return NGX_OK;
  3956.         }

  3958.         if (ctx->rest % 6 != 0) {
  3959.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3960.                           "upstream sent settings frame "
  3961.                           "with invalid length: %uz",
  3962.                           ctx->rest);
  3963.             return NGX_ERROR;
  3964.         }

  3966.         if (ctx->free == NULL && ctx->settings++ > 1000) {
  3967.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3968.                           "upstream sent too many settings frames");
  3969.             return NGX_ERROR;
  3970.         }
  3971.     }

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

  3976. #if 0
  3977.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3978.                        "grpc settings byte: %02Xd s:%d", ch, state);
  3979. #endif

  3981.         switch (state) {

  3983.         case sw_start:
  3984.         case sw_id:
  3985.             ctx->setting_id = ch << 8;
  3986.             state = sw_id_2;
  3987.             break;

  3989.         case sw_id_2:
  3990.             ctx->setting_id |= ch;
  3991.             state = sw_value;
  3992.             break;

  3994.         case sw_value:
  3995.             ctx->setting_value = (ngx_uint_t) ch << 24;
  3996.             state = sw_value_2;
  3997.             break;

  3999.         case sw_value_2:
  4000.             ctx->setting_value |= ch << 16;
  4001.             state = sw_value_3;
  4002.             break;

  4004.         case sw_value_3:
  4005.             ctx->setting_value |= ch << 8;
  4006.             state = sw_value_4;
  4007.             break;

  4009.         case sw_value_4:
  4010.             ctx->setting_value |= ch;
  4011.             state = sw_id;

  4013.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4014.                            "grpc setting: %ui %ui",
  4015.                            ctx->setting_id, ctx->setting_value);

  4017.             /*
  4018.              * The following settings are defined by the protocol:
  4019.              *
  4020.              * SETTINGS_HEADER_TABLE_SIZE, SETTINGS_ENABLE_PUSH,
  4021.              * SETTINGS_MAX_CONCURRENT_STREAMS, SETTINGS_INITIAL_WINDOW_SIZE,
  4022.              * SETTINGS_MAX_FRAME_SIZE, SETTINGS_MAX_HEADER_LIST_SIZE
  4023.              *
  4024.              * Only SETTINGS_INITIAL_WINDOW_SIZE seems to be needed in
  4025.              * a simple client.
  4026.              */

  4028.             if (ctx->setting_id == 0x04) {
  4029.                 /* SETTINGS_INITIAL_WINDOW_SIZE */

  4031.                 if (ctx->setting_value > NGX_HTTP_V2_MAX_WINDOW) {
  4032.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4033.                                   "upstream sent settings frame "
  4034.                                   "with too large initial window size: %ui",
  4035.                                   ctx->setting_value);
  4036.                     return NGX_ERROR;
  4037.                 }

  4039.                 window_update = ctx->setting_value
  4040.                                 - ctx->connection->init_window;
  4041.                 ctx->connection->init_window = ctx->setting_value;

  4043.                 if (ctx->send_window > 0
  4044.                     && window_update > (ssize_t) NGX_HTTP_V2_MAX_WINDOW
  4045.                                        - ctx->send_window)
  4046.                 {
  4047.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4048.                                   "upstream sent settings frame "
  4049.                                   "with too large initial window size: %ui",
  4050.                                   ctx->setting_value);
  4051.                     return NGX_ERROR;
  4052.                 }

  4054.                 ctx->send_window += window_update;
  4055.             }

  4057.             break;
  4058.         }
  4059.     }

  4061.     ctx->rest -= p - b->pos;
  4062.     ctx->frame_state = state;
  4063.     b->pos = p;

  4065.     if (ctx->rest > 0) {
  4066.         return NGX_AGAIN;
  4067.     }

  4069.     ctx->state = ngx_http_grpc_st_start;

  4071.     return ngx_http_grpc_send_settings_ack(r, ctx);
  4072. }


  4075. static ngx_int_t
  4076. ‌ngx_http_grpc_parse_ping(ngx_http_request_t *r,
  4077.     ngx_http_grpc_ctx_t *ctx, ngx_buf_t *b)
  4078. {
  4079.     u_char  ch, *p, *last;
  4080. ‌    enum {
  4081.         sw_start = 0,
  4082.         sw_data_2,
  4083.         sw_data_3,
  4084.         sw_data_4,
  4085.         sw_data_5,
  4086.         sw_data_6,
  4087.         sw_data_7,
  4088.         sw_data_8
  4089.     } state;

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

  4094.     } else {
  4095.         last = b->pos + ctx->rest;
  4096.     }

  4098.     state = ctx->frame_state;

  4100.     if (state == sw_start) {

  4102.         if (ctx->stream_id) {
  4103.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4104.                           "upstream sent ping frame "
  4105.                           "with non-zero stream id: %ui",
  4106.                           ctx->stream_id);
  4107.             return NGX_ERROR;
  4108.         }

  4110.         if (ctx->rest != 8) {
  4111.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4112.                           "upstream sent ping frame "
  4113.                           "with invalid length: %uz",
  4114.                           ctx->rest);
  4115.             return NGX_ERROR;
  4116.         }

  4118.         if (ctx->flags & NGX_HTTP_V2_ACK_FLAG) {
  4119.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4120.                           "upstream sent ping frame with ack flag");
  4121.             return NGX_ERROR;
  4122.         }

  4124.         if (ctx->free == NULL && ctx->pings++ > 1000) {
  4125.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4126.                           "upstream sent too many ping frames");
  4127.             return NGX_ERROR;
  4128.         }
  4129.     }

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

  4134. #if 0
  4135.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4136.                        "grpc ping byte: %02Xd s:%d", ch, state);
  4137. #endif

  4139.         if (state < sw_data_8) {
  4140.             ctx->ping_data[state] = ch;
  4141.             state++;

  4143.         } else {
  4144.             ctx->ping_data[7] = ch;
  4145.             state = sw_start;

  4147.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4148.                            "grpc ping");
  4149.         }
  4150.     }

  4152.     ctx->rest -= p - b->pos;
  4153.     ctx->frame_state = state;
  4154.     b->pos = p;

  4156.     if (ctx->rest > 0) {
  4157.         return NGX_AGAIN;
  4158.     }

  4160.     ctx->state = ngx_http_grpc_st_start;

  4162.     return ngx_http_grpc_send_ping_ack(r, ctx);
  4163. }


  4166. static ngx_int_t
  4167. ‌ngx_http_grpc_send_settings_ack(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  4168. {
  4169.     ngx_chain_t            *cl, **ll;
  4170.     ngx_http_grpc_frame_t  *f;

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

  4175.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4176.         ll = &cl->next;
  4177.     }

  4179.     cl = ngx_http_grpc_get_buf(r, ctx);
  4180.     if (cl == NULL) {
  4181.         return NGX_ERROR;
  4182.     }

  4184.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4185.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4187.     f->length_0 = 0;
  4188.     f->length_1 = 0;
  4189.     f->length_2 = 0;
  4190.     f->type = NGX_HTTP_V2_SETTINGS_FRAME;
  4191.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  4192.     f->stream_id_0 = 0;
  4193.     f->stream_id_1 = 0;
  4194.     f->stream_id_2 = 0;
  4195.     f->stream_id_3 = 0;

  4197.     *ll = cl;

  4199.     return NGX_OK;
  4200. }


  4203. static ngx_int_t
  4204. ‌ngx_http_grpc_send_ping_ack(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  4205. {
  4206.     ngx_chain_t            *cl, **ll;
  4207.     ngx_http_grpc_frame_t  *f;

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

  4212.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4213.         ll = &cl->next;
  4214.     }

  4216.     cl = ngx_http_grpc_get_buf(r, ctx);
  4217.     if (cl == NULL) {
  4218.         return NGX_ERROR;
  4219.     }

  4221.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4222.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4224.     f->length_0 = 0;
  4225.     f->length_1 = 0;
  4226.     f->length_2 = 8;
  4227.     f->type = NGX_HTTP_V2_PING_FRAME;
  4228.     f->flags = NGX_HTTP_V2_ACK_FLAG;
  4229.     f->stream_id_0 = 0;
  4230.     f->stream_id_1 = 0;
  4231.     f->stream_id_2 = 0;
  4232.     f->stream_id_3 = 0;

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

  4236.     *ll = cl;

  4238.     return NGX_OK;
  4239. }


  4242. static ngx_int_t
  4243. ‌ngx_http_grpc_send_window_update(ngx_http_request_t *r,
  4244.     ngx_http_grpc_ctx_t *ctx)
  4245. {
  4246.     size_t                  n;
  4247.     ngx_chain_t            *cl, **ll;
  4248.     ngx_http_grpc_frame_t  *f;

  4250.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4251.                    "grpc send window update: %uz %uz",
  4252.                    ctx->connection->recv_window, ctx->recv_window);

  4254.     for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
  4255.         ll = &cl->next;
  4256.     }

  4258.     cl = ngx_http_grpc_get_buf(r, ctx);
  4259.     if (cl == NULL) {
  4260.         return NGX_ERROR;
  4261.     }

  4263.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4264.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4266.     f->length_0 = 0;
  4267.     f->length_1 = 0;
  4268.     f->length_2 = 4;
  4269.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4270.     f->flags = 0;
  4271.     f->stream_id_0 = 0;
  4272.     f->stream_id_1 = 0;
  4273.     f->stream_id_2 = 0;
  4274.     f->stream_id_3 = 0;

  4276.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->connection->recv_window;
  4277.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4279.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4280.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4281.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4282.     *cl->buf->last++ = (u_char) (n & 0xff);

  4284.     f = (ngx_http_grpc_frame_t *) cl->buf->last;
  4285.     cl->buf->last += sizeof(ngx_http_grpc_frame_t);

  4287.     f->length_0 = 0;
  4288.     f->length_1 = 0;
  4289.     f->length_2 = 4;
  4290.     f->type = NGX_HTTP_V2_WINDOW_UPDATE_FRAME;
  4291.     f->flags = 0;
  4292.     f->stream_id_0 = (u_char) ((ctx->id >> 24) & 0xff);
  4293.     f->stream_id_1 = (u_char) ((ctx->id >> 16) & 0xff);
  4294.     f->stream_id_2 = (u_char) ((ctx->id >> 8) & 0xff);
  4295.     f->stream_id_3 = (u_char) (ctx->id & 0xff);

  4297.     n = NGX_HTTP_V2_MAX_WINDOW - ctx->recv_window;
  4298.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4300.     *cl->buf->last++ = (u_char) ((n >> 24) & 0xff);
  4301.     *cl->buf->last++ = (u_char) ((n >> 16) & 0xff);
  4302.     *cl->buf->last++ = (u_char) ((n >> 8) & 0xff);
  4303.     *cl->buf->last++ = (u_char) (n & 0xff);

  4305.     *ll = cl;

  4307.     return NGX_OK;
  4308. }


  4311. static ngx_chain_t *
  4312. ‌ngx_http_grpc_get_buf(ngx_http_request_t *r, ngx_http_grpc_ctx_t *ctx)
  4313. {
  4314.     u_char       *start;
  4315.     ngx_buf_t    *b;
  4316.     ngx_chain_t  *cl;

  4318.     cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  4319.     if (cl == NULL) {
  4320.         return NULL;
  4321.     }

  4323.     b = cl->buf;
  4324.     start = b->start;

  4326.     if (start == NULL) {

  4328.         /*
  4329.          * each buffer is large enough to hold two window update
  4330.          * frames in a row
  4331.          */

  4333.         start = ngx_palloc(r->pool, 2 * sizeof(ngx_http_grpc_frame_t) + 8);
  4334.         if (start == NULL) {
  4335.             return NULL;
  4336.         }

  4338.     }

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

  4342.     b->start = start;
  4343.     b->pos = start;
  4344.     b->last = start;
  4345.     b->end = start + 2 * sizeof(ngx_http_grpc_frame_t) + 8;

  4347.     b->tag = (ngx_buf_tag_t) &ngx_http_grpc_body_output_filter;
  4348.     b->temporary = 1;
  4349.     b->flush = 1;

  4351.     return cl;
  4352. }


  4355. static ngx_http_grpc_ctx_t *
  4356. ‌ngx_http_grpc_get_ctx(ngx_http_request_t *r)
  4357. {
  4358.     ngx_http_grpc_ctx_t  *ctx;
  4359.     ngx_http_upstream_t  *u;

  4361.     ctx = ngx_http_get_module_ctx(r, ngx_http_grpc_module);

  4363.     if (ctx->connection == NULL) {
  4364.         u = r->upstream;

  4366.         if (ngx_http_grpc_get_connection_data(r, ctx, &u->peer) != NGX_OK) {
  4367.             return NULL;
  4368.         }
  4369.     }

  4371.     return ctx;
  4372. }


  4375. static ngx_int_t
  4376. ‌ngx_http_grpc_get_connection_data(ngx_http_request_t *r,
  4377.     ngx_http_grpc_ctx_t *ctx, ngx_peer_connection_t *pc)
  4378. {
  4379.     ngx_connection_t    *c;
  4380.     ngx_pool_cleanup_t  *cln;

  4382.     c = pc->connection;

  4384.     if (pc->cached) {

  4386.         /*
  4387.          * for cached connections, connection data can be found
  4388.          * in the cleanup handler
  4389.          */

  4391.         for (cln = c->pool->cleanup; cln; cln = cln->next) {
  4392.             if (cln->handler == ngx_http_grpc_cleanup) {
  4393.                 ctx->connection = cln->data;
  4394.                 break;
  4395.             }
  4396.         }

  4398.         if (ctx->connection == NULL) {
  4399.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  4400.                           "no connection data found for "
  4401.                           "keepalive http2 connection");
  4402.             return NGX_ERROR;
  4403.         }

  4405.         ctx->send_window = ctx->connection->init_window;
  4406.         ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4408.         ctx->connection->last_stream_id += 2;
  4409.         ctx->id = ctx->connection->last_stream_id;

  4411.         return NGX_OK;
  4412.     }

  4414.     cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_grpc_conn_t));
  4415.     if (cln == NULL) {
  4416.         return NGX_ERROR;
  4417.     }

  4419.     cln->handler = ngx_http_grpc_cleanup;
  4420.     ctx->connection = cln->data;

  4422.     ctx->connection->init_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4423.     ctx->connection->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4424.     ctx->connection->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4426.     ctx->send_window = NGX_HTTP_V2_DEFAULT_WINDOW;
  4427.     ctx->recv_window = NGX_HTTP_V2_MAX_WINDOW;

  4429.     ctx->id = 1;
  4430.     ctx->connection->last_stream_id = 1;

  4432.     return NGX_OK;
  4433. }


  4436. static void
  4437. ‌ngx_http_grpc_cleanup(void *data)
  4438. {
  4439. #if 0
  4440.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  4441.                    "grpc cleanup");
  4442. #endif
  4443.     return;
  4444. }


  4447. static void
  4448. ‌ngx_http_grpc_abort_request(ngx_http_request_t *r)
  4449. {
  4450.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4451.                    "abort grpc request");
  4452.     return;
  4453. }


  4456. static void
  4457. ‌ngx_http_grpc_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  4458. {
  4459.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4460.                    "finalize grpc request");
  4461.     return;
  4462. }


  4465. static ngx_int_t
  4466. ‌ngx_http_grpc_internal_trailers_variable(ngx_http_request_t *r,
  4467.     ngx_http_variable_value_t *v, uintptr_t data)
  4468. {
  4469.     ngx_table_elt_t  *te;

  4471.     te = r->headers_in.te;

  4473.     if (te == NULL) {
  4474.         v->not_found = 1;
  4475.         return NGX_OK;
  4476.     }

  4478.     if (ngx_strlcasestrn(te->value.data, te->value.data + te->value.len,
  4479.                          (u_char *) "trailers", 8 - 1)
  4480.         == NULL)
  4481.     {
  4482.         v->not_found = 1;
  4483.         return NGX_OK;
  4484.     }

  4486.     v->valid = 1;
  4487.     v->no_cacheable = 0;
  4488.     v->not_found = 0;

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

  4493.     return NGX_OK;
  4494. }


  4497. static ngx_int_t
  4498. ‌ngx_http_grpc_add_variables(ngx_conf_t *cf)
  4499. {
  4500.     ngx_http_variable_t  *var, *v;

  4502.     for (v = ngx_http_grpc_vars; v->name.len; v++) {
  4503.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  4504.         if (var == NULL) {
  4505.             return NGX_ERROR;
  4506.         }

  4508.         var->get_handler = v->get_handler;
  4509.         var->data = v->data;
  4510.     }

  4512.     return NGX_OK;
  4513. }


  4516. static void *
  4517. ‌ngx_http_grpc_create_loc_conf(ngx_conf_t *cf)
  4518. {
  4519.     ngx_http_grpc_loc_conf_t  *conf;

  4521.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_grpc_loc_conf_t));
  4522.     if (conf == NULL) {
  4523.         return NULL;
  4524.     }

  4526.     /*
  4527.      * set by ngx_pcalloc():
  4528.      *
  4529.      *     conf->upstream.ignore_headers = 0;
  4530.      *     conf->upstream.next_upstream = 0;
  4531.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  4532.      *
  4533.      *     conf->headers.lengths = NULL;
  4534.      *     conf->headers.values = NULL;
  4535.      *     conf->headers.hash = { NULL, 0 };
  4536.      *     conf->host = { 0, NULL };
  4537.      *     conf->host_value = NULL;
  4538.      *     conf->ssl = 0;
  4539.      *     conf->ssl_protocols = 0;
  4540.      *     conf->ssl_ciphers = { 0, NULL };
  4541.      *     conf->ssl_trusted_certificate = { 0, NULL };
  4542.      *     conf->ssl_crl = { 0, NULL };
  4543.      */

  4545.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  4546.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;
  4547.     conf->upstream.socket_rcvbuf = NGX_CONF_UNSET_SIZE;
  4548.     conf->upstream.socket_sndbuf = NGX_CONF_UNSET_SIZE;
  4549.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  4550.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  4551.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  4552.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  4553.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  4555.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;

  4557.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  4558.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  4560.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  4562. #if (NGX_HTTP_SSL)
  4563.     conf->upstream.ssl_session_reuse = NGX_CONF_UNSET;
  4564.     conf->upstream.ssl_name = NGX_CONF_UNSET_PTR;
  4565.     conf->upstream.ssl_server_name = NGX_CONF_UNSET;
  4566.     conf->upstream.ssl_verify = NGX_CONF_UNSET;
  4567.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  4568.     conf->upstream.ssl_certificate = NGX_CONF_UNSET_PTR;
  4569.     conf->upstream.ssl_certificate_key = NGX_CONF_UNSET_PTR;
  4570.     conf->upstream.ssl_certificate_cache = NGX_CONF_UNSET_PTR;
  4571.     conf->upstream.ssl_passwords = NGX_CONF_UNSET_PTR;
  4572.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  4573. #endif

  4575.     /* the hardcoded values */
  4576.     conf->upstream.cyclic_temp_file = 0;
  4577.     conf->upstream.buffering = 0;
  4578.     conf->upstream.ignore_client_abort = 0;
  4579.     conf->upstream.send_lowat = 0;
  4580.     conf->upstream.bufs.num = 0;
  4581.     conf->upstream.busy_buffers_size = 0;
  4582.     conf->upstream.max_temp_file_size = 0;
  4583.     conf->upstream.temp_file_write_size = 0;
  4584.     conf->upstream.pass_request_headers = 1;
  4585.     conf->upstream.pass_request_body = 1;
  4586.     conf->upstream.force_ranges = 0;
  4587.     conf->upstream.pass_trailers = 1;
  4588.     conf->upstream.pass_early_hints = 1;
  4589.     conf->upstream.preserve_output = 1;

  4591.     conf->headers_source = NGX_CONF_UNSET_PTR;

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

  4595.     return conf;
  4596. }


  4599. static char *
  4600. ‌ngx_http_grpc_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  4601. {
  4602.     ngx_http_grpc_loc_conf_t *prev = parent;
  4603.     ngx_http_grpc_loc_conf_t *conf = child;

  4605.     ngx_int_t                  rc;
  4606.     ngx_hash_init_t            hash;
  4607.     ngx_http_core_loc_conf_t  *clcf;

  4609.     ngx_conf_merge_ptr_value(conf->upstream.local,
  4610.                               prev->upstream.local, NULL);

  4612.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  4613.                               prev->upstream.socket_keepalive, 0);

  4615.     ngx_conf_merge_size_value(conf->upstream.socket_rcvbuf,
  4616.                               prev->upstream.socket_rcvbuf, 0);

  4618.     ngx_conf_merge_size_value(conf->upstream.socket_sndbuf,
  4619.                               prev->upstream.socket_sndbuf, 0);

  4621.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  4622.                               prev->upstream.next_upstream_tries, 0);

  4624.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  4625.                               prev->upstream.connect_timeout, 60000);

  4627.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  4628.                               prev->upstream.send_timeout, 60000);

  4630.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  4631.                               prev->upstream.read_timeout, 60000);

  4633.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  4634.                               prev->upstream.next_upstream_timeout, 0);

  4636.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  4637.                               prev->upstream.buffer_size,
  4638.                               (size_t) ngx_pagesize);

  4640.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  4641.                               prev->upstream.ignore_headers,
  4642.                               NGX_CONF_BITMASK_SET);

  4644.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  4645.                               prev->upstream.next_upstream,
  4646.                               (NGX_CONF_BITMASK_SET
  4647.                                |NGX_HTTP_UPSTREAM_FT_ERROR
  4648.                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  4650.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  4651.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  4652.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  4653.     }

  4655.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  4656.                               prev->upstream.intercept_errors, 0);

  4658. #if (NGX_HTTP_SSL)

  4660.     if (ngx_http_grpc_merge_ssl(cf, conf, prev) != NGX_OK) {
  4661.         return NGX_CONF_ERROR;
  4662.     }

  4664.     ngx_conf_merge_value(conf->upstream.ssl_session_reuse,
  4665.                               prev->upstream.ssl_session_reuse, 1);

  4667.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  4668.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  4670.     ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers,
  4671.                              "DEFAULT");

  4673.     ngx_conf_merge_ptr_value(conf->upstream.ssl_name,
  4674.                               prev->upstream.ssl_name, NULL);
  4675.     ngx_conf_merge_value(conf->upstream.ssl_server_name,
  4676.                               prev->upstream.ssl_server_name, 0);
  4677.     ngx_conf_merge_value(conf->upstream.ssl_verify,
  4678.                               prev->upstream.ssl_verify, 0);
  4679.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  4680.                               prev->ssl_verify_depth, 1);
  4681.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  4682.                               prev->ssl_trusted_certificate, "");
  4683.     ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");

  4685.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate,
  4686.                               prev->upstream.ssl_certificate, NULL);
  4687.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_key,
  4688.                               prev->upstream.ssl_certificate_key, NULL);
  4689.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_cache,
  4690.                               prev->upstream.ssl_certificate_cache, NULL);

  4692.     if (ngx_http_upstream_merge_ssl_passwords(cf, &conf->upstream,
  4693.                                               &prev->upstream)
  4694.         != NGX_OK)
  4695.     {
  4696.         return NGX_CONF_ERROR;
  4697.     }

  4699.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  4700.                               prev->ssl_conf_commands, NULL);

  4702.     if (conf->ssl && ngx_http_grpc_set_ssl(cf, conf) != NGX_OK) {
  4703.         return NGX_CONF_ERROR;
  4704.     }

  4706. #endif

  4708.     hash.max_size = 512;
  4709.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  4710.     hash.name = "grpc_headers_hash";

  4712.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  4713.             &prev->upstream, ngx_http_grpc_hide_headers, &hash)
  4714.         != NGX_OK)
  4715.     {
  4716.         return NGX_CONF_ERROR;
  4717.     }

  4719.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  4721.     if (clcf->noname
  4722.         && conf->upstream.upstream == NULL && conf->grpc_lengths == NULL)
  4723.     {
  4724.         conf->upstream.upstream = prev->upstream.upstream;
  4725.         conf->host = prev->host;

  4727.         conf->grpc_lengths = prev->grpc_lengths;
  4728.         conf->grpc_values = prev->grpc_values;

  4730. #if (NGX_HTTP_SSL)
  4731.         conf->ssl = prev->ssl;
  4732. #endif
  4733.     }

  4735.     if (clcf->lmt_excpt && clcf->handler == NULL
  4736.         && (conf->upstream.upstream || conf->grpc_lengths))
  4737.     {
  4738.         clcf->handler = ngx_http_grpc_handler;
  4739.     }

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

  4743.     if (conf->headers_source == prev->headers_source) {
  4744.         conf->headers = prev->headers;
  4745.         conf->host_value = prev->host_value;
  4746.     }

  4748.     rc = ngx_http_grpc_init_headers(cf, conf, &conf->headers,
  4749.                                     ngx_http_grpc_headers);
  4750.     if (rc != NGX_OK) {
  4751.         return NGX_CONF_ERROR;
  4752.     }

  4754.     /*
  4755.      * special handling to preserve conf->headers in the "http" section
  4756.      * to inherit it to all servers
  4757.      */

  4759.     if (prev->headers.hash.buckets == NULL
  4760.         && conf->headers_source == prev->headers_source)
  4761.     {
  4762.         prev->headers = conf->headers;
  4763.         prev->host_value = conf->host_value;
  4764.     }

  4766.     return NGX_CONF_OK;
  4767. }


  4770. static ngx_int_t
  4771. ‌ngx_http_grpc_init_headers(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *conf,
  4772.     ngx_http_grpc_headers_t *headers, ngx_keyval_t *default_headers)
  4773. {
  4774.     u_char                            *p;
  4775.     size_t                             size;
  4776.     uintptr_t                         *code;
  4777.     ngx_uint_t                         i;
  4778.     ngx_array_t                        headers_names, headers_merged;
  4779.     ngx_keyval_t                      *src, *s, *h;
  4780.     ngx_hash_key_t                    *hk;
  4781.     ngx_hash_init_t                    hash;
  4782.     ngx_http_script_compile_t          sc;
  4783.     ngx_http_script_copy_code_t       *copy;
  4784.     ngx_http_compile_complex_value_t   ccv;

  4786.     if (headers->hash.buckets) {
  4787.         return NGX_OK;
  4788.     }

  4790.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  4791.         != NGX_OK)
  4792.     {
  4793.         return NGX_ERROR;
  4794.     }

  4796.     if (ngx_array_init(&headers_merged, cf->temp_pool, 4, sizeof(ngx_keyval_t))
  4797.         != NGX_OK)
  4798.     {
  4799.         return NGX_ERROR;
  4800.     }

  4802.     headers->lengths = ngx_array_create(cf->pool, 64, 1);
  4803.     if (headers->lengths == NULL) {
  4804.         return NGX_ERROR;
  4805.     }

  4807.     headers->values = ngx_array_create(cf->pool, 512, 1);
  4808.     if (headers->values == NULL) {
  4809.         return NGX_ERROR;
  4810.     }

  4812.     if (conf->headers_source) {

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

  4817.             if (src[i].key.len == 4
  4818.                 && ngx_strncasecmp(src[i].key.data, (u_char *) "Host", 4) == 0)
  4819.             {
  4820.                 conf->host_value = ngx_pcalloc(cf->pool,
  4821.                                              sizeof(ngx_http_complex_value_t));
  4822.                 if (conf->host_value == NULL) {
  4823.                     return NGX_ERROR;
  4824.                 }

  4826.                 ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  4828.                 ccv.cf = cf;
  4829.                 ccv.value = &src[i].value;
  4830.                 ccv.complex_value = conf->host_value;

  4832.                 if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  4833.                     return NGX_ERROR;
  4834.                 }

  4836.                 continue;
  4837.             }

  4839.             s = ngx_array_push(&headers_merged);
  4840.             if (s == NULL) {
  4841.                 return NGX_ERROR;
  4842.             }

  4844.             *s = src[i];
  4845.         }
  4846.     }

  4848.     h = default_headers;

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

  4852.         src = headers_merged.elts;
  4853.         for (i = 0; i < headers_merged.nelts; i++) {
  4854.             if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  4855.                 goto next;
  4856.             }
  4857.         }

  4859.         s = ngx_array_push(&headers_merged);
  4860.         if (s == NULL) {
  4861.             return NGX_ERROR;
  4862.         }

  4864.         *s = *h;

  4866.     next:

  4868.         h++;
  4869.     }


  4872.     src = headers_merged.elts;
  4873.     for (i = 0; i < headers_merged.nelts; i++) {

  4875.         hk = ngx_array_push(&headers_names);
  4876.         if (hk == NULL) {
  4877.             return NGX_ERROR;
  4878.         }

  4880.         hk->key = src[i].key;
  4881.         hk->key_hash = ngx_hash_key_lc(src[i].key.data, src[i].key.len);
  4882.         hk->value = (void *) 1;

  4884.         if (src[i].value.len == 0) {
  4885.             continue;
  4886.         }

  4888.         copy = ngx_array_push_n(headers->lengths,
  4889.                                 sizeof(ngx_http_script_copy_code_t));
  4890.         if (copy == NULL) {
  4891.             return NGX_ERROR;
  4892.         }

  4894.         copy->code = (ngx_http_script_code_pt) (void *)
  4895.                                                  ngx_http_script_copy_len_code;
  4896.         copy->len = src[i].key.len;

  4898.         size = (sizeof(ngx_http_script_copy_code_t)
  4899.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  4900.                & ~(sizeof(uintptr_t) - 1);

  4902.         copy = ngx_array_push_n(headers->values, size);
  4903.         if (copy == NULL) {
  4904.             return NGX_ERROR;
  4905.         }

  4907.         copy->code = ngx_http_script_copy_code;
  4908.         copy->len = src[i].key.len;

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

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

  4915.         sc.cf = cf;
  4916.         sc.source = &src[i].value;
  4917.         sc.flushes = &headers->flushes;
  4918.         sc.lengths = &headers->lengths;
  4919.         sc.values = &headers->values;

  4921.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  4922.             return NGX_ERROR;
  4923.         }

  4925.         code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
  4926.         if (code == NULL) {
  4927.             return NGX_ERROR;
  4928.         }

  4930.         *code = (uintptr_t) NULL;

  4932.         code = ngx_array_push_n(headers->values, sizeof(uintptr_t));
  4933.         if (code == NULL) {
  4934.             return NGX_ERROR;
  4935.         }

  4937.         *code = (uintptr_t) NULL;
  4938.     }

  4940.     code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
  4941.     if (code == NULL) {
  4942.         return NGX_ERROR;
  4943.     }

  4945.     *code = (uintptr_t) NULL;


  4948.     hash.hash = &headers->hash;
  4949.     hash.key = ngx_hash_key_lc;
  4950.     hash.max_size = 512;
  4951.     hash.bucket_size = 64;
  4952.     hash.name = "grpc_headers_hash";
  4953.     hash.pool = cf->pool;
  4954.     hash.temp_pool = NULL;

  4956.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  4957. }


  4960. static char *
  4961. ‌ngx_http_grpc_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  4962. {
  4963.     ngx_http_grpc_loc_conf_t *glcf = conf;

  4965.     size_t                      add;
  4966.     ngx_str_t                  *value, *url;
  4967.     ngx_url_t                   u;
  4968.     ngx_uint_t                  n;
  4969.     ngx_http_core_loc_conf_t   *clcf;
  4970.     ngx_http_script_compile_t   sc;

  4972.     if (glcf->upstream.upstream || glcf->grpc_lengths) {
  4973.         return "is duplicate";
  4974.     }

  4976.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  4978.     clcf->handler = ngx_http_grpc_handler;

  4980.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  4981.         clcf->auto_redirect = 1;
  4982.     }

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

  4986.     url = &value[1];

  4988.     n = ngx_http_script_variables_count(url);

  4990.     if (n) {

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

  4994.         sc.cf = cf;
  4995.         sc.source = url;
  4996.         sc.lengths = &glcf->grpc_lengths;
  4997.         sc.values = &glcf->grpc_values;
  4998.         sc.variables = n;
  4999.         sc.complete_lengths = 1;
  5000.         sc.complete_values = 1;

  5002.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  5003.             return NGX_CONF_ERROR;
  5004.         }

  5006. #if (NGX_HTTP_SSL)
  5007.         glcf->ssl = 1;
  5008. #endif

  5010.         return NGX_CONF_OK;
  5011.     }

  5013.     if (ngx_strncasecmp(url->data, (u_char *) "grpc://", 7) == 0) {
  5014.         add = 7;

  5016.     } else if (ngx_strncasecmp(url->data, (u_char *) "grpcs://", 8) == 0) {

  5018. #if (NGX_HTTP_SSL)
  5019.         glcf->ssl = 1;

  5021.         add = 8;
  5022. #else
  5023.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5024.                            "grpcs protocol requires SSL support");
  5025.         return NGX_CONF_ERROR;
  5026. #endif

  5028.     } else {
  5029.         add = 0;
  5030.     }

  5032.     ngx_memzero(&u, sizeof(ngx_url_t));

  5034.     u.url.len = url->len - add;
  5035.     u.url.data = url->data + add;
  5036.     u.no_resolve = 1;

  5038.     glcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  5039.     if (glcf->upstream.upstream == NULL) {
  5040.         return NGX_CONF_ERROR;
  5041.     }

  5043.     if (u.family != AF_UNIX) {

  5045.         if (u.no_port) {
  5046.             glcf->host = u.host;

  5048.         } else {
  5049.             glcf->host.len = u.host.len + 1 + u.port_text.len;
  5050.             glcf->host.data = u.host.data;
  5051.         }

  5053.     } else {
  5054.         ngx_str_set(&glcf->host, "localhost");
  5055.     }

  5057.     return NGX_CONF_OK;
  5058. }


  5061. #if (NGX_HTTP_SSL)

  5063. static char *
  5064. ‌ngx_http_grpc_ssl_certificate_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  5065.     void *conf)
  5066. {
  5067.     ngx_http_grpc_loc_conf_t *plcf = conf;

  5069.     time_t       inactive, valid;
  5070.     ngx_str_t   *value, s;
  5071.     ngx_int_t    max;
  5072.     ngx_uint_t   i;

  5074.     if (plcf->upstream.ssl_certificate_cache != NGX_CONF_UNSET_PTR) {
  5075.         return "is duplicate";
  5076.     }

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

  5080.     max = 0;
  5081.     inactive = 10;
  5082.     valid = 60;

  5084.     for (i = 1; i < cf->args->nelts; i++) {

  5086.         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {

  5088.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  5089.             if (max <= 0) {
  5090.                 goto failed;
  5091.             }

  5093.             continue;
  5094.         }

  5096.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  5098.             s.len = value[i].len - 9;
  5099.             s.data = value[i].data + 9;

  5101.             inactive = ngx_parse_time(&s, 1);
  5102.             if (inactive == (time_t) NGX_ERROR) {
  5103.                 goto failed;
  5104.             }

  5106.             continue;
  5107.         }

  5109.         if (ngx_strncmp(value[i].data, "valid=", 6) == 0) {

  5111.             s.len = value[i].len - 6;
  5112.             s.data = value[i].data + 6;

  5114.             valid = ngx_parse_time(&s, 1);
  5115.             if (valid == (time_t) NGX_ERROR) {
  5116.                 goto failed;
  5117.             }

  5119.             continue;
  5120.         }

  5122.         if (ngx_strcmp(value[i].data, "off") == 0) {

  5124.             plcf->upstream.ssl_certificate_cache = NULL;

  5126.             continue;
  5127.         }

  5129.     failed:

  5131.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5132.                            "invalid parameter \"%V\"", &value[i]);
  5133.         return NGX_CONF_ERROR;
  5134.     }

  5136.     if (plcf->upstream.ssl_certificate_cache == NULL) {
  5137.         return NGX_CONF_OK;
  5138.     }

  5140.     if (max == 0) {
  5141.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5142.                            "\"grpc_ssl_certificate_cache\" must have "
  5143.                            "the \"max\" parameter");
  5144.         return NGX_CONF_ERROR;
  5145.     }

  5147.     plcf->upstream.ssl_certificate_cache = ngx_ssl_cache_init(cf->pool, max,
  5148.                                                               valid, inactive);
  5149.     if (plcf->upstream.ssl_certificate_cache == NULL) {
  5150.         return NGX_CONF_ERROR;
  5151.     }

  5153.     return NGX_CONF_OK;
  5154. }


  5157. static char *
  5158. ‌ngx_http_grpc_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5159. {
  5160.     ngx_http_grpc_loc_conf_t *glcf = conf;

  5162.     ngx_str_t  *value;

  5164.     if (glcf->upstream.ssl_passwords != NGX_CONF_UNSET_PTR) {
  5165.         return "is duplicate";
  5166.     }

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

  5170.     glcf->upstream.ssl_passwords = ngx_ssl_read_password_file(cf, &value[1]);

  5172.     if (glcf->upstream.ssl_passwords == NULL) {
  5173.         return NGX_CONF_ERROR;
  5174.     }

  5176.     return NGX_CONF_OK;
  5177. }


  5180. static char *
  5181. ‌ngx_http_grpc_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  5182. {
  5183. #ifndef SSL_CONF_FLAG_FILE
  5184.     return "is not supported on this platform";
  5185. #else
  5186.     return NGX_CONF_OK;
  5187. #endif
  5188. }


  5191. static ngx_int_t
  5192. ‌ngx_http_grpc_merge_ssl(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *conf,
  5193.     ngx_http_grpc_loc_conf_t *prev)
  5194. {
  5195.     ngx_uint_t  preserve;

  5197.     if (conf->ssl_protocols == 0
  5198.         && conf->ssl_ciphers.data == NULL
  5199.         && conf->upstream.ssl_certificate == NGX_CONF_UNSET_PTR
  5200.         && conf->upstream.ssl_certificate_key == NGX_CONF_UNSET_PTR
  5201.         && conf->upstream.ssl_passwords == NGX_CONF_UNSET_PTR
  5202.         && conf->upstream.ssl_verify == NGX_CONF_UNSET
  5203.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  5204.         && conf->ssl_trusted_certificate.data == NULL
  5205.         && conf->ssl_crl.data == NULL
  5206.         && conf->upstream.ssl_session_reuse == NGX_CONF_UNSET
  5207.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  5208.     {
  5209.         if (prev->upstream.ssl) {
  5210.             conf->upstream.ssl = prev->upstream.ssl;
  5211.             return NGX_OK;
  5212.         }

  5214.         preserve = 1;

  5216.     } else {
  5217.         preserve = 0;
  5218.     }

  5220.     conf->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  5221.     if (conf->upstream.ssl == NULL) {
  5222.         return NGX_ERROR;
  5223.     }

  5225.     conf->upstream.ssl->log = cf->log;

  5227.     /*
  5228.      * special handling to preserve conf->upstream.ssl
  5229.      * in the "http" section to inherit it to all servers
  5230.      */

  5232.     if (preserve) {
  5233.         prev->upstream.ssl = conf->upstream.ssl;
  5234.     }

  5236.     return NGX_OK;
  5237. }


  5240. static ngx_int_t
  5241. ‌ngx_http_grpc_set_ssl(ngx_conf_t *cf, ngx_http_grpc_loc_conf_t *glcf)
  5242. {
  5243.     ngx_pool_cleanup_t  *cln;

  5245.     if (glcf->upstream.ssl->ctx) {
  5246.         return NGX_OK;
  5247.     }

  5249.     if (ngx_ssl_create(glcf->upstream.ssl, glcf->ssl_protocols, NULL)
  5250.         != NGX_OK)
  5251.     {
  5252.         return NGX_ERROR;
  5253.     }

  5255.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  5256.     if (cln == NULL) {
  5257.         ngx_ssl_cleanup_ctx(glcf->upstream.ssl);
  5258.         return NGX_ERROR;
  5259.     }

  5261.     cln->handler = ngx_ssl_cleanup_ctx;
  5262.     cln->data = glcf->upstream.ssl;

  5264.     if (ngx_ssl_ciphers(cf, glcf->upstream.ssl, &glcf->ssl_ciphers, 0)
  5265.         != NGX_OK)
  5266.     {
  5267.         return NGX_ERROR;
  5268.     }

  5270.     if (glcf->upstream.ssl_certificate
  5271.         && glcf->upstream.ssl_certificate->value.len)
  5272.     {
  5273.         if (glcf->upstream.ssl_certificate_key == NULL) {
  5274.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  5275.                           "no \"grpc_ssl_certificate_key\" is defined "
  5276.                           "for certificate \"%V\"",
  5277.                           &glcf->upstream.ssl_certificate->value);
  5278.             return NGX_ERROR;
  5279.         }

  5281.         if (glcf->upstream.ssl_certificate->lengths == NULL
  5282.             && glcf->upstream.ssl_certificate_key->lengths == NULL)
  5283.         {
  5284.             if (ngx_ssl_certificate(cf, glcf->upstream.ssl,
  5285.                                     &glcf->upstream.ssl_certificate->value,
  5286.                                     &glcf->upstream.ssl_certificate_key->value,
  5287.                                     glcf->upstream.ssl_passwords)
  5288.                 != NGX_OK)
  5289.             {
  5290.                 return NGX_ERROR;
  5291.             }
  5292.         }
  5293.     }

  5295.     if (glcf->upstream.ssl_verify) {
  5296.         if (glcf->ssl_trusted_certificate.len == 0) {
  5297.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  5298.                       "no grpc_ssl_trusted_certificate for grpc_ssl_verify");
  5299.             return NGX_ERROR;
  5300.         }

  5302.         if (ngx_ssl_trusted_certificate(cf, glcf->upstream.ssl,
  5303.                                         &glcf->ssl_trusted_certificate,
  5304.                                         glcf->ssl_verify_depth)
  5305.             != NGX_OK)
  5306.         {
  5307.             return NGX_ERROR;
  5308.         }

  5310.         if (ngx_ssl_crl(cf, glcf->upstream.ssl, &glcf->ssl_crl) != NGX_OK) {
  5311.             return NGX_ERROR;
  5312.         }
  5313.     }

  5315.     if (ngx_ssl_client_session_cache(cf, glcf->upstream.ssl,
  5316.                                      glcf->upstream.ssl_session_reuse)
  5317.         != NGX_OK)
  5318.     {
  5319.         return NGX_ERROR;
  5320.     }

  5322. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  5324.     if (SSL_CTX_set_alpn_protos(glcf->upstream.ssl->ctx,
  5325.                                 (u_char *) "\x02h2", 3)
  5326.         != 0)
  5327.     {
  5328.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  5329.                       "SSL_CTX_set_alpn_protos() failed");
  5330.         return NGX_ERROR;
  5331.     }

  5333. #endif

  5335.     if (ngx_ssl_conf_commands(cf, glcf->upstream.ssl, glcf->ssl_conf_commands)
  5336.         != NGX_OK)
  5337.     {
  5338.         return NGX_ERROR;
  5339.     }

  5341.     return NGX_OK;
  5342. }

  5344. #endif

One Level Up Top Level