One Level Up Top Level

src/stream/ngx_stream_proxy_module.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Roman Arutyunyan
  4. * Copyright (C) Nginx, Inc.
  5. */


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


  13. ‌typedef struct {
  14.     ngx_addr_t                      *addr;
  15.     ngx_stream_complex_value_t      *value;
  16. #if (NGX_HAVE_TRANSPARENT_PROXY)
  17.     ngx_uint_t                       transparent; /* unsigned  transparent:1; */
  18. #endif
  19. ‌} ngx_stream_upstream_local_t;


  22. ‌typedef struct {
  23.     ngx_msec_t                       connect_timeout;
  24.     ngx_msec_t                       timeout;
  25.     ngx_msec_t                       next_upstream_timeout;
  26.     size_t                           buffer_size;
  27.     ngx_stream_complex_value_t      *upload_rate;
  28.     ngx_stream_complex_value_t      *download_rate;
  29.     ngx_uint_t                       requests;
  30.     ngx_uint_t                       responses;
  31.     ngx_uint_t                       next_upstream_tries;
  32.     ngx_flag_t                       next_upstream;
  33.     ngx_uint_t                       proxy_protocol;
  34.     ngx_flag_t                       half_close;
  35.     ngx_stream_upstream_local_t     *local;
  36.     ngx_flag_t                       socket_keepalive;
  37.     size_t                           socket_rcvbuf;
  38.     size_t                           socket_sndbuf;

  40. #if (NGX_STREAM_SSL)
  41.     ngx_flag_t                       ssl_enable;
  42.     ngx_flag_t                       ssl_session_reuse;
  43.     ngx_uint_t                       ssl_protocols;
  44.     ngx_str_t                        ssl_ciphers;
  45.     ngx_stream_complex_value_t      *ssl_name;
  46.     ngx_flag_t                       ssl_server_name;
  47.     ngx_array_t                     *ssl_alpn;

  49.     ngx_flag_t                       ssl_verify;
  50.     ngx_uint_t                       ssl_verify_depth;
  51.     ngx_str_t                        ssl_trusted_certificate;
  52.     ngx_str_t                        ssl_crl;
  53.     ngx_stream_complex_value_t      *ssl_certificate;
  54.     ngx_stream_complex_value_t      *ssl_certificate_key;
  55.     ngx_ssl_cache_t                 *ssl_certificate_cache;
  56.     ngx_array_t                     *ssl_passwords;
  57.     ngx_array_t                     *ssl_conf_commands;

  59.     ngx_ssl_t                       *ssl;
  60. #endif

  62.     ngx_stream_upstream_srv_conf_t  *upstream;
  63.     ngx_stream_complex_value_t      *upstream_value;
  64. ‌} ngx_stream_proxy_srv_conf_t;


  67. static void ngx_stream_proxy_handler(ngx_stream_session_t *s);
  68. static ngx_int_t ngx_stream_proxy_eval(ngx_stream_session_t *s,
  69.     ngx_stream_proxy_srv_conf_t *pscf);
  70. static ngx_int_t ngx_stream_proxy_set_local(ngx_stream_session_t *s,
  71.     ngx_stream_upstream_t *u, ngx_stream_upstream_local_t *local);
  72. static void ngx_stream_proxy_connect(ngx_stream_session_t *s);
  73. static void ngx_stream_proxy_init_upstream(ngx_stream_session_t *s);
  74. static void ngx_stream_proxy_resolve_handler(ngx_resolver_ctx_t *ctx);
  75. static void ngx_stream_proxy_upstream_handler(ngx_event_t *ev);
  76. static void ngx_stream_proxy_downstream_handler(ngx_event_t *ev);
  77. static void ngx_stream_proxy_process_connection(ngx_event_t *ev,
  78.     ngx_uint_t from_upstream);
  79. static void ngx_stream_proxy_connect_handler(ngx_event_t *ev);
  80. static ngx_int_t ngx_stream_proxy_test_connect(ngx_connection_t *c);
  81. static void ngx_stream_proxy_process(ngx_stream_session_t *s,
  82.     ngx_uint_t from_upstream, ngx_uint_t do_write);
  83. static ngx_int_t ngx_stream_proxy_test_finalize(ngx_stream_session_t *s,
  84.     ngx_uint_t from_upstream);
  85. static void ngx_stream_proxy_next_upstream(ngx_stream_session_t *s);
  86. static void ngx_stream_proxy_finalize(ngx_stream_session_t *s, ngx_uint_t rc);
  87. static u_char *ngx_stream_proxy_log_error(ngx_log_t *log, u_char *buf,
  88.     size_t len);

  90. static void *ngx_stream_proxy_create_srv_conf(ngx_conf_t *cf);
  91. static char *ngx_stream_proxy_merge_srv_conf(ngx_conf_t *cf, void *parent,
  92.     void *child);
  93. static char *ngx_stream_proxy_pass(ngx_conf_t *cf, ngx_command_t *cmd,
  94.     void *conf);
  95. static char *ngx_stream_proxy_bind(ngx_conf_t *cf, ngx_command_t *cmd,
  96.     void *conf);

  98. #if (NGX_STREAM_SSL)

  100. static ngx_int_t ngx_stream_proxy_send_proxy_protocol(ngx_stream_session_t *s);
  101. static char *ngx_stream_proxy_ssl_alpn_set_slot(ngx_conf_t *cf,
  102.     ngx_command_t *cmd, void *conf);
  103. static char *ngx_stream_proxy_ssl_certificate_cache(ngx_conf_t *cf,
  104.     ngx_command_t *cmd, void *conf);
  105. static char *ngx_stream_proxy_ssl_password_file(ngx_conf_t *cf,
  106.     ngx_command_t *cmd, void *conf);
  107. static char *ngx_stream_proxy_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  108.     void *data);
  109. static void ngx_stream_proxy_ssl_init_connection(ngx_stream_session_t *s);
  110. static void ngx_stream_proxy_ssl_handshake(ngx_connection_t *pc);
  111. static void ngx_stream_proxy_ssl_save_session(ngx_connection_t *c);
  112. static ngx_int_t ngx_stream_proxy_ssl_name(ngx_stream_session_t *s);
  113. static ngx_int_t ngx_stream_proxy_ssl_alpn(ngx_stream_session_t *s);
  114. static ngx_int_t ngx_stream_proxy_ssl_certificate(ngx_stream_session_t *s);
  115. static ngx_int_t ngx_stream_proxy_merge_ssl(ngx_conf_t *cf,
  116.     ngx_stream_proxy_srv_conf_t *conf, ngx_stream_proxy_srv_conf_t *prev);
  117. static ngx_int_t ngx_stream_proxy_merge_ssl_passwords(ngx_conf_t *cf,
  118.     ngx_stream_proxy_srv_conf_t *conf, ngx_stream_proxy_srv_conf_t *prev);
  119. static ngx_int_t ngx_stream_proxy_set_ssl(ngx_conf_t *cf,
  120.     ngx_stream_proxy_srv_conf_t *pscf);


  123. ‌static ngx_conf_bitmask_t  ngx_stream_proxy_ssl_protocols[] = {
  124.     { ngx_string("SSLv2"), NGX_SSL_SSLv2 },
  125.     { ngx_string("SSLv3"), NGX_SSL_SSLv3 },
  126.     { ngx_string("TLSv1"), NGX_SSL_TLSv1 },
  127.     { ngx_string("TLSv1.1"), NGX_SSL_TLSv1_1 },
  128.     { ngx_string("TLSv1.2"), NGX_SSL_TLSv1_2 },
  129.     { ngx_string("TLSv1.3"), NGX_SSL_TLSv1_3 },
  130.     { ngx_null_string, 0 }
  131. };

  133. ‌static ngx_conf_post_t  ngx_stream_proxy_ssl_conf_command_post =
  134.     { ngx_stream_proxy_ssl_conf_command_check };

  136. #endif


  139. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_proxy_downstream_buffer = {
  140.     ngx_conf_deprecated, "proxy_downstream_buffer", "proxy_buffer_size"
  141. };

  143. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_proxy_upstream_buffer = {
  144.     ngx_conf_deprecated, "proxy_upstream_buffer", "proxy_buffer_size"
  145. };


  148. ‌static ngx_conf_enum_t  ngx_stream_proxy_protocol_versions[] = {
  149.     { ngx_string("off"), 0 },
  150.     { ngx_string("on"), 1 },
  151.     { ngx_string("v2"), 2 },
  152.     { ngx_null_string, 0 }
  153. };


  156. ‌static ngx_command_t  ngx_stream_proxy_commands[] = {

  158.     { ngx_string("proxy_pass"),
  159.       NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  160.       ngx_stream_proxy_pass,
  161.       NGX_STREAM_SRV_CONF_OFFSET,
  162.       0,
  163.       NULL },

  165.     { ngx_string("proxy_bind"),
  166.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE12,
  167.       ngx_stream_proxy_bind,
  168.       NGX_STREAM_SRV_CONF_OFFSET,
  169.       0,
  170.       NULL },

  172.     { ngx_string("proxy_socket_keepalive"),
  173.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  174.       ngx_conf_set_flag_slot,
  175.       NGX_STREAM_SRV_CONF_OFFSET,
  176.       offsetof(ngx_stream_proxy_srv_conf_t, socket_keepalive),
  177.       NULL },

  179.     { ngx_string("proxy_socket_rcvbuf"),
  180.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  181.       ngx_conf_set_size_slot,
  182.       NGX_STREAM_SRV_CONF_OFFSET,
  183.       offsetof(ngx_stream_proxy_srv_conf_t, socket_rcvbuf),
  184.       NULL },

  186.     { ngx_string("proxy_socket_sndbuf"),
  187.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  188.       ngx_conf_set_size_slot,
  189.       NGX_STREAM_SRV_CONF_OFFSET,
  190.       offsetof(ngx_stream_proxy_srv_conf_t, socket_sndbuf),
  191.       NULL },

  193.     { ngx_string("proxy_connect_timeout"),
  194.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  195.       ngx_conf_set_msec_slot,
  196.       NGX_STREAM_SRV_CONF_OFFSET,
  197.       offsetof(ngx_stream_proxy_srv_conf_t, connect_timeout),
  198.       NULL },

  200.     { ngx_string("proxy_timeout"),
  201.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  202.       ngx_conf_set_msec_slot,
  203.       NGX_STREAM_SRV_CONF_OFFSET,
  204.       offsetof(ngx_stream_proxy_srv_conf_t, timeout),
  205.       NULL },

  207.     { ngx_string("proxy_buffer_size"),
  208.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  209.       ngx_conf_set_size_slot,
  210.       NGX_STREAM_SRV_CONF_OFFSET,
  211.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  212.       NULL },

  214.     { ngx_string("proxy_downstream_buffer"),
  215.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  216.       ngx_conf_set_size_slot,
  217.       NGX_STREAM_SRV_CONF_OFFSET,
  218.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  219.       &ngx_conf_deprecated_proxy_downstream_buffer },

  221.     { ngx_string("proxy_upstream_buffer"),
  222.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  223.       ngx_conf_set_size_slot,
  224.       NGX_STREAM_SRV_CONF_OFFSET,
  225.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  226.       &ngx_conf_deprecated_proxy_upstream_buffer },

  228.     { ngx_string("proxy_upload_rate"),
  229.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  230.       ngx_stream_set_complex_value_size_slot,
  231.       NGX_STREAM_SRV_CONF_OFFSET,
  232.       offsetof(ngx_stream_proxy_srv_conf_t, upload_rate),
  233.       NULL },

  235.     { ngx_string("proxy_download_rate"),
  236.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  237.       ngx_stream_set_complex_value_size_slot,
  238.       NGX_STREAM_SRV_CONF_OFFSET,
  239.       offsetof(ngx_stream_proxy_srv_conf_t, download_rate),
  240.       NULL },

  242.     { ngx_string("proxy_requests"),
  243.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  244.       ngx_conf_set_num_slot,
  245.       NGX_STREAM_SRV_CONF_OFFSET,
  246.       offsetof(ngx_stream_proxy_srv_conf_t, requests),
  247.       NULL },

  249.     { ngx_string("proxy_responses"),
  250.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  251.       ngx_conf_set_num_slot,
  252.       NGX_STREAM_SRV_CONF_OFFSET,
  253.       offsetof(ngx_stream_proxy_srv_conf_t, responses),
  254.       NULL },

  256.     { ngx_string("proxy_next_upstream"),
  257.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  258.       ngx_conf_set_flag_slot,
  259.       NGX_STREAM_SRV_CONF_OFFSET,
  260.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream),
  261.       NULL },

  263.     { ngx_string("proxy_next_upstream_tries"),
  264.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  265.       ngx_conf_set_num_slot,
  266.       NGX_STREAM_SRV_CONF_OFFSET,
  267.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream_tries),
  268.       NULL },

  270.     { ngx_string("proxy_next_upstream_timeout"),
  271.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  272.       ngx_conf_set_msec_slot,
  273.       NGX_STREAM_SRV_CONF_OFFSET,
  274.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream_timeout),
  275.       NULL },

  277.     { ngx_string("proxy_protocol"),
  278.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  279.       ngx_conf_set_enum_slot,
  280.       NGX_STREAM_SRV_CONF_OFFSET,
  281.       offsetof(ngx_stream_proxy_srv_conf_t, proxy_protocol),
  282.       &ngx_stream_proxy_protocol_versions },

  284.     { ngx_string("proxy_half_close"),
  285.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  286.       ngx_conf_set_flag_slot,
  287.       NGX_STREAM_SRV_CONF_OFFSET,
  288.       offsetof(ngx_stream_proxy_srv_conf_t, half_close),
  289.       NULL },

  291. #if (NGX_STREAM_SSL)

  293.     { ngx_string("proxy_ssl"),
  294.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  295.       ngx_conf_set_flag_slot,
  296.       NGX_STREAM_SRV_CONF_OFFSET,
  297.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_enable),
  298.       NULL },

  300.     { ngx_string("proxy_ssl_session_reuse"),
  301.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  302.       ngx_conf_set_flag_slot,
  303.       NGX_STREAM_SRV_CONF_OFFSET,
  304.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_session_reuse),
  305.       NULL },

  307.     { ngx_string("proxy_ssl_protocols"),
  308.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  309.       ngx_conf_set_bitmask_slot,
  310.       NGX_STREAM_SRV_CONF_OFFSET,
  311.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_protocols),
  312.       &ngx_stream_proxy_ssl_protocols },

  314.     { ngx_string("proxy_ssl_ciphers"),
  315.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  316.       ngx_conf_set_str_slot,
  317.       NGX_STREAM_SRV_CONF_OFFSET,
  318.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_ciphers),
  319.       NULL },

  321.     { ngx_string("proxy_ssl_name"),
  322.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  323.       ngx_stream_set_complex_value_slot,
  324.       NGX_STREAM_SRV_CONF_OFFSET,
  325.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_name),
  326.       NULL },

  328.     { ngx_string("proxy_ssl_server_name"),
  329.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  330.       ngx_conf_set_flag_slot,
  331.       NGX_STREAM_SRV_CONF_OFFSET,
  332.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_server_name),
  333.       NULL },

  335.     { ngx_string("proxy_ssl_alpn"),
  336.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  337.       ngx_stream_proxy_ssl_alpn_set_slot,
  338.       NGX_STREAM_SRV_CONF_OFFSET,
  339.       0,
  340.       NULL },

  342.     { ngx_string("proxy_ssl_verify"),
  343.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  344.       ngx_conf_set_flag_slot,
  345.       NGX_STREAM_SRV_CONF_OFFSET,
  346.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_verify),
  347.       NULL },

  349.     { ngx_string("proxy_ssl_verify_depth"),
  350.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  351.       ngx_conf_set_num_slot,
  352.       NGX_STREAM_SRV_CONF_OFFSET,
  353.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_verify_depth),
  354.       NULL },

  356.     { ngx_string("proxy_ssl_trusted_certificate"),
  357.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  358.       ngx_conf_set_str_slot,
  359.       NGX_STREAM_SRV_CONF_OFFSET,
  360.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_trusted_certificate),
  361.       NULL },

  363.     { ngx_string("proxy_ssl_crl"),
  364.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  365.       ngx_conf_set_str_slot,
  366.       NGX_STREAM_SRV_CONF_OFFSET,
  367.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_crl),
  368.       NULL },

  370.     { ngx_string("proxy_ssl_certificate"),
  371.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  372.       ngx_stream_set_complex_value_zero_slot,
  373.       NGX_STREAM_SRV_CONF_OFFSET,
  374.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_certificate),
  375.       NULL },

  377.     { ngx_string("proxy_ssl_certificate_key"),
  378.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  379.       ngx_stream_set_complex_value_zero_slot,
  380.       NGX_STREAM_SRV_CONF_OFFSET,
  381.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_certificate_key),
  382.       NULL },

  384.     { ngx_string("proxy_ssl_certificate_cache"),
  385.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE123,
  386.       ngx_stream_proxy_ssl_certificate_cache,
  387.       NGX_STREAM_SRV_CONF_OFFSET,
  388.       0,
  389.       NULL },

  391.     { ngx_string("proxy_ssl_password_file"),
  392.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  393.       ngx_stream_proxy_ssl_password_file,
  394.       NGX_STREAM_SRV_CONF_OFFSET,
  395.       0,
  396.       NULL },

  398.     { ngx_string("proxy_ssl_conf_command"),
  399.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE2,
  400.       ngx_conf_set_keyval_slot,
  401.       NGX_STREAM_SRV_CONF_OFFSET,
  402.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_conf_commands),
  403.       &ngx_stream_proxy_ssl_conf_command_post },

  405. #endif

  407.       ngx_null_command
  408. };


  411. ‌static ngx_stream_module_t  ngx_stream_proxy_module_ctx = {
  412.     NULL,                                  /* preconfiguration */
  413.     NULL,                                  /* postconfiguration */

  415.     NULL,                                  /* create main configuration */
  416.     NULL,                                  /* init main configuration */

  418.     ngx_stream_proxy_create_srv_conf,      /* create server configuration */
  419.     ngx_stream_proxy_merge_srv_conf        /* merge server configuration */
  420. };


  423. ‌ngx_module_t  ngx_stream_proxy_module = {
  424.     NGX_MODULE_V1,
  425.     &ngx_stream_proxy_module_ctx,          /* module context */
  426.     ngx_stream_proxy_commands,             /* module directives */
  427.     NGX_STREAM_MODULE,                     /* module type */
  428.     NULL,                                  /* init master */
  429.     NULL,                                  /* init module */
  430.     NULL,                                  /* init process */
  431.     NULL,                                  /* init thread */
  432.     NULL,                                  /* exit thread */
  433.     NULL,                                  /* exit process */
  434.     NULL,                                  /* exit master */
  435.     NGX_MODULE_V1_PADDING
  436. };


  439. static void
  440. ‌ngx_stream_proxy_handler(ngx_stream_session_t *s)
  441. {
  442.     u_char                           *p;
  443.     ngx_str_t                        *host;
  444.     ngx_uint_t                        i;
  445.     ngx_connection_t                 *c;
  446.     ngx_resolver_ctx_t               *ctx, temp;
  447.     ngx_stream_upstream_t            *u;
  448.     ngx_stream_core_srv_conf_t       *cscf;
  449.     ngx_stream_proxy_srv_conf_t      *pscf;
  450.     ngx_stream_upstream_srv_conf_t   *uscf, **uscfp;
  451.     ngx_stream_upstream_main_conf_t  *umcf;

  453.     c = s->connection;

  455.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  457.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  458.                    "proxy connection handler");

  460.     u = ngx_pcalloc(c->pool, sizeof(ngx_stream_upstream_t));
  461.     if (u == NULL) {
  462.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  463.         return;
  464.     }

  466.     s->upstream = u;

  468.     s->log_handler = ngx_stream_proxy_log_error;

  470.     u->requests = 1;

  472.     u->peer.log = c->log;
  473.     u->peer.log_error = NGX_ERROR_ERR;

  475.     if (ngx_stream_proxy_set_local(s, u, pscf->local) != NGX_OK) {
  476.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  477.         return;
  478.     }

  480.     if (pscf->socket_keepalive) {
  481.         u->peer.so_keepalive = 1;
  482.     }

  484.     if (pscf->socket_rcvbuf) {
  485.         u->peer.rcvbuf = (int) pscf->socket_rcvbuf;
  486.     }

  488.     if (pscf->socket_sndbuf) {
  489.         u->peer.sndbuf = (int) pscf->socket_sndbuf;
  490.     }

  492.     u->peer.type = c->type;
  493.     u->start_sec = ngx_time();

  495.     c->write->handler = ngx_stream_proxy_downstream_handler;
  496.     c->read->handler = ngx_stream_proxy_downstream_handler;

  498.     s->upstream_states = ngx_array_create(c->pool, 1,
  499.                                           sizeof(ngx_stream_upstream_state_t));
  500.     if (s->upstream_states == NULL) {
  501.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  502.         return;
  503.     }

  505.     p = ngx_pnalloc(c->pool, pscf->buffer_size);
  506.     if (p == NULL) {
  507.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  508.         return;
  509.     }

  511.     u->downstream_buf.start = p;
  512.     u->downstream_buf.end = p + pscf->buffer_size;
  513.     u->downstream_buf.pos = p;
  514.     u->downstream_buf.last = p;

  516.     if (c->read->ready) {
  517.         ngx_post_event(c->read, &ngx_posted_events);
  518.     }

  520.     if (pscf->upstream_value) {
  521.         if (ngx_stream_proxy_eval(s, pscf) != NGX_OK) {
  522.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  523.             return;
  524.         }
  525.     }

  527.     if (u->resolved == NULL) {

  529.         uscf = pscf->upstream;

  531.     } else {

  533. #if (NGX_STREAM_SSL)
  534.         u->ssl_name = u->resolved->host;
  535. #endif

  537.         host = &u->resolved->host;

  539.         umcf = ngx_stream_get_module_main_conf(s, ngx_stream_upstream_module);

  541.         uscfp = umcf->upstreams.elts;

  543.         for (i = 0; i < umcf->upstreams.nelts; i++) {

  545.             uscf = uscfp[i];

  547.             if (uscf->host.len == host->len
  548.                 && ((uscf->port == 0 && u->resolved->no_port)
  549.                      || uscf->port == u->resolved->port)
  550.                 && ngx_strncasecmp(uscf->host.data, host->data, host->len) == 0)
  551.             {
  552.                 goto found;
  553.             }
  554.         }

  556.         if (u->resolved->sockaddr) {

  558.             if (u->resolved->port == 0
  559.                 && u->resolved->sockaddr->sa_family != AF_UNIX)
  560.             {
  561.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  562.                               "no port in upstream \"%V\"", host);
  563.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  564.                 return;
  565.             }

  567.             if (ngx_stream_upstream_create_round_robin_peer(s, u->resolved)
  568.                 != NGX_OK)
  569.             {
  570.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  571.                 return;
  572.             }

  574.             ngx_stream_proxy_connect(s);

  576.             return;
  577.         }

  579.         if (u->resolved->port == 0) {
  580.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  581.                           "no port in upstream \"%V\"", host);
  582.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  583.             return;
  584.         }

  586.         temp.name = *host;

  588.         cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  590.         ctx = ngx_resolve_start(cscf->resolver, &temp);
  591.         if (ctx == NULL) {
  592.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  593.             return;
  594.         }

  596.         if (ctx == NGX_NO_RESOLVER) {
  597.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  598.                           "no resolver defined to resolve %V", host);
  599.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  600.             return;
  601.         }

  603.         ctx->name = *host;
  604.         ctx->handler = ngx_stream_proxy_resolve_handler;
  605.         ctx->data = s;
  606.         ctx->timeout = cscf->resolver_timeout;

  608.         u->resolved->ctx = ctx;

  610.         if (ngx_resolve_name(ctx) != NGX_OK) {
  611.             u->resolved->ctx = NULL;
  612.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  613.             return;
  614.         }

  616.         return;
  617.     }

  619. found:

  621.     if (uscf == NULL) {
  622.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "no upstream configuration");
  623.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  624.         return;
  625.     }

  627.     u->upstream = uscf;

  629. #if (NGX_STREAM_SSL)
  630.     u->ssl_name = uscf->host;
  631. #endif

  633.     if (uscf->peer.init(s, uscf) != NGX_OK) {
  634.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  635.         return;
  636.     }

  638.     u->peer.start_time = ngx_current_msec;

  640.     if (pscf->next_upstream_tries
  641.         && u->peer.tries > pscf->next_upstream_tries)
  642.     {
  643.         u->peer.tries = pscf->next_upstream_tries;
  644.     }

  646.     ngx_stream_proxy_connect(s);
  647. }


  650. static ngx_int_t
  651. ‌ngx_stream_proxy_eval(ngx_stream_session_t *s,
  652.     ngx_stream_proxy_srv_conf_t *pscf)
  653. {
  654.     ngx_str_t               host;
  655.     ngx_url_t               url;
  656.     ngx_stream_upstream_t  *u;

  658.     if (ngx_stream_complex_value(s, pscf->upstream_value, &host) != NGX_OK) {
  659.         return NGX_ERROR;
  660.     }

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

  664.     url.url = host;
  665.     url.no_resolve = 1;

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

  673.         return NGX_ERROR;
  674.     }

  676.     u = s->upstream;

  678.     u->resolved = ngx_pcalloc(s->connection->pool,
  679.                               sizeof(ngx_stream_upstream_resolved_t));
  680.     if (u->resolved == NULL) {
  681.         return NGX_ERROR;
  682.     }

  684.     if (url.addrs) {
  685.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  686.         u->resolved->socklen = url.addrs[0].socklen;
  687.         u->resolved->name = url.addrs[0].name;
  688.         u->resolved->naddrs = 1;
  689.     }

  691.     u->resolved->host = url.host;
  692.     u->resolved->port = url.port;
  693.     u->resolved->no_port = url.no_port;

  695.     return NGX_OK;
  696. }


  699. static ngx_int_t
  700. ‌ngx_stream_proxy_set_local(ngx_stream_session_t *s, ngx_stream_upstream_t *u,
  701.     ngx_stream_upstream_local_t *local)
  702. {
  703.     ngx_int_t    rc;
  704.     ngx_str_t    val;
  705.     ngx_addr_t  *addr;

  707.     if (local == NULL) {
  708.         u->peer.local = NULL;
  709.         return NGX_OK;
  710.     }

  712. #if (NGX_HAVE_TRANSPARENT_PROXY)
  713.     u->peer.transparent = local->transparent;
  714. #endif

  716.     if (local->value == NULL) {
  717.         u->peer.local = local->addr;
  718.         return NGX_OK;
  719.     }

  721.     if (ngx_stream_complex_value(s, local->value, &val) != NGX_OK) {
  722.         return NGX_ERROR;
  723.     }

  725.     if (val.len == 0) {
  726.         u->peer.local = NULL;
  727.         return NGX_OK;
  728.     }

  730.     addr = ngx_palloc(s->connection->pool, sizeof(ngx_addr_t));
  731.     if (addr == NULL) {
  732.         return NGX_ERROR;
  733.     }

  735.     rc = ngx_parse_addr_port(s->connection->pool, addr, val.data, val.len);
  736.     if (rc == NGX_ERROR) {
  737.         return NGX_ERROR;
  738.     }

  740.     if (rc != NGX_OK) {
  741.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  742.                       "invalid local address \"%V\"", &val);
  743.         u->peer.local = NULL;
  744.         return NGX_OK;
  745.     }

  747.     addr->name = val;
  748.     u->peer.local = addr;

  750.     return NGX_OK;
  751. }


  754. static void
  755. ‌ngx_stream_proxy_connect(ngx_stream_session_t *s)
  756. {
  757.     ngx_int_t                     rc;
  758.     ngx_connection_t             *c, *pc;
  759.     ngx_stream_upstream_t        *u;
  760.     ngx_stream_proxy_srv_conf_t  *pscf;

  762.     c = s->connection;

  764.     c->log->action = "connecting to upstream";

  766.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  768.     u = s->upstream;

  770.     u->connected = 0;
  771.     u->proxy_protocol = pscf->proxy_protocol;

  773.     if (u->state) {
  774.         u->state->response_time = ngx_current_msec - u->start_time;
  775.     }

  777.     u->state = ngx_array_push(s->upstream_states);
  778.     if (u->state == NULL) {
  779.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  780.         return;
  781.     }

  783.     ngx_memzero(u->state, sizeof(ngx_stream_upstream_state_t));

  785.     u->start_time = ngx_current_msec;

  787.     u->state->connect_time = (ngx_msec_t) -1;
  788.     u->state->first_byte_time = (ngx_msec_t) -1;
  789.     u->state->response_time = (ngx_msec_t) -1;

  791.     rc = ngx_event_connect_peer(&u->peer);

  793.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0, "proxy connect: %i", rc);

  795.     if (rc == NGX_ERROR) {
  796.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  797.         return;
  798.     }

  800.     u->state->peer = u->peer.name;

  802. #if (NGX_STREAM_UPSTREAM_ZONE)
  803.     if (u->upstream && u->upstream->shm_zone
  804.         && (u->upstream->flags & NGX_STREAM_UPSTREAM_MODIFY))
  805.     {
  806.         u->state->peer = ngx_palloc(s->connection->pool,
  807.                                     sizeof(ngx_str_t) + u->peer.name->len);
  808.         if (u->state->peer == NULL) {
  809.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  810.             return;
  811.         }

  813.         u->state->peer->len = u->peer.name->len;
  814.         u->state->peer->data = (u_char *) (u->state->peer + 1);
  815.         ngx_memcpy(u->state->peer->data, u->peer.name->data, u->peer.name->len);

  817.         u->peer.name = u->state->peer;
  818.     }
  819. #endif

  821.     if (rc == NGX_BUSY) {
  822.         ngx_log_error(NGX_LOG_ERR, c->log, 0, "no live upstreams");
  823.         ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);
  824.         return;
  825.     }

  827.     if (rc == NGX_DECLINED) {
  828.         ngx_stream_proxy_next_upstream(s);
  829.         return;
  830.     }

  832.     /* rc == NGX_OK || rc == NGX_AGAIN || rc == NGX_DONE */

  834.     pc = u->peer.connection;

  836.     pc->data = s;
  837.     pc->log = c->log;
  838.     pc->pool = c->pool;
  839.     pc->read->log = c->log;
  840.     pc->write->log = c->log;

  842.     if (rc != NGX_AGAIN) {
  843.         ngx_stream_proxy_init_upstream(s);
  844.         return;
  845.     }

  847.     pc->read->handler = ngx_stream_proxy_connect_handler;
  848.     pc->write->handler = ngx_stream_proxy_connect_handler;

  850.     ngx_add_timer(pc->write, pscf->connect_timeout);
  851. }


  854. static void
  855. ‌ngx_stream_proxy_init_upstream(ngx_stream_session_t *s)
  856. {
  857.     u_char                       *p;
  858.     size_t                        size;
  859.     ngx_chain_t                  *cl;
  860.     ngx_connection_t             *c, *pc;
  861.     ngx_log_handler_pt            handler;
  862.     ngx_stream_upstream_t        *u;
  863.     ngx_stream_core_srv_conf_t   *cscf;
  864.     ngx_stream_proxy_srv_conf_t  *pscf;
  865.     static u_char                 buf[NGX_PROXY_PROTOCOL_MAX_HEADER];

  867.     u = s->upstream;
  868.     pc = u->peer.connection;

  870.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  872.     if (pc->type == SOCK_STREAM
  873.         && cscf->tcp_nodelay
  874.         && ngx_tcp_nodelay(pc) != NGX_OK)
  875.     {
  876.         ngx_stream_proxy_next_upstream(s);
  877.         return;
  878.     }

  880.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  882. #if (NGX_STREAM_SSL)

  884.     if (pc->type == SOCK_STREAM && pscf->ssl_enable) {

  886.         if (u->proxy_protocol) {
  887.             if (ngx_stream_proxy_send_proxy_protocol(s) != NGX_OK) {
  888.                 return;
  889.             }

  891.             u->proxy_protocol = 0;
  892.         }

  894.         if (pc->ssl == NULL) {
  895.             ngx_stream_proxy_ssl_init_connection(s);
  896.             return;
  897.         }
  898.     }

  900. #endif

  902.     c = s->connection;

  904.     if (c->log->log_level >= NGX_LOG_INFO) {
  905.         ngx_str_t  str;
  906.         u_char     addr[NGX_SOCKADDR_STRLEN];

  908.         str.len = NGX_SOCKADDR_STRLEN;
  909.         str.data = addr;

  911.         if (ngx_connection_local_sockaddr(pc, &str, 1) == NGX_OK) {
  912.             handler = c->log->handler;
  913.             c->log->handler = NULL;

  915.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  916.                           "%sproxy %V connected to %V",
  917.                           pc->type == SOCK_DGRAM ? "udp " : "",
  918.                           &str, u->peer.name);

  920.             c->log->handler = handler;
  921.         }
  922.     }

  924.     u->state->connect_time = ngx_current_msec - u->start_time;

  926.     if (u->peer.notify) {
  927.         u->peer.notify(&u->peer, u->peer.data,
  928.                        NGX_STREAM_UPSTREAM_NOTIFY_CONNECT);
  929.     }

  931.     if (u->upstream_buf.start == NULL) {
  932.         p = ngx_pnalloc(c->pool, pscf->buffer_size);
  933.         if (p == NULL) {
  934.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  935.             return;
  936.         }

  938.         u->upstream_buf.start = p;
  939.         u->upstream_buf.end = p + pscf->buffer_size;
  940.         u->upstream_buf.pos = p;
  941.         u->upstream_buf.last = p;
  942.     }

  944.     if (c->buffer && c->buffer->pos <= c->buffer->last) {
  945.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  946.                        "stream proxy add preread buffer: %uz",
  947.                        c->buffer->last - c->buffer->pos);

  949.         cl = ngx_chain_get_free_buf(c->pool, &u->free);
  950.         if (cl == NULL) {
  951.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  952.             return;
  953.         }

  955.         *cl->buf = *c->buffer;

  957.         cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;
  958.         cl->buf->temporary = (cl->buf->pos == cl->buf->last) ? 0 : 1;
  959.         cl->buf->flush = 1;

  961.         cl->next = u->upstream_out;
  962.         u->upstream_out = cl;
  963.     }

  965.     if (u->proxy_protocol) {
  966.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  967.                        "stream proxy add PROXY protocol header");

  969.         if (u->proxy_protocol == 2) {
  970.             p = ngx_proxy_protocol_v2_write(c, buf, buf + sizeof(buf), NULL);

  972.         } else {
  973.             p = ngx_proxy_protocol_write(c, buf, buf + sizeof(buf));
  974.         }

  976.         if (p == NULL) {
  977.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  978.             return;
  979.         }

  981.         size = p - buf;

  983.         p = ngx_pnalloc(c->pool, size);
  984.         if (p == NULL) {
  985.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  986.             return;
  987.         }

  989.         ngx_memcpy(p, buf, size);

  991.         cl = ngx_chain_get_free_buf(c->pool, &u->free);
  992.         if (cl == NULL) {
  993.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  994.             return;
  995.         }

  997.         cl->buf->pos = p;
  998.         cl->buf->last = p + size;

  1000.         cl->buf->temporary = 1;
  1001.         cl->buf->flush = 0;
  1002.         cl->buf->last_buf = 0;
  1003.         cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;

  1005.         cl->next = u->upstream_out;
  1006.         u->upstream_out = cl;

  1008.         u->proxy_protocol = 0;
  1009.     }

  1011.     u->upload_rate = ngx_stream_complex_value_size(s, pscf->upload_rate, 0);
  1012.     u->download_rate = ngx_stream_complex_value_size(s, pscf->download_rate, 0);

  1014.     u->connected = 1;

  1016.     pc->read->handler = ngx_stream_proxy_upstream_handler;
  1017.     pc->write->handler = ngx_stream_proxy_upstream_handler;

  1019.     if (pc->read->ready) {
  1020.         ngx_post_event(pc->read, &ngx_posted_events);
  1021.     }

  1023.     ngx_stream_proxy_process(s, 0, 1);
  1024. }


  1027. #if (NGX_STREAM_SSL)

  1029. static ngx_int_t
  1030. ‌ngx_stream_proxy_send_proxy_protocol(ngx_stream_session_t *s)
  1031. {
  1032.     u_char                       *p;
  1033.     size_t                        size;
  1034.     ssize_t                       n;
  1035.     ngx_connection_t             *c, *pc;
  1036.     ngx_stream_upstream_t        *u;
  1037.     ngx_stream_proxy_srv_conf_t  *pscf;
  1038.     static u_char                 buf[NGX_PROXY_PROTOCOL_MAX_HEADER];

  1040.     c = s->connection;

  1042.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  1043.                    "stream proxy send PROXY protocol header");

  1045.     u = s->upstream;

  1047.     if (u->proxy_protocol == 2) {
  1048.         p = ngx_proxy_protocol_v2_write(c, buf, buf + sizeof(buf), NULL);

  1050.     } else {
  1051.         p = ngx_proxy_protocol_write(c, buf, buf + sizeof(buf));
  1052.     }

  1054.     if (p == NULL) {
  1055.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1056.         return NGX_ERROR;
  1057.     }

  1059.     pc = u->peer.connection;

  1061.     size = p - buf;

  1063.     n = pc->send(pc, buf, size);

  1065.     if (n == NGX_AGAIN) {
  1066.         if (ngx_handle_write_event(pc->write, 0) != NGX_OK) {
  1067.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1068.             return NGX_ERROR;
  1069.         }

  1071.         pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1073.         ngx_add_timer(pc->write, pscf->timeout);

  1075.         pc->write->handler = ngx_stream_proxy_connect_handler;

  1077.         return NGX_AGAIN;
  1078.     }

  1080.     if (n == NGX_ERROR) {
  1081.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1082.         return NGX_ERROR;
  1083.     }

  1085.     if (n != (ssize_t) size) {

  1087.         /*
  1088.          * PROXY protocol specification:
  1089.          * The sender must always ensure that the header
  1090.          * is sent at once, so that the transport layer
  1091.          * maintains atomicity along the path to the receiver.
  1092.          */

  1094.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1095.                       "could not send PROXY protocol header at once");

  1097.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);

  1099.         return NGX_ERROR;
  1100.     }

  1102.     return NGX_OK;
  1103. }


  1106. static char *
  1107. ‌ngx_stream_proxy_ssl_alpn_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  1108.     void *conf)
  1109. {
  1110. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1112.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  1114.     ngx_str_t                           *value;
  1115.     ngx_uint_t                           i;
  1116.     ngx_stream_complex_value_t          *cv;
  1117.     ngx_stream_compile_complex_value_t   ccv;

  1119.     if (pscf->ssl_alpn != NGX_CONF_UNSET_PTR) {
  1120.         return "is duplicate";
  1121.     }

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

  1125.     pscf->ssl_alpn = ngx_array_create(cf->pool, cf->args->nelts - 1,
  1126.                                       sizeof(ngx_stream_complex_value_t));
  1127.     if (pscf->ssl_alpn == NULL) {
  1128.         return NGX_CONF_ERROR;
  1129.     }

  1131.     cv = ngx_array_push_n(pscf->ssl_alpn, cf->args->nelts - 1);

  1133.     for (i = 1; i < cf->args->nelts; i++) {
  1134.         ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

  1136.         ccv.cf = cf;
  1137.         ccv.value = &value[i];
  1138.         ccv.complex_value = &cv[i - 1];

  1140.         if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1141.             return NGX_CONF_ERROR;
  1142.         }

  1144.         if (cv[i - 1].lengths == NULL && value[i].len > 255) {
  1145.             return "protocol too long";
  1146.         }
  1147.     }

  1149.     return NGX_CONF_OK;

  1151. #else
  1152.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1153.                        "the \"proxy_ssl_alpn\" directive requires "
  1154.                        "OpenSSL with ALPN support");

  1156.     return NGX_CONF_ERROR;
  1157. #endif
  1158. }


  1161. static char *
  1162. ‌ngx_stream_proxy_ssl_certificate_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  1163.     void *conf)
  1164. {
  1165.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  1167.     time_t       inactive, valid;
  1168.     ngx_str_t   *value, s;
  1169.     ngx_int_t    max;
  1170.     ngx_uint_t   i;

  1172.     if (pscf->ssl_certificate_cache != NGX_CONF_UNSET_PTR) {
  1173.         return "is duplicate";
  1174.     }

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

  1178.     max = 0;
  1179.     inactive = 10;
  1180.     valid = 60;

  1182.     for (i = 1; i < cf->args->nelts; i++) {

  1184.         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {

  1186.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  1187.             if (max <= 0) {
  1188.                 goto failed;
  1189.             }

  1191.             continue;
  1192.         }

  1194.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  1196.             s.len = value[i].len - 9;
  1197.             s.data = value[i].data + 9;

  1199.             inactive = ngx_parse_time(&s, 1);
  1200.             if (inactive == (time_t) NGX_ERROR) {
  1201.                 goto failed;
  1202.             }

  1204.             continue;
  1205.         }

  1207.         if (ngx_strncmp(value[i].data, "valid=", 6) == 0) {

  1209.             s.len = value[i].len - 6;
  1210.             s.data = value[i].data + 6;

  1212.             valid = ngx_parse_time(&s, 1);
  1213.             if (valid == (time_t) NGX_ERROR) {
  1214.                 goto failed;
  1215.             }

  1217.             continue;
  1218.         }

  1220.         if (ngx_strcmp(value[i].data, "off") == 0) {

  1222.             pscf->ssl_certificate_cache = NULL;

  1224.             continue;
  1225.         }

  1227.     failed:

  1229.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1230.                            "invalid parameter \"%V\"", &value[i]);
  1231.         return NGX_CONF_ERROR;
  1232.     }

  1234.     if (pscf->ssl_certificate_cache == NULL) {
  1235.         return NGX_CONF_OK;
  1236.     }

  1238.     if (max == 0) {
  1239.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1240.                            "\"proxy_ssl_certificate_cache\" must have "
  1241.                            "the \"max\" parameter");
  1242.         return NGX_CONF_ERROR;
  1243.     }

  1245.     pscf->ssl_certificate_cache = ngx_ssl_cache_init(cf->pool, max, valid,
  1246.                                                      inactive);
  1247.     if (pscf->ssl_certificate_cache == NULL) {
  1248.         return NGX_CONF_ERROR;
  1249.     }

  1251.     return NGX_CONF_OK;
  1252. }


  1255. static char *
  1256. ‌ngx_stream_proxy_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd,
  1257.     void *conf)
  1258. {
  1259.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  1261.     ngx_str_t  *value;

  1263.     if (pscf->ssl_passwords != NGX_CONF_UNSET_PTR) {
  1264.         return "is duplicate";
  1265.     }

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

  1269.     pscf->ssl_passwords = ngx_ssl_read_password_file(cf, &value[1]);

  1271.     if (pscf->ssl_passwords == NULL) {
  1272.         return NGX_CONF_ERROR;
  1273.     }

  1275.     return NGX_CONF_OK;
  1276. }


  1279. static char *
  1280. ‌ngx_stream_proxy_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  1281. {
  1282. #ifndef SSL_CONF_FLAG_FILE
  1283.     return "is not supported on this platform";
  1284. #else
  1285.     return NGX_CONF_OK;
  1286. #endif
  1287. }


  1290. static void
  1291. ‌ngx_stream_proxy_ssl_init_connection(ngx_stream_session_t *s)
  1292. {
  1293.     ngx_int_t                     rc;
  1294.     ngx_connection_t             *pc;
  1295.     ngx_stream_upstream_t        *u;
  1296.     ngx_stream_proxy_srv_conf_t  *pscf;

  1298.     u = s->upstream;

  1300.     pc = u->peer.connection;

  1302.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1304.     if (ngx_ssl_create_connection(pscf->ssl, pc, NGX_SSL_BUFFER|NGX_SSL_CLIENT)
  1305.         != NGX_OK)
  1306.     {
  1307.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1308.         return;
  1309.     }

  1311.     if (pscf->ssl_server_name || pscf->ssl_verify) {
  1312.         if (ngx_stream_proxy_ssl_name(s) != NGX_OK) {
  1313.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1314.             return;
  1315.         }
  1316.     }

  1318.     if (pscf->ssl_alpn) {
  1319.         if (ngx_stream_proxy_ssl_alpn(s) != NGX_OK) {
  1320.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1321.             return;
  1322.         }
  1323.     }

  1325.     if (pscf->ssl_certificate
  1326.         && pscf->ssl_certificate->value.len
  1327.         && (pscf->ssl_certificate->lengths
  1328.             || pscf->ssl_certificate_key->lengths))
  1329.     {
  1330.         if (ngx_stream_proxy_ssl_certificate(s) != NGX_OK) {
  1331.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1332.             return;
  1333.         }
  1334.     }

  1336.     if (pscf->ssl_session_reuse) {
  1337.         pc->ssl->save_session = ngx_stream_proxy_ssl_save_session;

  1339.         if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
  1340.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1341.             return;
  1342.         }
  1343.     }

  1345.     s->connection->log->action = "SSL handshaking to upstream";

  1347.     rc = ngx_ssl_handshake(pc);

  1349.     if (rc == NGX_AGAIN) {

  1351.         if (!pc->write->timer_set) {
  1352.             ngx_add_timer(pc->write, pscf->connect_timeout);
  1353.         }

  1355.         pc->ssl->handler = ngx_stream_proxy_ssl_handshake;
  1356.         return;
  1357.     }

  1359.     ngx_stream_proxy_ssl_handshake(pc);
  1360. }


  1363. static void
  1364. ‌ngx_stream_proxy_ssl_handshake(ngx_connection_t *pc)
  1365. {
  1366.     long                          rc;
  1367.     ngx_stream_session_t         *s;
  1368.     ngx_stream_upstream_t        *u;
  1369.     ngx_stream_proxy_srv_conf_t  *pscf;

  1371.     s = pc->data;

  1373.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1375.     if (pc->ssl->handshaked) {

  1377.         if (pscf->ssl_verify) {
  1378.             rc = SSL_get_verify_result(pc->ssl->connection);

  1380.             if (rc != X509_V_OK) {
  1381.                 ngx_log_error(NGX_LOG_ERR, pc->log, 0,
  1382.                               "upstream SSL certificate verify error: (%l:%s)",
  1383.                               rc, X509_verify_cert_error_string(rc));
  1384.                 goto failed;
  1385.             }

  1387.             u = s->upstream;

  1389.             if (ngx_ssl_check_host(pc, &u->ssl_name) != NGX_OK) {
  1390.                 ngx_log_error(NGX_LOG_ERR, pc->log, 0,
  1391.                               "upstream SSL certificate does not match \"%V\"",
  1392.                               &u->ssl_name);
  1393.                 goto failed;
  1394.             }
  1395.         }

  1397.         if (pc->write->timer_set) {
  1398.             ngx_del_timer(pc->write);
  1399.         }

  1401.         ngx_stream_proxy_init_upstream(s);

  1403.         return;
  1404.     }

  1406. failed:

  1408.     ngx_stream_proxy_next_upstream(s);
  1409. }


  1412. static void
  1413. ‌ngx_stream_proxy_ssl_save_session(ngx_connection_t *c)
  1414. {
  1415.     ngx_stream_session_t   *s;
  1416.     ngx_stream_upstream_t  *u;

  1418.     s = c->data;
  1419.     u = s->upstream;

  1421.     u->peer.save_session(&u->peer, u->peer.data);
  1422. }


  1425. static ngx_int_t
  1426. ‌ngx_stream_proxy_ssl_name(ngx_stream_session_t *s)
  1427. {
  1428.     u_char                       *p, *last;
  1429.     ngx_str_t                     name;
  1430.     ngx_stream_upstream_t        *u;
  1431.     ngx_stream_proxy_srv_conf_t  *pscf;

  1433.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1435.     u = s->upstream;

  1437.     if (pscf->ssl_name) {
  1438.         if (ngx_stream_complex_value(s, pscf->ssl_name, &name) != NGX_OK) {
  1439.             return NGX_ERROR;
  1440.         }

  1442.     } else {
  1443.         name = u->ssl_name;
  1444.     }

  1446.     if (name.len == 0) {
  1447.         goto done;
  1448.     }

  1450.     /*
  1451.      * ssl name here may contain port, strip it for compatibility
  1452.      * with the http module
  1453.      */

  1455.     p = name.data;
  1456.     last = name.data + name.len;

  1458.     if (*p == '[') {
  1459.         p = ngx_strlchr(p, last, ']');

  1461.         if (p == NULL) {
  1462.             p = name.data;
  1463.         }
  1464.     }

  1466.     p = ngx_strlchr(p, last, ':');

  1468.     if (p != NULL) {
  1469.         name.len = p - name.data;
  1470.     }

  1472.     if (!pscf->ssl_server_name) {
  1473.         goto done;
  1474.     }

  1476. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  1478.     /* as per RFC 6066, literal IPv4 and IPv6 addresses are not permitted */

  1480.     if (name.len == 0 || *name.data == '[') {
  1481.         goto done;
  1482.     }

  1484.     if (ngx_inet_addr(name.data, name.len) != INADDR_NONE) {
  1485.         goto done;
  1486.     }

  1488.     /*
  1489.      * SSL_set_tlsext_host_name() needs a null-terminated string,
  1490.      * hence we explicitly null-terminate name here
  1491.      */

  1493.     p = ngx_pnalloc(s->connection->pool, name.len + 1);
  1494.     if (p == NULL) {
  1495.         return NGX_ERROR;
  1496.     }

  1498.     (void) ngx_cpystrn(p, name.data, name.len + 1);

  1500.     name.data = p;

  1502.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  1503.                    "upstream SSL server name: \"%s\"", name.data);

  1505.     if (SSL_set_tlsext_host_name(u->peer.connection->ssl->connection,
  1506.                                  (char *) name.data)
  1507.         == 0)
  1508.     {
  1509.         ngx_ssl_error(NGX_LOG_ERR, s->connection->log, 0,
  1510.                       "SSL_set_tlsext_host_name(\"%s\") failed", name.data);
  1511.         return NGX_ERROR;
  1512.     }

  1514. #endif

  1516. done:

  1518.     u->ssl_name = name;

  1520.     return NGX_OK;
  1521. }


  1524. static ngx_int_t
  1525. ‌ngx_stream_proxy_ssl_alpn(ngx_stream_session_t *s)
  1526. {
  1527. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1529.     size_t                        len;
  1530.     u_char                       *p, *buf;
  1531.     ngx_str_t                     proto, *value;
  1532.     ngx_uint_t                    i;
  1533.     ngx_array_t                  *values;
  1534.     ngx_connection_t             *c;
  1535.     ngx_stream_upstream_t        *u;
  1536.     ngx_stream_complex_value_t   *cv;
  1537.     ngx_stream_proxy_srv_conf_t  *pscf;

  1539.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1541.     u = s->upstream;
  1542.     c = u->peer.connection;

  1544.     values = NULL;
  1545.     len = 0;

  1547.     cv = pscf->ssl_alpn->elts;

  1549.     for (i = 0; i < pscf->ssl_alpn->nelts; i++) {

  1551.         if (ngx_stream_complex_value(s, &cv[i], &proto) != NGX_OK) {
  1552.             return NGX_ERROR;
  1553.         }

  1555.         if (proto.len == 0 || proto.len > 255) {
  1556.             continue;
  1557.         }

  1559.         if (values == NULL) {
  1560.             values = ngx_array_create(c->pool, 1, sizeof(ngx_str_t));
  1561.             if (values == NULL) {
  1562.                 return NGX_ERROR;
  1563.             }
  1564.         }

  1566.         value = ngx_array_push(values);
  1567.         if (value == NULL) {
  1568.             return NGX_ERROR;
  1569.         }

  1571.         *value = proto;

  1573.         len += 1 + proto.len;
  1574.     }

  1576.     if (len == 0) {
  1577.         return NGX_OK;
  1578.     }

  1580.     buf = ngx_pnalloc(c->pool, len);
  1581.     if (buf == NULL) {
  1582.         return NGX_ERROR;
  1583.     }

  1585.     p = buf;
  1586.     value = values->elts;

  1588.     for (i = 0; i < values->nelts; i++) {

  1590.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  1591.                        "upstream SSL ALPN: \"%V\"", &value[i]);

  1593.         *p++ = value[i].len;
  1594.         p = ngx_cpymem(p, value[i].data, value[i].len);
  1595.     }

  1597.     if (SSL_set_alpn_protos(c->ssl->connection, buf, p - buf) != 0) {
  1598.         ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  1599.                       "SSL_set_alpn_protos() failed");
  1600.         return NGX_ERROR;
  1601.     }

  1603. #endif

  1605.     return NGX_OK;
  1606. }


  1609. static ngx_int_t
  1610. ‌ngx_stream_proxy_ssl_certificate(ngx_stream_session_t *s)
  1611. {
  1612.     ngx_str_t                     cert, key;
  1613.     ngx_connection_t             *c;
  1614.     ngx_stream_proxy_srv_conf_t  *pscf;

  1616.     c = s->upstream->peer.connection;

  1618.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1620.     if (ngx_stream_complex_value(s, pscf->ssl_certificate, &cert)
  1621.         != NGX_OK)
  1622.     {
  1623.         return NGX_ERROR;
  1624.     }

  1626.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  1627.                    "stream upstream ssl cert: \"%s\"", cert.data);

  1629.     if (*cert.data == '\0') {
  1630.         return NGX_OK;
  1631.     }

  1633.     if (ngx_stream_complex_value(s, pscf->ssl_certificate_key, &key)
  1634.         != NGX_OK)
  1635.     {
  1636.         return NGX_ERROR;
  1637.     }

  1639.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  1640.                    "stream upstream ssl key: \"%s\"", key.data);

  1642.     if (ngx_ssl_connection_certificate(c, c->pool, &cert, &key,
  1643.                                        pscf->ssl_certificate_cache,
  1644.                                        pscf->ssl_passwords)
  1645.         != NGX_OK)
  1646.     {
  1647.         return NGX_ERROR;
  1648.     }

  1650.     return NGX_OK;
  1651. }

  1653. #endif


  1656. static void
  1657. ‌ngx_stream_proxy_downstream_handler(ngx_event_t *ev)
  1658. {
  1659.     ngx_stream_proxy_process_connection(ev, ev->write);
  1660. }


  1663. static void
  1664. ‌ngx_stream_proxy_resolve_handler(ngx_resolver_ctx_t *ctx)
  1665. {
  1666.     ngx_stream_session_t            *s;
  1667.     ngx_stream_upstream_t           *u;
  1668.     ngx_stream_proxy_srv_conf_t     *pscf;
  1669.     ngx_stream_upstream_resolved_t  *ur;

  1671.     s = ctx->data;

  1673.     u = s->upstream;
  1674.     ur = u->resolved;

  1676.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  1677.                    "stream upstream resolve");

  1679.     if (ctx->state) {
  1680.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1681.                       "%V could not be resolved (%i: %s)",
  1682.                       &ctx->name, ctx->state,
  1683.                       ngx_resolver_strerror(ctx->state));

  1685.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1686.         return;
  1687.     }

  1689.     ur->naddrs = ctx->naddrs;
  1690.     ur->addrs = ctx->addrs;

  1692. #if (NGX_DEBUG)
  1693.     {
  1694.     u_char      text[NGX_SOCKADDR_STRLEN];
  1695.     ngx_str_t   addr;
  1696.     ngx_uint_t  i;

  1698.     addr.data = text;

  1700.     for (i = 0; i < ctx->naddrs; i++) {
  1701.         addr.len = ngx_sock_ntop(ur->addrs[i].sockaddr, ur->addrs[i].socklen,
  1702.                                  text, NGX_SOCKADDR_STRLEN, 0);

  1704.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  1705.                        "name was resolved to %V", &addr);
  1706.     }
  1707.     }
  1708. #endif

  1710.     if (ngx_stream_upstream_create_round_robin_peer(s, ur) != NGX_OK) {
  1711.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1712.         return;
  1713.     }

  1715.     ngx_resolve_name_done(ctx);
  1716.     ur->ctx = NULL;

  1718.     u->peer.start_time = ngx_current_msec;

  1720.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1722.     if (pscf->next_upstream_tries
  1723.         && u->peer.tries > pscf->next_upstream_tries)
  1724.     {
  1725.         u->peer.tries = pscf->next_upstream_tries;
  1726.     }

  1728.     ngx_stream_proxy_connect(s);
  1729. }


  1732. static void
  1733. ‌ngx_stream_proxy_upstream_handler(ngx_event_t *ev)
  1734. {
  1735.     ngx_stream_proxy_process_connection(ev, !ev->write);
  1736. }


  1739. static void
  1740. ‌ngx_stream_proxy_process_connection(ngx_event_t *ev, ngx_uint_t from_upstream)
  1741. {
  1742.     ngx_connection_t             *c, *pc;
  1743.     ngx_log_handler_pt            handler;
  1744.     ngx_stream_session_t         *s;
  1745.     ngx_stream_upstream_t        *u;
  1746.     ngx_stream_proxy_srv_conf_t  *pscf;

  1748.     c = ev->data;
  1749.     s = c->data;
  1750.     u = s->upstream;

  1752.     if (c->close) {
  1753.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "shutdown timeout");
  1754.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1755.         return;
  1756.     }

  1758.     c = s->connection;
  1759.     pc = u->peer.connection;

  1761.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1763.     if (ev->timedout) {
  1764.         ev->timedout = 0;

  1766.         if (ev->delayed) {
  1767.             ev->delayed = 0;

  1769.             if (!ev->ready) {
  1770.                 if (ngx_handle_read_event(ev, 0) != NGX_OK) {
  1771.                     ngx_stream_proxy_finalize(s,
  1772.                                               NGX_STREAM_INTERNAL_SERVER_ERROR);
  1773.                     return;
  1774.                 }

  1776.                 if (u->connected && !c->read->delayed && !pc->read->delayed) {
  1777.                     ngx_add_timer(c->write, pscf->timeout);
  1778.                 }

  1780.                 return;
  1781.             }

  1783.         } else {
  1784.             if (s->connection->type == SOCK_DGRAM) {

  1786.                 if (pscf->responses == NGX_MAX_INT32_VALUE
  1787.                     || (u->responses >= pscf->responses * u->requests))
  1788.                 {

  1790.                     /*
  1791.                      * successfully terminate timed out UDP session
  1792.                      * if expected number of responses was received
  1793.                      */

  1795.                     handler = c->log->handler;
  1796.                     c->log->handler = NULL;

  1798.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1799.                                   "udp timed out"
  1800.                                   ", packets from/to client:%ui/%ui"
  1801.                                   ", bytes from/to client:%O/%O"
  1802.                                   ", bytes from/to upstream:%O/%O",
  1803.                                   u->requests, u->responses,
  1804.                                   s->received, c->sent, u->received,
  1805.                                   pc ? pc->sent : 0);

  1807.                     c->log->handler = handler;

  1809.                     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1810.                     return;
  1811.                 }

  1813.                 ngx_connection_error(pc, NGX_ETIMEDOUT, "upstream timed out");

  1815.                 pc->read->error = 1;

  1817.                 ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);

  1819.                 return;
  1820.             }

  1822.             ngx_connection_error(c, NGX_ETIMEDOUT, "connection timed out");

  1824.             ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  1826.             return;
  1827.         }

  1829.     } else if (ev->delayed) {

  1831.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  1832.                        "stream connection delayed");

  1834.         if (ngx_handle_read_event(ev, 0) != NGX_OK) {
  1835.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1836.         }

  1838.         return;
  1839.     }

  1841.     if (from_upstream && !u->connected) {
  1842.         return;
  1843.     }

  1845.     ngx_stream_proxy_process(s, from_upstream, ev->write);
  1846. }


  1849. static void
  1850. ‌ngx_stream_proxy_connect_handler(ngx_event_t *ev)
  1851. {
  1852.     ngx_connection_t      *c;
  1853.     ngx_stream_session_t  *s;

  1855.     c = ev->data;
  1856.     s = c->data;

  1858.     if (ev->timedout) {
  1859.         ngx_log_error(NGX_LOG_ERR, c->log, NGX_ETIMEDOUT, "upstream timed out");
  1860.         ngx_stream_proxy_next_upstream(s);
  1861.         return;
  1862.     }

  1864.     ngx_del_timer(c->write);

  1866.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  1867.                    "stream proxy connect upstream");

  1869.     if (ngx_stream_proxy_test_connect(c) != NGX_OK) {
  1870.         ngx_stream_proxy_next_upstream(s);
  1871.         return;
  1872.     }

  1874.     ngx_stream_proxy_init_upstream(s);
  1875. }


  1878. static ngx_int_t
  1879. ‌ngx_stream_proxy_test_connect(ngx_connection_t *c)
  1880. {
  1881.     int        err;
  1882.     socklen_t  len;

  1884. #if (NGX_HAVE_KQUEUE)

  1886.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
  1887.         err = c->write->kq_errno ? c->write->kq_errno : c->read->kq_errno;

  1889.         if (err) {
  1890.             (void) ngx_connection_error(c, err,
  1891.                                     "kevent() reported that connect() failed");
  1892.             return NGX_ERROR;
  1893.         }

  1895.     } else
  1896. #endif
  1897.     {
  1898.         err = 0;
  1899.         len = sizeof(int);

  1901.         /*
  1902.          * BSDs and Linux return 0 and set a pending error in err
  1903.          * Solaris returns -1 and sets errno
  1904.          */

  1906.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  1907.             == -1)
  1908.         {
  1909.             err = ngx_socket_errno;
  1910.         }

  1912.         if (err) {
  1913.             (void) ngx_connection_error(c, err, "connect() failed");
  1914.             return NGX_ERROR;
  1915.         }
  1916.     }

  1918.     return NGX_OK;
  1919. }


  1922. static void
  1923. ‌ngx_stream_proxy_process(ngx_stream_session_t *s, ngx_uint_t from_upstream,
  1924.     ngx_uint_t do_write)
  1925. {
  1926.     char                         *recv_action, *send_action;
  1927.     off_t                        *received, limit;
  1928.     size_t                        size, limit_rate;
  1929.     ssize_t                       n;
  1930.     ngx_buf_t                    *b;
  1931.     ngx_int_t                     rc;
  1932.     ngx_uint_t                    flags, *packets;
  1933.     ngx_msec_t                    delay;
  1934.     ngx_chain_t                  *cl, **ll, **out, **busy;
  1935.     ngx_connection_t             *c, *pc, *src, *dst;
  1936.     ngx_log_handler_pt            handler;
  1937.     ngx_stream_upstream_t        *u;
  1938.     ngx_stream_proxy_srv_conf_t  *pscf;

  1940.     u = s->upstream;

  1942.     c = s->connection;
  1943.     pc = u->connected ? u->peer.connection : NULL;

  1945.     if (c->type == SOCK_DGRAM && (ngx_terminate || ngx_exiting)) {

  1947.         /* socket is already closed on worker shutdown */

  1949.         handler = c->log->handler;
  1950.         c->log->handler = NULL;

  1952.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "disconnected on shutdown");

  1954.         c->log->handler = handler;

  1956.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1957.         return;
  1958.     }

  1960.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1962.     if (from_upstream) {
  1963.         src = pc;
  1964.         dst = c;
  1965.         b = &u->upstream_buf;
  1966.         limit_rate = u->download_rate;
  1967.         received = &u->received;
  1968.         packets = &u->responses;
  1969.         out = &u->downstream_out;
  1970.         busy = &u->downstream_busy;
  1971.         recv_action = "proxying and reading from upstream";
  1972.         send_action = "proxying and sending to client";

  1974.     } else {
  1975.         src = c;
  1976.         dst = pc;
  1977.         b = &u->downstream_buf;
  1978.         limit_rate = u->upload_rate;
  1979.         received = &s->received;
  1980.         packets = &u->requests;
  1981.         out = &u->upstream_out;
  1982.         busy = &u->upstream_busy;
  1983.         recv_action = "proxying and reading from client";
  1984.         send_action = "proxying and sending to upstream";
  1985.     }

  1987.     for ( ;; ) {

  1989.         if (do_write && dst) {

  1991.             if (*out || *busy || dst->buffered) {
  1992.                 c->log->action = send_action;

  1994.                 rc = ngx_stream_top_filter(s, *out, from_upstream);

  1996.                 if (rc == NGX_ERROR) {
  1997.                     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1998.                     return;
  1999.                 }

  2001.                 ngx_chain_update_chains(c->pool, &u->free, busy, out,
  2002.                                       (ngx_buf_tag_t) &ngx_stream_proxy_module);

  2004.                 if (*busy == NULL) {
  2005.                     b->pos = b->start;
  2006.                     b->last = b->start;
  2007.                 }
  2008.             }
  2009.         }

  2011.         size = b->end - b->last;

  2013.         if (size && src->read->ready && !src->read->delayed) {

  2015.             if (limit_rate) {
  2016.                 limit = (off_t) limit_rate * (ngx_time() - u->start_sec + 1)
  2017.                         - *received;

  2019.                 if (limit <= 0) {
  2020.                     src->read->delayed = 1;
  2021.                     delay = (ngx_msec_t) (- limit * 1000 / limit_rate + 1);
  2022.                     ngx_add_timer(src->read, delay);
  2023.                     break;
  2024.                 }

  2026.                 if (c->type == SOCK_STREAM && (off_t) size > limit) {
  2027.                     size = (size_t) limit;
  2028.                 }
  2029.             }

  2031.             c->log->action = recv_action;

  2033.             n = src->recv(src, b->last, size);

  2035.             if (n == NGX_AGAIN) {
  2036.                 break;
  2037.             }

  2039.             if (n == NGX_ERROR) {
  2040.                 src->read->eof = 1;
  2041.                 n = 0;
  2042.             }

  2044.             if (n >= 0) {
  2045.                 if (limit_rate) {
  2046.                     delay = (ngx_msec_t) (n * 1000 / limit_rate);

  2048.                     if (delay > 0) {
  2049.                         src->read->delayed = 1;
  2050.                         ngx_add_timer(src->read, delay);
  2051.                     }
  2052.                 }

  2054.                 if (from_upstream) {
  2055.                     if (u->state->first_byte_time == (ngx_msec_t) -1) {
  2056.                         u->state->first_byte_time = ngx_current_msec
  2057.                                                     - u->start_time;

  2059.                         if (u->peer.notify) {
  2060.                             u->peer.notify(&u->peer, u->peer.data,
  2061.                                        NGX_STREAM_UPSTREAM_NOTIFY_FIRST_BYTE);
  2062.                         }
  2063.                     }
  2064.                 }

  2066.                 for (ll = out; *ll; ll = &(*ll)->next) { /* void */ }

  2068.                 cl = ngx_chain_get_free_buf(c->pool, &u->free);
  2069.                 if (cl == NULL) {
  2070.                     ngx_stream_proxy_finalize(s,
  2071.                                               NGX_STREAM_INTERNAL_SERVER_ERROR);
  2072.                     return;
  2073.                 }

  2075.                 *ll = cl;

  2077.                 cl->buf->pos = b->last;
  2078.                 cl->buf->last = b->last + n;
  2079.                 cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;

  2081.                 cl->buf->temporary = (n ? 1 : 0);
  2082.                 cl->buf->last_buf = src->read->eof;
  2083.                 cl->buf->flush = !src->read->eof;

  2085.                 (*packets)++;
  2086.                 *received += n;
  2087.                 b->last += n;
  2088.                 do_write = 1;

  2090.                 continue;
  2091.             }
  2092.         }

  2094.         break;
  2095.     }

  2097.     c->log->action = "proxying connection";

  2099.     if (ngx_stream_proxy_test_finalize(s, from_upstream) == NGX_OK) {
  2100.         return;
  2101.     }

  2103.     flags = src->read->eof ? NGX_CLOSE_EVENT : 0;

  2105.     if (ngx_handle_read_event(src->read, flags) != NGX_OK) {
  2106.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  2107.         return;
  2108.     }

  2110.     if (dst) {

  2112.         if (dst->type == SOCK_STREAM && pscf->half_close
  2113.             && src->read->eof && !u->half_closed && !dst->buffered)
  2114.         {
  2115.             if (ngx_shutdown_socket(dst->fd, NGX_WRITE_SHUTDOWN) == -1) {
  2116.                 ngx_connection_error(c, ngx_socket_errno,
  2117.                                      ngx_shutdown_socket_n " failed");

  2119.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  2120.                 return;
  2121.             }

  2123.             u->half_closed = 1;
  2124.             ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  2125.                            "stream proxy %s socket shutdown",
  2126.                            from_upstream ? "client" : "upstream");
  2127.         }

  2129.         if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
  2130.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  2131.             return;
  2132.         }

  2134.         if (!c->read->delayed && !pc->read->delayed) {
  2135.             ngx_add_timer(c->write, pscf->timeout);

  2137.         } else if (c->write->timer_set) {
  2138.             ngx_del_timer(c->write);
  2139.         }
  2140.     }
  2141. }


  2144. static ngx_int_t
  2145. ‌ngx_stream_proxy_test_finalize(ngx_stream_session_t *s,
  2146.     ngx_uint_t from_upstream)
  2147. {
  2148.     ngx_connection_t             *c, *pc;
  2149.     ngx_log_handler_pt            handler;
  2150.     ngx_stream_upstream_t        *u;
  2151.     ngx_stream_proxy_srv_conf_t  *pscf;

  2153.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  2155.     c = s->connection;
  2156.     u = s->upstream;
  2157.     pc = u->connected ? u->peer.connection : NULL;

  2159.     if (c->type == SOCK_DGRAM) {

  2161.         if (pscf->requests && u->requests < pscf->requests) {
  2162.             return NGX_DECLINED;
  2163.         }

  2165.         if (pscf->requests) {
  2166.             ngx_delete_udp_connection(c);
  2167.         }

  2169.         if (pscf->responses == NGX_MAX_INT32_VALUE
  2170.             || u->responses < pscf->responses * u->requests)
  2171.         {
  2172.             return NGX_DECLINED;
  2173.         }

  2175.         if (pc == NULL || c->buffered || pc->buffered) {
  2176.             return NGX_DECLINED;
  2177.         }

  2179.         handler = c->log->handler;
  2180.         c->log->handler = NULL;

  2182.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2183.                       "udp done"
  2184.                       ", packets from/to client:%ui/%ui"
  2185.                       ", bytes from/to client:%O/%O"
  2186.                       ", bytes from/to upstream:%O/%O",
  2187.                       u->requests, u->responses,
  2188.                       s->received, c->sent, u->received, pc ? pc->sent : 0);

  2190.         c->log->handler = handler;

  2192.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  2194.         return NGX_OK;
  2195.     }

  2197.     /* c->type == SOCK_STREAM */

  2199.     if (pc == NULL
  2200.         || (!c->read->eof && !pc->read->eof)
  2201.         || (!c->read->eof && c->buffered)
  2202.         || (!pc->read->eof && pc->buffered))
  2203.     {
  2204.         return NGX_DECLINED;
  2205.     }

  2207.     if (pscf->half_close) {
  2208.         /* avoid closing live connections until both read ends get EOF */
  2209.         if (!(c->read->eof && pc->read->eof && !c->buffered && !pc->buffered)) {
  2210.              return NGX_DECLINED;
  2211.         }
  2212.     }

  2214.     handler = c->log->handler;
  2215.     c->log->handler = NULL;

  2217.     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2218.                   "%s disconnected"
  2219.                   ", bytes from/to client:%O/%O"
  2220.                   ", bytes from/to upstream:%O/%O",
  2221.                   from_upstream ? "upstream" : "client",
  2222.                   s->received, c->sent, u->received, pc ? pc->sent : 0);

  2224.     c->log->handler = handler;

  2226.     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  2228.     return NGX_OK;
  2229. }


  2232. static void
  2233. ‌ngx_stream_proxy_next_upstream(ngx_stream_session_t *s)
  2234. {
  2235.     ngx_msec_t                    timeout;
  2236.     ngx_connection_t             *pc;
  2237.     ngx_stream_upstream_t        *u;
  2238.     ngx_stream_proxy_srv_conf_t  *pscf;

  2240.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  2241.                    "stream proxy next upstream");

  2243.     u = s->upstream;
  2244.     pc = u->peer.connection;

  2246.     if (pc && pc->buffered) {
  2247.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  2248.                       "buffered data on next upstream");
  2249.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  2250.         return;
  2251.     }

  2253.     if (s->connection->type == SOCK_DGRAM) {
  2254.         u->upstream_out = NULL;
  2255.     }

  2257.     if (u->peer.sockaddr) {
  2258.         u->peer.free(&u->peer, u->peer.data, NGX_PEER_FAILED);
  2259.         u->peer.sockaddr = NULL;
  2260.     }

  2262.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  2264.     timeout = pscf->next_upstream_timeout;

  2266.     if (u->peer.tries == 0
  2267.         || !pscf->next_upstream
  2268.         || (timeout && ngx_current_msec - u->peer.start_time >= timeout))
  2269.     {
  2270.         ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);
  2271.         return;
  2272.     }

  2274.     if (pc) {
  2275.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  2276.                        "close proxy upstream connection: %d", pc->fd);

  2278. #if (NGX_STREAM_SSL)
  2279.         if (pc->ssl) {
  2280.             pc->ssl->no_wait_shutdown = 1;
  2281.             pc->ssl->no_send_shutdown = 1;

  2283.             (void) ngx_ssl_shutdown(pc);
  2284.         }
  2285. #endif

  2287.         u->state->bytes_received = u->received;
  2288.         u->state->bytes_sent = pc->sent;

  2290.         ngx_close_connection(pc);
  2291.         u->peer.connection = NULL;
  2292.     }

  2294.     ngx_stream_proxy_connect(s);
  2295. }


  2298. static void
  2299. ‌ngx_stream_proxy_finalize(ngx_stream_session_t *s, ngx_uint_t rc)
  2300. {
  2301.     ngx_uint_t              state;
  2302.     ngx_connection_t       *pc;
  2303.     ngx_stream_upstream_t  *u;

  2305.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  2306.                    "finalize stream proxy: %i", rc);

  2308.     u = s->upstream;

  2310.     if (u == NULL) {
  2311.         goto noupstream;
  2312.     }

  2314.     if (u->resolved && u->resolved->ctx) {
  2315.         ngx_resolve_name_done(u->resolved->ctx);
  2316.         u->resolved->ctx = NULL;
  2317.     }

  2319.     pc = u->peer.connection;

  2321.     if (u->state) {
  2322.         if (u->state->response_time == (ngx_msec_t) -1) {
  2323.             u->state->response_time = ngx_current_msec - u->start_time;
  2324.         }

  2326.         if (pc) {
  2327.             u->state->bytes_received = u->received;
  2328.             u->state->bytes_sent = pc->sent;
  2329.         }
  2330.     }

  2332.     if (u->peer.free && u->peer.sockaddr) {
  2333.         state = 0;

  2335.         if (pc && pc->type == SOCK_DGRAM
  2336.             && (pc->read->error || pc->write->error))
  2337.         {
  2338.             state = NGX_PEER_FAILED;
  2339.         }

  2341.         u->peer.free(&u->peer, u->peer.data, state);
  2342.         u->peer.sockaddr = NULL;
  2343.     }

  2345.     if (pc) {
  2346.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  2347.                        "close stream proxy upstream connection: %d", pc->fd);

  2349. #if (NGX_STREAM_SSL)
  2350.         if (pc->ssl) {
  2351.             pc->ssl->no_wait_shutdown = 1;
  2352.             (void) ngx_ssl_shutdown(pc);
  2353.         }
  2354. #endif

  2356.         ngx_close_connection(pc);
  2357.         u->peer.connection = NULL;
  2358.     }

  2360. noupstream:

  2362.     ngx_stream_finalize_session(s, rc);
  2363. }


  2366. static u_char *
  2367. ‌ngx_stream_proxy_log_error(ngx_log_t *log, u_char *buf, size_t len)
  2368. {
  2369.     u_char                 *p;
  2370.     ngx_connection_t       *pc;
  2371.     ngx_stream_session_t   *s;
  2372.     ngx_stream_upstream_t  *u;

  2374.     s = log->data;

  2376.     u = s->upstream;

  2378.     p = buf;

  2380.     if (u->peer.name) {
  2381.         p = ngx_snprintf(p, len, ", upstream: \"%V\"", u->peer.name);
  2382.         len -= p - buf;
  2383.     }

  2385.     pc = u->peer.connection;

  2387.     p = ngx_snprintf(p, len,
  2388.                      ", bytes from/to client:%O/%O"
  2389.                      ", bytes from/to upstream:%O/%O",
  2390.                      s->received, s->connection->sent,
  2391.                      u->received, pc ? pc->sent : 0);

  2393.     return p;
  2394. }


  2397. static void *
  2398. ‌ngx_stream_proxy_create_srv_conf(ngx_conf_t *cf)
  2399. {
  2400.     ngx_stream_proxy_srv_conf_t  *conf;

  2402.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_proxy_srv_conf_t));
  2403.     if (conf == NULL) {
  2404.         return NULL;
  2405.     }

  2407.     /*
  2408.      * set by ngx_pcalloc():
  2409.      *
  2410.      *     conf->ssl_protocols = 0;
  2411.      *     conf->ssl_ciphers = { 0, NULL };
  2412.      *     conf->ssl_trusted_certificate = { 0, NULL };
  2413.      *     conf->ssl_crl = { 0, NULL };
  2414.      *
  2415.      *     conf->ssl = NULL;
  2416.      *     conf->upstream = NULL;
  2417.      *     conf->upstream_value = NULL;
  2418.      */

  2420.     conf->connect_timeout = NGX_CONF_UNSET_MSEC;
  2421.     conf->timeout = NGX_CONF_UNSET_MSEC;
  2422.     conf->next_upstream_timeout = NGX_CONF_UNSET_MSEC;
  2423.     conf->buffer_size = NGX_CONF_UNSET_SIZE;
  2424.     conf->upload_rate = NGX_CONF_UNSET_PTR;
  2425.     conf->download_rate = NGX_CONF_UNSET_PTR;
  2426.     conf->requests = NGX_CONF_UNSET_UINT;
  2427.     conf->responses = NGX_CONF_UNSET_UINT;
  2428.     conf->next_upstream_tries = NGX_CONF_UNSET_UINT;
  2429.     conf->next_upstream = NGX_CONF_UNSET;
  2430.     conf->proxy_protocol = NGX_CONF_UNSET_UINT;
  2431.     conf->local = NGX_CONF_UNSET_PTR;
  2432.     conf->socket_keepalive = NGX_CONF_UNSET;
  2433.     conf->socket_rcvbuf = NGX_CONF_UNSET_SIZE;
  2434.     conf->socket_sndbuf = NGX_CONF_UNSET_SIZE;
  2435.     conf->half_close = NGX_CONF_UNSET;

  2437. #if (NGX_STREAM_SSL)
  2438.     conf->ssl_enable = NGX_CONF_UNSET;
  2439.     conf->ssl_session_reuse = NGX_CONF_UNSET;
  2440.     conf->ssl_name = NGX_CONF_UNSET_PTR;
  2441.     conf->ssl_server_name = NGX_CONF_UNSET;
  2442.     conf->ssl_alpn = NGX_CONF_UNSET_PTR;
  2443.     conf->ssl_verify = NGX_CONF_UNSET;
  2444.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  2445.     conf->ssl_certificate = NGX_CONF_UNSET_PTR;
  2446.     conf->ssl_certificate_key = NGX_CONF_UNSET_PTR;
  2447.     conf->ssl_certificate_cache = NGX_CONF_UNSET_PTR;
  2448.     conf->ssl_passwords = NGX_CONF_UNSET_PTR;
  2449.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  2450. #endif

  2452.     return conf;
  2453. }


  2456. static char *
  2457. ‌ngx_stream_proxy_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  2458. {
  2459.     ngx_stream_proxy_srv_conf_t *prev = parent;
  2460.     ngx_stream_proxy_srv_conf_t *conf = child;

  2462.     ngx_conf_merge_msec_value(conf->connect_timeout,
  2463.                               prev->connect_timeout, 60000);

  2465.     ngx_conf_merge_msec_value(conf->timeout,
  2466.                               prev->timeout, 10 * 60000);

  2468.     ngx_conf_merge_msec_value(conf->next_upstream_timeout,
  2469.                               prev->next_upstream_timeout, 0);

  2471.     ngx_conf_merge_size_value(conf->buffer_size,
  2472.                               prev->buffer_size, 16384);

  2474.     ngx_conf_merge_ptr_value(conf->upload_rate, prev->upload_rate, NULL);

  2476.     ngx_conf_merge_ptr_value(conf->download_rate, prev->download_rate, NULL);

  2478.     ngx_conf_merge_uint_value(conf->requests,
  2479.                               prev->requests, 0);

  2481.     ngx_conf_merge_uint_value(conf->responses,
  2482.                               prev->responses, NGX_MAX_INT32_VALUE);

  2484.     ngx_conf_merge_uint_value(conf->next_upstream_tries,
  2485.                               prev->next_upstream_tries, 0);

  2487.     ngx_conf_merge_value(conf->next_upstream, prev->next_upstream, 1);

  2489.     ngx_conf_merge_uint_value(conf->proxy_protocol, prev->proxy_protocol, 0);

  2491.     ngx_conf_merge_ptr_value(conf->local, prev->local, NULL);

  2493.     ngx_conf_merge_value(conf->socket_keepalive,
  2494.                               prev->socket_keepalive, 0);

  2496.     ngx_conf_merge_size_value(conf->socket_rcvbuf, prev->socket_rcvbuf, 0);

  2498.     ngx_conf_merge_size_value(conf->socket_sndbuf, prev->socket_sndbuf, 0);

  2500.     ngx_conf_merge_value(conf->half_close, prev->half_close, 0);

  2502. #if (NGX_STREAM_SSL)

  2504.     if (ngx_stream_proxy_merge_ssl(cf, conf, prev) != NGX_OK) {
  2505.         return NGX_CONF_ERROR;
  2506.     }

  2508.     ngx_conf_merge_value(conf->ssl_enable, prev->ssl_enable, 0);

  2510.     ngx_conf_merge_value(conf->ssl_session_reuse,
  2511.                               prev->ssl_session_reuse, 1);

  2513.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  2514.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

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

  2518.     ngx_conf_merge_ptr_value(conf->ssl_name, prev->ssl_name, NULL);

  2520.     ngx_conf_merge_value(conf->ssl_server_name, prev->ssl_server_name, 0);

  2522.     ngx_conf_merge_ptr_value(conf->ssl_alpn, prev->ssl_alpn, NULL);

  2524.     ngx_conf_merge_value(conf->ssl_verify, prev->ssl_verify, 0);

  2526.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  2527.                               prev->ssl_verify_depth, 1);

  2529.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  2530.                               prev->ssl_trusted_certificate, "");

  2532.     ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");

  2534.     ngx_conf_merge_ptr_value(conf->ssl_certificate,
  2535.                               prev->ssl_certificate, NULL);

  2537.     ngx_conf_merge_ptr_value(conf->ssl_certificate_key,
  2538.                               prev->ssl_certificate_key, NULL);

  2540.     ngx_conf_merge_ptr_value(conf->ssl_certificate_cache,
  2541.                               prev->ssl_certificate_cache, NULL);

  2543.     if (ngx_stream_proxy_merge_ssl_passwords(cf, conf, prev) != NGX_OK) {
  2544.         return NGX_CONF_ERROR;
  2545.     }

  2547.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  2548.                               prev->ssl_conf_commands, NULL);

  2550.     if (conf->ssl_enable && ngx_stream_proxy_set_ssl(cf, conf) != NGX_OK) {
  2551.         return NGX_CONF_ERROR;
  2552.     }

  2554. #endif

  2556.     return NGX_CONF_OK;
  2557. }


  2560. #if (NGX_STREAM_SSL)

  2562. static ngx_int_t
  2563. ‌ngx_stream_proxy_merge_ssl(ngx_conf_t *cf, ngx_stream_proxy_srv_conf_t *conf,
  2564.     ngx_stream_proxy_srv_conf_t *prev)
  2565. {
  2566.     ngx_uint_t  preserve;

  2568.     if (conf->ssl_protocols == 0
  2569.         && conf->ssl_ciphers.data == NULL
  2570.         && conf->ssl_certificate == NGX_CONF_UNSET_PTR
  2571.         && conf->ssl_certificate_key == NGX_CONF_UNSET_PTR
  2572.         && conf->ssl_passwords == NGX_CONF_UNSET_PTR
  2573.         && conf->ssl_verify == NGX_CONF_UNSET
  2574.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  2575.         && conf->ssl_trusted_certificate.data == NULL
  2576.         && conf->ssl_crl.data == NULL
  2577.         && conf->ssl_session_reuse == NGX_CONF_UNSET
  2578.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  2579.     {
  2580.         if (prev->ssl) {
  2581.             conf->ssl = prev->ssl;
  2582.             return NGX_OK;
  2583.         }

  2585.         preserve = 1;

  2587.     } else {
  2588.         preserve = 0;
  2589.     }

  2591.     conf->ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  2592.     if (conf->ssl == NULL) {
  2593.         return NGX_ERROR;
  2594.     }

  2596.     conf->ssl->log = cf->log;

  2598.     /*
  2599.      * special handling to preserve conf->ssl
  2600.      * in the "stream" section to inherit it to all servers
  2601.      */

  2603.     if (preserve) {
  2604.         prev->ssl = conf->ssl;
  2605.     }

  2607.     return NGX_OK;
  2608. }


  2611. static ngx_int_t
  2612. ‌ngx_stream_proxy_merge_ssl_passwords(ngx_conf_t *cf,
  2613.     ngx_stream_proxy_srv_conf_t *conf, ngx_stream_proxy_srv_conf_t *prev)
  2614. {
  2615.     ngx_uint_t  preserve;

  2617.     ngx_conf_merge_ptr_value(conf->ssl_passwords, prev->ssl_passwords, NULL);

  2619.     if (conf->ssl_certificate == NULL
  2620.         || conf->ssl_certificate->value.len == 0
  2621.         || conf->ssl_certificate_key == NULL)
  2622.     {
  2623.         return NGX_OK;
  2624.     }

  2626.     if (conf->ssl_certificate->lengths == NULL
  2627.         && conf->ssl_certificate_key->lengths == NULL)
  2628.     {
  2629.         if (conf->ssl_passwords && conf->ssl_passwords->pool == NULL) {
  2630.             /* un-preserve empty password list */
  2631.             conf->ssl_passwords = NULL;
  2632.         }

  2634.         return NGX_OK;
  2635.     }

  2637.     if (conf->ssl_passwords && conf->ssl_passwords->pool != cf->temp_pool) {
  2638.         /* already preserved */
  2639.         return NGX_OK;
  2640.     }

  2642.     preserve = (conf->ssl_passwords == prev->ssl_passwords) ? 1 : 0;

  2644.     conf->ssl_passwords = ngx_ssl_preserve_passwords(cf, conf->ssl_passwords);
  2645.     if (conf->ssl_passwords == NULL) {
  2646.         return NGX_ERROR;
  2647.     }

  2649.     /*
  2650.      * special handling to keep a preserved ssl_passwords copy
  2651.      * in the previous configuration to inherit it to all children
  2652.      */

  2654.     if (preserve) {
  2655.         prev->ssl_passwords = conf->ssl_passwords;
  2656.     }

  2658.     return NGX_OK;
  2659. }


  2662. static ngx_int_t
  2663. ‌ngx_stream_proxy_set_ssl(ngx_conf_t *cf, ngx_stream_proxy_srv_conf_t *pscf)
  2664. {
  2665.     ngx_pool_cleanup_t  *cln;

  2667.     if (pscf->ssl->ctx) {
  2668.         return NGX_OK;
  2669.     }

  2671.     if (ngx_ssl_create(pscf->ssl, pscf->ssl_protocols, NULL) != NGX_OK) {
  2672.         return NGX_ERROR;
  2673.     }

  2675.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  2676.     if (cln == NULL) {
  2677.         ngx_ssl_cleanup_ctx(pscf->ssl);
  2678.         return NGX_ERROR;
  2679.     }

  2681.     cln->handler = ngx_ssl_cleanup_ctx;
  2682.     cln->data = pscf->ssl;

  2684.     if (ngx_ssl_ciphers(cf, pscf->ssl, &pscf->ssl_ciphers, 0) != NGX_OK) {
  2685.         return NGX_ERROR;
  2686.     }

  2688.     if (pscf->ssl_certificate
  2689.         && pscf->ssl_certificate->value.len)
  2690.     {
  2691.         if (pscf->ssl_certificate_key == NULL) {
  2692.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2693.                           "no \"proxy_ssl_certificate_key\" is defined "
  2694.                           "for certificate \"%V\"",
  2695.                           &pscf->ssl_certificate->value);
  2696.             return NGX_ERROR;
  2697.         }

  2699.         if (pscf->ssl_certificate->lengths == NULL
  2700.             && pscf->ssl_certificate_key->lengths == NULL)
  2701.         {
  2702.             if (ngx_ssl_certificate(cf, pscf->ssl,
  2703.                                     &pscf->ssl_certificate->value,
  2704.                                     &pscf->ssl_certificate_key->value,
  2705.                                     pscf->ssl_passwords)
  2706.                 != NGX_OK)
  2707.             {
  2708.                 return NGX_ERROR;
  2709.             }
  2710.         }
  2711.     }

  2713.     if (pscf->ssl_verify) {
  2714.         if (pscf->ssl_trusted_certificate.len == 0) {
  2715.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2716.                       "no proxy_ssl_trusted_certificate for proxy_ssl_verify");
  2717.             return NGX_ERROR;
  2718.         }

  2720.         if (ngx_ssl_trusted_certificate(cf, pscf->ssl,
  2721.                                         &pscf->ssl_trusted_certificate,
  2722.                                         pscf->ssl_verify_depth)
  2723.             != NGX_OK)
  2724.         {
  2725.             return NGX_ERROR;
  2726.         }

  2728.         if (ngx_ssl_crl(cf, pscf->ssl, &pscf->ssl_crl) != NGX_OK) {
  2729.             return NGX_ERROR;
  2730.         }
  2731.     }

  2733.     if (ngx_ssl_client_session_cache(cf, pscf->ssl, pscf->ssl_session_reuse)
  2734.         != NGX_OK)
  2735.     {
  2736.         return NGX_ERROR;
  2737.     }

  2739.     if (ngx_ssl_conf_commands(cf, pscf->ssl, pscf->ssl_conf_commands)
  2740.         != NGX_OK)
  2741.     {
  2742.         return NGX_ERROR;
  2743.     }

  2745.     return NGX_OK;
  2746. }

  2748. #endif


  2751. static char *
  2752. ‌ngx_stream_proxy_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2753. {
  2754.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  2756.     ngx_url_t                            u;
  2757.     ngx_str_t                           *value, *url;
  2758.     ngx_stream_complex_value_t           cv;
  2759.     ngx_stream_core_srv_conf_t          *cscf;
  2760.     ngx_stream_compile_complex_value_t   ccv;

  2762.     if (pscf->upstream || pscf->upstream_value) {
  2763.         return "is duplicate";
  2764.     }

  2766.     cscf = ngx_stream_conf_get_module_srv_conf(cf, ngx_stream_core_module);

  2768.     cscf->handler = ngx_stream_proxy_handler;

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

  2772.     url = &value[1];

  2774.     ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

  2776.     ccv.cf = cf;
  2777.     ccv.value = url;
  2778.     ccv.complex_value = &cv;

  2780.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  2781.         return NGX_CONF_ERROR;
  2782.     }

  2784.     if (cv.lengths) {
  2785.         pscf->upstream_value = ngx_palloc(cf->pool,
  2786.                                           sizeof(ngx_stream_complex_value_t));
  2787.         if (pscf->upstream_value == NULL) {
  2788.             return NGX_CONF_ERROR;
  2789.         }

  2791.         *pscf->upstream_value = cv;

  2793.         return NGX_CONF_OK;
  2794.     }

  2796.     ngx_memzero(&u, sizeof(ngx_url_t));

  2798.     u.url = *url;
  2799.     u.no_resolve = 1;

  2801.     pscf->upstream = ngx_stream_upstream_add(cf, &u, 0);
  2802.     if (pscf->upstream == NULL) {
  2803.         return NGX_CONF_ERROR;
  2804.     }

  2806.     return NGX_CONF_OK;
  2807. }


  2810. static char *
  2811. ‌ngx_stream_proxy_bind(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2812. {
  2813.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  2815.     ngx_int_t                            rc;
  2816.     ngx_str_t                           *value;
  2817.     ngx_stream_complex_value_t           cv;
  2818.     ngx_stream_upstream_local_t         *local;
  2819.     ngx_stream_compile_complex_value_t   ccv;

  2821.     if (pscf->local != NGX_CONF_UNSET_PTR) {
  2822.         return "is duplicate";
  2823.     }

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

  2827.     if (cf->args->nelts == 2 && ngx_strcmp(value[1].data, "off") == 0) {
  2828.         pscf->local = NULL;
  2829.         return NGX_CONF_OK;
  2830.     }

  2832.     ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

  2834.     ccv.cf = cf;
  2835.     ccv.value = &value[1];
  2836.     ccv.complex_value = &cv;

  2838.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  2839.         return NGX_CONF_ERROR;
  2840.     }

  2842.     local = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_local_t));
  2843.     if (local == NULL) {
  2844.         return NGX_CONF_ERROR;
  2845.     }

  2847.     pscf->local = local;

  2849.     if (cv.lengths) {
  2850.         local->value = ngx_palloc(cf->pool, sizeof(ngx_stream_complex_value_t));
  2851.         if (local->value == NULL) {
  2852.             return NGX_CONF_ERROR;
  2853.         }

  2855.         *local->value = cv;

  2857.     } else {
  2858.         local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
  2859.         if (local->addr == NULL) {
  2860.             return NGX_CONF_ERROR;
  2861.         }

  2863.         rc = ngx_parse_addr_port(cf->pool, local->addr, value[1].data,
  2864.                                  value[1].len);

  2866.         switch (rc) {
  2867.         case NGX_OK:
  2868.             local->addr->name = value[1];
  2869.             break;

  2871.         case NGX_DECLINED:
  2872.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2873.                                "invalid address \"%V\"", &value[1]);
  2874.             /* fall through */

  2876.         default:
  2877.             return NGX_CONF_ERROR;
  2878.         }
  2879.     }

  2881.     if (cf->args->nelts > 2) {
  2882.         if (ngx_strcmp(value[2].data, "transparent") == 0) {
  2883. #if (NGX_HAVE_TRANSPARENT_PROXY)
  2884.             ngx_core_conf_t  *ccf;

  2886.             ccf = (ngx_core_conf_t *) ngx_get_conf(cf->cycle->conf_ctx,
  2887.                                                    ngx_core_module);

  2889.             ccf->transparent = 1;
  2890.             local->transparent = 1;
  2891. #else
  2892.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2893.                                "transparent proxying is not supported "
  2894.                                "on this platform, ignored");
  2895. #endif
  2896.         } else {
  2897.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2898.                                "invalid parameter \"%V\"", &value[2]);
  2899.             return NGX_CONF_ERROR;
  2900.         }
  2901.     }

  2903.     return NGX_CONF_OK;
  2904. }

One Level Up Top Level