One Level Up Top Level

src/stream/ngx_stream_proxy_module.c - nginx-1.31.3 nginx/ @ 42f8df65b

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_flag_t                       proxy_protocol;
  34.     ngx_flag_t                       half_close;
  35.     ngx_stream_upstream_local_t     *local;
  36.     ngx_flag_t                       socket_keepalive;

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

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

  57.     ngx_ssl_t                       *ssl;
  58. #endif

  60.     ngx_stream_upstream_srv_conf_t  *upstream;
  61.     ngx_stream_complex_value_t      *upstream_value;
  62. ‌} ngx_stream_proxy_srv_conf_t;


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

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

  96. #if (NGX_STREAM_SSL)

  98. static ngx_int_t ngx_stream_proxy_send_proxy_protocol(ngx_stream_session_t *s);
  99. static char *ngx_stream_proxy_ssl_alpn_set_slot(ngx_conf_t *cf,
  100.     ngx_command_t *cmd, void *conf);
  101. static char *ngx_stream_proxy_ssl_certificate_cache(ngx_conf_t *cf,
  102.     ngx_command_t *cmd, void *conf);
  103. static char *ngx_stream_proxy_ssl_password_file(ngx_conf_t *cf,
  104.     ngx_command_t *cmd, void *conf);
  105. static char *ngx_stream_proxy_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  106.     void *data);
  107. static void ngx_stream_proxy_ssl_init_connection(ngx_stream_session_t *s);
  108. static void ngx_stream_proxy_ssl_handshake(ngx_connection_t *pc);
  109. static void ngx_stream_proxy_ssl_save_session(ngx_connection_t *c);
  110. static ngx_int_t ngx_stream_proxy_ssl_name(ngx_stream_session_t *s);
  111. static ngx_int_t ngx_stream_proxy_ssl_alpn(ngx_stream_session_t *s);
  112. static ngx_int_t ngx_stream_proxy_ssl_certificate(ngx_stream_session_t *s);
  113. static ngx_int_t ngx_stream_proxy_merge_ssl(ngx_conf_t *cf,
  114.     ngx_stream_proxy_srv_conf_t *conf, ngx_stream_proxy_srv_conf_t *prev);
  115. static ngx_int_t ngx_stream_proxy_merge_ssl_passwords(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_set_ssl(ngx_conf_t *cf,
  118.     ngx_stream_proxy_srv_conf_t *pscf);


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

  131. ‌static ngx_conf_post_t  ngx_stream_proxy_ssl_conf_command_post =
  132.     { ngx_stream_proxy_ssl_conf_command_check };

  134. #endif


  137. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_proxy_downstream_buffer = {
  138.     ngx_conf_deprecated, "proxy_downstream_buffer", "proxy_buffer_size"
  139. };

  141. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_proxy_upstream_buffer = {
  142.     ngx_conf_deprecated, "proxy_upstream_buffer", "proxy_buffer_size"
  143. };


  146. ‌static ngx_command_t  ngx_stream_proxy_commands[] = {

  148.     { ngx_string("proxy_pass"),
  149.       NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  150.       ngx_stream_proxy_pass,
  151.       NGX_STREAM_SRV_CONF_OFFSET,
  152.       0,
  153.       NULL },

  155.     { ngx_string("proxy_bind"),
  156.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE12,
  157.       ngx_stream_proxy_bind,
  158.       NGX_STREAM_SRV_CONF_OFFSET,
  159.       0,
  160.       NULL },

  162.     { ngx_string("proxy_socket_keepalive"),
  163.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  164.       ngx_conf_set_flag_slot,
  165.       NGX_STREAM_SRV_CONF_OFFSET,
  166.       offsetof(ngx_stream_proxy_srv_conf_t, socket_keepalive),
  167.       NULL },

  169.     { ngx_string("proxy_connect_timeout"),
  170.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  171.       ngx_conf_set_msec_slot,
  172.       NGX_STREAM_SRV_CONF_OFFSET,
  173.       offsetof(ngx_stream_proxy_srv_conf_t, connect_timeout),
  174.       NULL },

  176.     { ngx_string("proxy_timeout"),
  177.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  178.       ngx_conf_set_msec_slot,
  179.       NGX_STREAM_SRV_CONF_OFFSET,
  180.       offsetof(ngx_stream_proxy_srv_conf_t, timeout),
  181.       NULL },

  183.     { ngx_string("proxy_buffer_size"),
  184.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  185.       ngx_conf_set_size_slot,
  186.       NGX_STREAM_SRV_CONF_OFFSET,
  187.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  188.       NULL },

  190.     { ngx_string("proxy_downstream_buffer"),
  191.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  192.       ngx_conf_set_size_slot,
  193.       NGX_STREAM_SRV_CONF_OFFSET,
  194.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  195.       &ngx_conf_deprecated_proxy_downstream_buffer },

  197.     { ngx_string("proxy_upstream_buffer"),
  198.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  199.       ngx_conf_set_size_slot,
  200.       NGX_STREAM_SRV_CONF_OFFSET,
  201.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  202.       &ngx_conf_deprecated_proxy_upstream_buffer },

  204.     { ngx_string("proxy_upload_rate"),
  205.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  206.       ngx_stream_set_complex_value_size_slot,
  207.       NGX_STREAM_SRV_CONF_OFFSET,
  208.       offsetof(ngx_stream_proxy_srv_conf_t, upload_rate),
  209.       NULL },

  211.     { ngx_string("proxy_download_rate"),
  212.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  213.       ngx_stream_set_complex_value_size_slot,
  214.       NGX_STREAM_SRV_CONF_OFFSET,
  215.       offsetof(ngx_stream_proxy_srv_conf_t, download_rate),
  216.       NULL },

  218.     { ngx_string("proxy_requests"),
  219.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  220.       ngx_conf_set_num_slot,
  221.       NGX_STREAM_SRV_CONF_OFFSET,
  222.       offsetof(ngx_stream_proxy_srv_conf_t, requests),
  223.       NULL },

  225.     { ngx_string("proxy_responses"),
  226.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  227.       ngx_conf_set_num_slot,
  228.       NGX_STREAM_SRV_CONF_OFFSET,
  229.       offsetof(ngx_stream_proxy_srv_conf_t, responses),
  230.       NULL },

  232.     { ngx_string("proxy_next_upstream"),
  233.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  234.       ngx_conf_set_flag_slot,
  235.       NGX_STREAM_SRV_CONF_OFFSET,
  236.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream),
  237.       NULL },

  239.     { ngx_string("proxy_next_upstream_tries"),
  240.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  241.       ngx_conf_set_num_slot,
  242.       NGX_STREAM_SRV_CONF_OFFSET,
  243.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream_tries),
  244.       NULL },

  246.     { ngx_string("proxy_next_upstream_timeout"),
  247.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  248.       ngx_conf_set_msec_slot,
  249.       NGX_STREAM_SRV_CONF_OFFSET,
  250.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream_timeout),
  251.       NULL },

  253.     { ngx_string("proxy_protocol"),
  254.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  255.       ngx_conf_set_flag_slot,
  256.       NGX_STREAM_SRV_CONF_OFFSET,
  257.       offsetof(ngx_stream_proxy_srv_conf_t, proxy_protocol),
  258.       NULL },

  260.     { ngx_string("proxy_half_close"),
  261.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  262.       ngx_conf_set_flag_slot,
  263.       NGX_STREAM_SRV_CONF_OFFSET,
  264.       offsetof(ngx_stream_proxy_srv_conf_t, half_close),
  265.       NULL },

  267. #if (NGX_STREAM_SSL)

  269.     { ngx_string("proxy_ssl"),
  270.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  271.       ngx_conf_set_flag_slot,
  272.       NGX_STREAM_SRV_CONF_OFFSET,
  273.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_enable),
  274.       NULL },

  276.     { ngx_string("proxy_ssl_session_reuse"),
  277.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  278.       ngx_conf_set_flag_slot,
  279.       NGX_STREAM_SRV_CONF_OFFSET,
  280.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_session_reuse),
  281.       NULL },

  283.     { ngx_string("proxy_ssl_protocols"),
  284.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  285.       ngx_conf_set_bitmask_slot,
  286.       NGX_STREAM_SRV_CONF_OFFSET,
  287.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_protocols),
  288.       &ngx_stream_proxy_ssl_protocols },

  290.     { ngx_string("proxy_ssl_ciphers"),
  291.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  292.       ngx_conf_set_str_slot,
  293.       NGX_STREAM_SRV_CONF_OFFSET,
  294.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_ciphers),
  295.       NULL },

  297.     { ngx_string("proxy_ssl_name"),
  298.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  299.       ngx_stream_set_complex_value_slot,
  300.       NGX_STREAM_SRV_CONF_OFFSET,
  301.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_name),
  302.       NULL },

  304.     { ngx_string("proxy_ssl_server_name"),
  305.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  306.       ngx_conf_set_flag_slot,
  307.       NGX_STREAM_SRV_CONF_OFFSET,
  308.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_server_name),
  309.       NULL },

  311.     { ngx_string("proxy_ssl_alpn"),
  312.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  313.       ngx_stream_proxy_ssl_alpn_set_slot,
  314.       NGX_STREAM_SRV_CONF_OFFSET,
  315.       0,
  316.       NULL },

  318.     { ngx_string("proxy_ssl_verify"),
  319.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  320.       ngx_conf_set_flag_slot,
  321.       NGX_STREAM_SRV_CONF_OFFSET,
  322.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_verify),
  323.       NULL },

  325.     { ngx_string("proxy_ssl_verify_depth"),
  326.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  327.       ngx_conf_set_num_slot,
  328.       NGX_STREAM_SRV_CONF_OFFSET,
  329.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_verify_depth),
  330.       NULL },

  332.     { ngx_string("proxy_ssl_trusted_certificate"),
  333.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  334.       ngx_conf_set_str_slot,
  335.       NGX_STREAM_SRV_CONF_OFFSET,
  336.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_trusted_certificate),
  337.       NULL },

  339.     { ngx_string("proxy_ssl_crl"),
  340.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  341.       ngx_conf_set_str_slot,
  342.       NGX_STREAM_SRV_CONF_OFFSET,
  343.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_crl),
  344.       NULL },

  346.     { ngx_string("proxy_ssl_certificate"),
  347.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  348.       ngx_stream_set_complex_value_zero_slot,
  349.       NGX_STREAM_SRV_CONF_OFFSET,
  350.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_certificate),
  351.       NULL },

  353.     { ngx_string("proxy_ssl_certificate_key"),
  354.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  355.       ngx_stream_set_complex_value_zero_slot,
  356.       NGX_STREAM_SRV_CONF_OFFSET,
  357.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_certificate_key),
  358.       NULL },

  360.     { ngx_string("proxy_ssl_certificate_cache"),
  361.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE123,
  362.       ngx_stream_proxy_ssl_certificate_cache,
  363.       NGX_STREAM_SRV_CONF_OFFSET,
  364.       0,
  365.       NULL },

  367.     { ngx_string("proxy_ssl_password_file"),
  368.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  369.       ngx_stream_proxy_ssl_password_file,
  370.       NGX_STREAM_SRV_CONF_OFFSET,
  371.       0,
  372.       NULL },

  374.     { ngx_string("proxy_ssl_conf_command"),
  375.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE2,
  376.       ngx_conf_set_keyval_slot,
  377.       NGX_STREAM_SRV_CONF_OFFSET,
  378.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_conf_commands),
  379.       &ngx_stream_proxy_ssl_conf_command_post },

  381. #endif

  383.       ngx_null_command
  384. };


  387. ‌static ngx_stream_module_t  ngx_stream_proxy_module_ctx = {
  388.     NULL,                                  /* preconfiguration */
  389.     NULL,                                  /* postconfiguration */

  391.     NULL,                                  /* create main configuration */
  392.     NULL,                                  /* init main configuration */

  394.     ngx_stream_proxy_create_srv_conf,      /* create server configuration */
  395.     ngx_stream_proxy_merge_srv_conf        /* merge server configuration */
  396. };


  399. ‌ngx_module_t  ngx_stream_proxy_module = {
  400.     NGX_MODULE_V1,
  401.     &ngx_stream_proxy_module_ctx,          /* module context */
  402.     ngx_stream_proxy_commands,             /* module directives */
  403.     NGX_STREAM_MODULE,                     /* module type */
  404.     NULL,                                  /* init master */
  405.     NULL,                                  /* init module */
  406.     NULL,                                  /* init process */
  407.     NULL,                                  /* init thread */
  408.     NULL,                                  /* exit thread */
  409.     NULL,                                  /* exit process */
  410.     NULL,                                  /* exit master */
  411.     NGX_MODULE_V1_PADDING
  412. };


  415. static void
  416. ‌ngx_stream_proxy_handler(ngx_stream_session_t *s)
  417. {
  418.     u_char                           *p;
  419.     ngx_str_t                        *host;
  420.     ngx_uint_t                        i;
  421.     ngx_connection_t                 *c;
  422.     ngx_resolver_ctx_t               *ctx, temp;
  423.     ngx_stream_upstream_t            *u;
  424.     ngx_stream_core_srv_conf_t       *cscf;
  425.     ngx_stream_proxy_srv_conf_t      *pscf;
  426.     ngx_stream_upstream_srv_conf_t   *uscf, **uscfp;
  427.     ngx_stream_upstream_main_conf_t  *umcf;

  429.     c = s->connection;

  431.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

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

  436.     u = ngx_pcalloc(c->pool, sizeof(ngx_stream_upstream_t));
  437.     if (u == NULL) {
  438.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  439.         return;
  440.     }

  442.     s->upstream = u;

  444.     s->log_handler = ngx_stream_proxy_log_error;

  446.     u->requests = 1;

  448.     u->peer.log = c->log;
  449.     u->peer.log_error = NGX_ERROR_ERR;

  451.     if (ngx_stream_proxy_set_local(s, u, pscf->local) != NGX_OK) {
  452.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  453.         return;
  454.     }

  456.     if (pscf->socket_keepalive) {
  457.         u->peer.so_keepalive = 1;
  458.     }

  460.     u->peer.type = c->type;
  461.     u->start_sec = ngx_time();

  463.     c->write->handler = ngx_stream_proxy_downstream_handler;
  464.     c->read->handler = ngx_stream_proxy_downstream_handler;

  466.     s->upstream_states = ngx_array_create(c->pool, 1,
  467.                                           sizeof(ngx_stream_upstream_state_t));
  468.     if (s->upstream_states == NULL) {
  469.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  470.         return;
  471.     }

  473.     p = ngx_pnalloc(c->pool, pscf->buffer_size);
  474.     if (p == NULL) {
  475.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  476.         return;
  477.     }

  479.     u->downstream_buf.start = p;
  480.     u->downstream_buf.end = p + pscf->buffer_size;
  481.     u->downstream_buf.pos = p;
  482.     u->downstream_buf.last = p;

  484.     if (c->read->ready) {
  485.         ngx_post_event(c->read, &ngx_posted_events);
  486.     }

  488.     if (pscf->upstream_value) {
  489.         if (ngx_stream_proxy_eval(s, pscf) != NGX_OK) {
  490.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  491.             return;
  492.         }
  493.     }

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

  497.         uscf = pscf->upstream;

  499.     } else {

  501. #if (NGX_STREAM_SSL)
  502.         u->ssl_name = u->resolved->host;
  503. #endif

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

  507.         umcf = ngx_stream_get_module_main_conf(s, ngx_stream_upstream_module);

  509.         uscfp = umcf->upstreams.elts;

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

  513.             uscf = uscfp[i];

  515.             if (uscf->host.len == host->len
  516.                 && ((uscf->port == 0 && u->resolved->no_port)
  517.                      || uscf->port == u->resolved->port)
  518.                 && ngx_strncasecmp(uscf->host.data, host->data, host->len) == 0)
  519.             {
  520.                 goto found;
  521.             }
  522.         }

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

  526.             if (u->resolved->port == 0
  527.                 && u->resolved->sockaddr->sa_family != AF_UNIX)
  528.             {
  529.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  530.                               "no port in upstream \"%V\"", host);
  531.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  532.                 return;
  533.             }

  535.             if (ngx_stream_upstream_create_round_robin_peer(s, u->resolved)
  536.                 != NGX_OK)
  537.             {
  538.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  539.                 return;
  540.             }

  542.             ngx_stream_proxy_connect(s);

  544.             return;
  545.         }

  547.         if (u->resolved->port == 0) {
  548.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  549.                           "no port in upstream \"%V\"", host);
  550.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  551.             return;
  552.         }

  554.         temp.name = *host;

  556.         cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  558.         ctx = ngx_resolve_start(cscf->resolver, &temp);
  559.         if (ctx == NULL) {
  560.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  561.             return;
  562.         }

  564.         if (ctx == NGX_NO_RESOLVER) {
  565.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  566.                           "no resolver defined to resolve %V", host);
  567.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  568.             return;
  569.         }

  571.         ctx->name = *host;
  572.         ctx->handler = ngx_stream_proxy_resolve_handler;
  573.         ctx->data = s;
  574.         ctx->timeout = cscf->resolver_timeout;

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

  578.         if (ngx_resolve_name(ctx) != NGX_OK) {
  579.             u->resolved->ctx = NULL;
  580.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  581.             return;
  582.         }

  584.         return;
  585.     }

  587. found:

  589.     if (uscf == NULL) {
  590.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "no upstream configuration");
  591.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  592.         return;
  593.     }

  595.     u->upstream = uscf;

  597. #if (NGX_STREAM_SSL)
  598.     u->ssl_name = uscf->host;
  599. #endif

  601.     if (uscf->peer.init(s, uscf) != NGX_OK) {
  602.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  603.         return;
  604.     }

  606.     u->peer.start_time = ngx_current_msec;

  608.     if (pscf->next_upstream_tries
  609.         && u->peer.tries > pscf->next_upstream_tries)
  610.     {
  611.         u->peer.tries = pscf->next_upstream_tries;
  612.     }

  614.     ngx_stream_proxy_connect(s);
  615. }


  618. static ngx_int_t
  619. ‌ngx_stream_proxy_eval(ngx_stream_session_t *s,
  620.     ngx_stream_proxy_srv_conf_t *pscf)
  621. {
  622.     ngx_str_t               host;
  623.     ngx_url_t               url;
  624.     ngx_stream_upstream_t  *u;

  626.     if (ngx_stream_complex_value(s, pscf->upstream_value, &host) != NGX_OK) {
  627.         return NGX_ERROR;
  628.     }

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

  632.     url.url = host;
  633.     url.no_resolve = 1;

  635.     if (ngx_parse_url(s->connection->pool, &url) != NGX_OK) {
  636.         if (url.err) {
  637.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  638.                           "%s in upstream \"%V\"", url.err, &url.url);
  639.         }

  641.         return NGX_ERROR;
  642.     }

  644.     u = s->upstream;

  646.     u->resolved = ngx_pcalloc(s->connection->pool,
  647.                               sizeof(ngx_stream_upstream_resolved_t));
  648.     if (u->resolved == NULL) {
  649.         return NGX_ERROR;
  650.     }

  652.     if (url.addrs) {
  653.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  654.         u->resolved->socklen = url.addrs[0].socklen;
  655.         u->resolved->name = url.addrs[0].name;
  656.         u->resolved->naddrs = 1;
  657.     }

  659.     u->resolved->host = url.host;
  660.     u->resolved->port = url.port;
  661.     u->resolved->no_port = url.no_port;

  663.     return NGX_OK;
  664. }


  667. static ngx_int_t
  668. ‌ngx_stream_proxy_set_local(ngx_stream_session_t *s, ngx_stream_upstream_t *u,
  669.     ngx_stream_upstream_local_t *local)
  670. {
  671.     ngx_int_t    rc;
  672.     ngx_str_t    val;
  673.     ngx_addr_t  *addr;

  675.     if (local == NULL) {
  676.         u->peer.local = NULL;
  677.         return NGX_OK;
  678.     }

  680. #if (NGX_HAVE_TRANSPARENT_PROXY)
  681.     u->peer.transparent = local->transparent;
  682. #endif

  684.     if (local->value == NULL) {
  685.         u->peer.local = local->addr;
  686.         return NGX_OK;
  687.     }

  689.     if (ngx_stream_complex_value(s, local->value, &val) != NGX_OK) {
  690.         return NGX_ERROR;
  691.     }

  693.     if (val.len == 0) {
  694.         u->peer.local = NULL;
  695.         return NGX_OK;
  696.     }

  698.     addr = ngx_palloc(s->connection->pool, sizeof(ngx_addr_t));
  699.     if (addr == NULL) {
  700.         return NGX_ERROR;
  701.     }

  703.     rc = ngx_parse_addr_port(s->connection->pool, addr, val.data, val.len);
  704.     if (rc == NGX_ERROR) {
  705.         return NGX_ERROR;
  706.     }

  708.     if (rc != NGX_OK) {
  709.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  710.                       "invalid local address \"%V\"", &val);
  711.         u->peer.local = NULL;
  712.         return NGX_OK;
  713.     }

  715.     addr->name = val;
  716.     u->peer.local = addr;

  718.     return NGX_OK;
  719. }


  722. static void
  723. ‌ngx_stream_proxy_connect(ngx_stream_session_t *s)
  724. {
  725.     ngx_int_t                     rc;
  726.     ngx_connection_t             *c, *pc;
  727.     ngx_stream_upstream_t        *u;
  728.     ngx_stream_proxy_srv_conf_t  *pscf;

  730.     c = s->connection;

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

  734.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  736.     u = s->upstream;

  738.     u->connected = 0;
  739.     u->proxy_protocol = pscf->proxy_protocol;

  741.     if (u->state) {
  742.         u->state->response_time = ngx_current_msec - u->start_time;
  743.     }

  745.     u->state = ngx_array_push(s->upstream_states);
  746.     if (u->state == NULL) {
  747.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  748.         return;
  749.     }

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

  753.     u->start_time = ngx_current_msec;

  755.     u->state->connect_time = (ngx_msec_t) -1;
  756.     u->state->first_byte_time = (ngx_msec_t) -1;
  757.     u->state->response_time = (ngx_msec_t) -1;

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

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

  763.     if (rc == NGX_ERROR) {
  764.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  765.         return;
  766.     }

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

  770. #if (NGX_STREAM_UPSTREAM_ZONE)
  771.     if (u->upstream && u->upstream->shm_zone
  772.         && (u->upstream->flags & NGX_STREAM_UPSTREAM_MODIFY))
  773.     {
  774.         u->state->peer = ngx_palloc(s->connection->pool,
  775.                                     sizeof(ngx_str_t) + u->peer.name->len);
  776.         if (u->state->peer == NULL) {
  777.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  778.             return;
  779.         }

  781.         u->state->peer->len = u->peer.name->len;
  782.         u->state->peer->data = (u_char *) (u->state->peer + 1);
  783.         ngx_memcpy(u->state->peer->data, u->peer.name->data, u->peer.name->len);

  785.         u->peer.name = u->state->peer;
  786.     }
  787. #endif

  789.     if (rc == NGX_BUSY) {
  790.         ngx_log_error(NGX_LOG_ERR, c->log, 0, "no live upstreams");
  791.         ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);
  792.         return;
  793.     }

  795.     if (rc == NGX_DECLINED) {
  796.         ngx_stream_proxy_next_upstream(s);
  797.         return;
  798.     }

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

  802.     pc = u->peer.connection;

  804.     pc->data = s;
  805.     pc->log = c->log;
  806.     pc->pool = c->pool;
  807.     pc->read->log = c->log;
  808.     pc->write->log = c->log;

  810.     if (rc != NGX_AGAIN) {
  811.         ngx_stream_proxy_init_upstream(s);
  812.         return;
  813.     }

  815.     pc->read->handler = ngx_stream_proxy_connect_handler;
  816.     pc->write->handler = ngx_stream_proxy_connect_handler;

  818.     ngx_add_timer(pc->write, pscf->connect_timeout);
  819. }


  822. static void
  823. ‌ngx_stream_proxy_init_upstream(ngx_stream_session_t *s)
  824. {
  825.     u_char                       *p;
  826.     ngx_chain_t                  *cl;
  827.     ngx_connection_t             *c, *pc;
  828.     ngx_log_handler_pt            handler;
  829.     ngx_stream_upstream_t        *u;
  830.     ngx_stream_core_srv_conf_t   *cscf;
  831.     ngx_stream_proxy_srv_conf_t  *pscf;

  833.     u = s->upstream;
  834.     pc = u->peer.connection;

  836.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  838.     if (pc->type == SOCK_STREAM
  839.         && cscf->tcp_nodelay
  840.         && ngx_tcp_nodelay(pc) != NGX_OK)
  841.     {
  842.         ngx_stream_proxy_next_upstream(s);
  843.         return;
  844.     }

  846.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  848. #if (NGX_STREAM_SSL)

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

  852.         if (u->proxy_protocol) {
  853.             if (ngx_stream_proxy_send_proxy_protocol(s) != NGX_OK) {
  854.                 return;
  855.             }

  857.             u->proxy_protocol = 0;
  858.         }

  860.         if (pc->ssl == NULL) {
  861.             ngx_stream_proxy_ssl_init_connection(s);
  862.             return;
  863.         }
  864.     }

  866. #endif

  868.     c = s->connection;

  870.     if (c->log->log_level >= NGX_LOG_INFO) {
  871.         ngx_str_t  str;
  872.         u_char     addr[NGX_SOCKADDR_STRLEN];

  874.         str.len = NGX_SOCKADDR_STRLEN;
  875.         str.data = addr;

  877.         if (ngx_connection_local_sockaddr(pc, &str, 1) == NGX_OK) {
  878.             handler = c->log->handler;
  879.             c->log->handler = NULL;

  881.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  882.                           "%sproxy %V connected to %V",
  883.                           pc->type == SOCK_DGRAM ? "udp " : "",
  884.                           &str, u->peer.name);

  886.             c->log->handler = handler;
  887.         }
  888.     }

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

  892.     if (u->peer.notify) {
  893.         u->peer.notify(&u->peer, u->peer.data,
  894.                        NGX_STREAM_UPSTREAM_NOTIFY_CONNECT);
  895.     }

  897.     if (u->upstream_buf.start == NULL) {
  898.         p = ngx_pnalloc(c->pool, pscf->buffer_size);
  899.         if (p == NULL) {
  900.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  901.             return;
  902.         }

  904.         u->upstream_buf.start = p;
  905.         u->upstream_buf.end = p + pscf->buffer_size;
  906.         u->upstream_buf.pos = p;
  907.         u->upstream_buf.last = p;
  908.     }

  910.     if (c->buffer && c->buffer->pos <= c->buffer->last) {
  911.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  912.                        "stream proxy add preread buffer: %uz",
  913.                        c->buffer->last - c->buffer->pos);

  915.         cl = ngx_chain_get_free_buf(c->pool, &u->free);
  916.         if (cl == NULL) {
  917.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  918.             return;
  919.         }

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

  923.         cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;
  924.         cl->buf->temporary = (cl->buf->pos == cl->buf->last) ? 0 : 1;
  925.         cl->buf->flush = 1;

  927.         cl->next = u->upstream_out;
  928.         u->upstream_out = cl;
  929.     }

  931.     if (u->proxy_protocol) {
  932.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  933.                        "stream proxy add PROXY protocol header");

  935.         cl = ngx_chain_get_free_buf(c->pool, &u->free);
  936.         if (cl == NULL) {
  937.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  938.             return;
  939.         }

  941.         p = ngx_pnalloc(c->pool, NGX_PROXY_PROTOCOL_V1_MAX_HEADER);
  942.         if (p == NULL) {
  943.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  944.             return;
  945.         }

  947.         cl->buf->pos = p;

  949.         p = ngx_proxy_protocol_write(c, p,
  950.                                      p + NGX_PROXY_PROTOCOL_V1_MAX_HEADER);
  951.         if (p == NULL) {
  952.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  953.             return;
  954.         }

  956.         cl->buf->last = p;
  957.         cl->buf->temporary = 1;
  958.         cl->buf->flush = 0;
  959.         cl->buf->last_buf = 0;
  960.         cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;

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

  965.         u->proxy_protocol = 0;
  966.     }

  968.     u->upload_rate = ngx_stream_complex_value_size(s, pscf->upload_rate, 0);
  969.     u->download_rate = ngx_stream_complex_value_size(s, pscf->download_rate, 0);

  971.     u->connected = 1;

  973.     pc->read->handler = ngx_stream_proxy_upstream_handler;
  974.     pc->write->handler = ngx_stream_proxy_upstream_handler;

  976.     if (pc->read->ready) {
  977.         ngx_post_event(pc->read, &ngx_posted_events);
  978.     }

  980.     ngx_stream_proxy_process(s, 0, 1);
  981. }


  984. #if (NGX_STREAM_SSL)

  986. static ngx_int_t
  987. ‌ngx_stream_proxy_send_proxy_protocol(ngx_stream_session_t *s)
  988. {
  989.     u_char                       *p;
  990.     ssize_t                       n, size;
  991.     ngx_connection_t             *c, *pc;
  992.     ngx_stream_upstream_t        *u;
  993.     ngx_stream_proxy_srv_conf_t  *pscf;
  994.     u_char                        buf[NGX_PROXY_PROTOCOL_V1_MAX_HEADER];

  996.     c = s->connection;

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

  1001.     p = ngx_proxy_protocol_write(c, buf,
  1002.                                  buf + NGX_PROXY_PROTOCOL_V1_MAX_HEADER);
  1003.     if (p == NULL) {
  1004.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1005.         return NGX_ERROR;
  1006.     }

  1008.     u = s->upstream;

  1010.     pc = u->peer.connection;

  1012.     size = p - buf;

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

  1016.     if (n == NGX_AGAIN) {
  1017.         if (ngx_handle_write_event(pc->write, 0) != NGX_OK) {
  1018.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1019.             return NGX_ERROR;
  1020.         }

  1022.         pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

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

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

  1028.         return NGX_AGAIN;
  1029.     }

  1031.     if (n == NGX_ERROR) {
  1032.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1033.         return NGX_ERROR;
  1034.     }

  1036.     if (n != size) {

  1038.         /*
  1039.          * PROXY protocol specification:
  1040.          * The sender must always ensure that the header
  1041.          * is sent at once, so that the transport layer
  1042.          * maintains atomicity along the path to the receiver.
  1043.          */

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

  1048.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);

  1050.         return NGX_ERROR;
  1051.     }

  1053.     return NGX_OK;
  1054. }


  1057. static char *
  1058. ‌ngx_stream_proxy_ssl_alpn_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  1059.     void *conf)
  1060. {
  1061. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1063.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  1065.     ngx_str_t                           *value;
  1066.     ngx_uint_t                           i;
  1067.     ngx_stream_complex_value_t          *cv;
  1068.     ngx_stream_compile_complex_value_t   ccv;

  1070.     if (pscf->ssl_alpn != NGX_CONF_UNSET_PTR) {
  1071.         return "is duplicate";
  1072.     }

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

  1076.     pscf->ssl_alpn = ngx_array_create(cf->pool, cf->args->nelts - 1,
  1077.                                       sizeof(ngx_stream_complex_value_t));
  1078.     if (pscf->ssl_alpn == NULL) {
  1079.         return NGX_CONF_ERROR;
  1080.     }

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

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

  1087.         ccv.cf = cf;
  1088.         ccv.value = &value[i];
  1089.         ccv.complex_value = &cv[i - 1];

  1091.         if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1092.             return NGX_CONF_ERROR;
  1093.         }

  1095.         if (cv[i - 1].lengths == NULL && value[i].len > 255) {
  1096.             return "protocol too long";
  1097.         }
  1098.     }

  1100.     return NGX_CONF_OK;

  1102. #else
  1103.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1104.                        "the \"proxy_ssl_alpn\" directive requires "
  1105.                        "OpenSSL with ALPN support");

  1107.     return NGX_CONF_ERROR;
  1108. #endif
  1109. }


  1112. static char *
  1113. ‌ngx_stream_proxy_ssl_certificate_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  1114.     void *conf)
  1115. {
  1116.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  1118.     time_t       inactive, valid;
  1119.     ngx_str_t   *value, s;
  1120.     ngx_int_t    max;
  1121.     ngx_uint_t   i;

  1123.     if (pscf->ssl_certificate_cache != NGX_CONF_UNSET_PTR) {
  1124.         return "is duplicate";
  1125.     }

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

  1129.     max = 0;
  1130.     inactive = 10;
  1131.     valid = 60;

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

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

  1137.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  1138.             if (max <= 0) {
  1139.                 goto failed;
  1140.             }

  1142.             continue;
  1143.         }

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

  1147.             s.len = value[i].len - 9;
  1148.             s.data = value[i].data + 9;

  1150.             inactive = ngx_parse_time(&s, 1);
  1151.             if (inactive == (time_t) NGX_ERROR) {
  1152.                 goto failed;
  1153.             }

  1155.             continue;
  1156.         }

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

  1160.             s.len = value[i].len - 6;
  1161.             s.data = value[i].data + 6;

  1163.             valid = ngx_parse_time(&s, 1);
  1164.             if (valid == (time_t) NGX_ERROR) {
  1165.                 goto failed;
  1166.             }

  1168.             continue;
  1169.         }

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

  1173.             pscf->ssl_certificate_cache = NULL;

  1175.             continue;
  1176.         }

  1178.     failed:

  1180.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1181.                            "invalid parameter \"%V\"", &value[i]);
  1182.         return NGX_CONF_ERROR;
  1183.     }

  1185.     if (pscf->ssl_certificate_cache == NULL) {
  1186.         return NGX_CONF_OK;
  1187.     }

  1189.     if (max == 0) {
  1190.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1191.                            "\"proxy_ssl_certificate_cache\" must have "
  1192.                            "the \"max\" parameter");
  1193.         return NGX_CONF_ERROR;
  1194.     }

  1196.     pscf->ssl_certificate_cache = ngx_ssl_cache_init(cf->pool, max, valid,
  1197.                                                      inactive);
  1198.     if (pscf->ssl_certificate_cache == NULL) {
  1199.         return NGX_CONF_ERROR;
  1200.     }

  1202.     return NGX_CONF_OK;
  1203. }


  1206. static char *
  1207. ‌ngx_stream_proxy_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd,
  1208.     void *conf)
  1209. {
  1210.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  1212.     ngx_str_t  *value;

  1214.     if (pscf->ssl_passwords != NGX_CONF_UNSET_PTR) {
  1215.         return "is duplicate";
  1216.     }

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

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

  1222.     if (pscf->ssl_passwords == NULL) {
  1223.         return NGX_CONF_ERROR;
  1224.     }

  1226.     return NGX_CONF_OK;
  1227. }


  1230. static char *
  1231. ‌ngx_stream_proxy_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  1232. {
  1233. #ifndef SSL_CONF_FLAG_FILE
  1234.     return "is not supported on this platform";
  1235. #else
  1236.     return NGX_CONF_OK;
  1237. #endif
  1238. }


  1241. static void
  1242. ‌ngx_stream_proxy_ssl_init_connection(ngx_stream_session_t *s)
  1243. {
  1244.     ngx_int_t                     rc;
  1245.     ngx_connection_t             *pc;
  1246.     ngx_stream_upstream_t        *u;
  1247.     ngx_stream_proxy_srv_conf_t  *pscf;

  1249.     u = s->upstream;

  1251.     pc = u->peer.connection;

  1253.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1255.     if (ngx_ssl_create_connection(pscf->ssl, pc, NGX_SSL_BUFFER|NGX_SSL_CLIENT)
  1256.         != NGX_OK)
  1257.     {
  1258.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1259.         return;
  1260.     }

  1262.     if (pscf->ssl_server_name || pscf->ssl_verify) {
  1263.         if (ngx_stream_proxy_ssl_name(s) != NGX_OK) {
  1264.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1265.             return;
  1266.         }
  1267.     }

  1269.     if (pscf->ssl_alpn) {
  1270.         if (ngx_stream_proxy_ssl_alpn(s) != NGX_OK) {
  1271.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1272.             return;
  1273.         }
  1274.     }

  1276.     if (pscf->ssl_certificate
  1277.         && pscf->ssl_certificate->value.len
  1278.         && (pscf->ssl_certificate->lengths
  1279.             || pscf->ssl_certificate_key->lengths))
  1280.     {
  1281.         if (ngx_stream_proxy_ssl_certificate(s) != NGX_OK) {
  1282.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1283.             return;
  1284.         }
  1285.     }

  1287.     if (pscf->ssl_session_reuse) {
  1288.         pc->ssl->save_session = ngx_stream_proxy_ssl_save_session;

  1290.         if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
  1291.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1292.             return;
  1293.         }
  1294.     }

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

  1298.     rc = ngx_ssl_handshake(pc);

  1300.     if (rc == NGX_AGAIN) {

  1302.         if (!pc->write->timer_set) {
  1303.             ngx_add_timer(pc->write, pscf->connect_timeout);
  1304.         }

  1306.         pc->ssl->handler = ngx_stream_proxy_ssl_handshake;
  1307.         return;
  1308.     }

  1310.     ngx_stream_proxy_ssl_handshake(pc);
  1311. }


  1314. static void
  1315. ‌ngx_stream_proxy_ssl_handshake(ngx_connection_t *pc)
  1316. {
  1317.     long                          rc;
  1318.     ngx_stream_session_t         *s;
  1319.     ngx_stream_upstream_t        *u;
  1320.     ngx_stream_proxy_srv_conf_t  *pscf;

  1322.     s = pc->data;

  1324.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

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

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

  1331.             if (rc != X509_V_OK) {
  1332.                 ngx_log_error(NGX_LOG_ERR, pc->log, 0,
  1333.                               "upstream SSL certificate verify error: (%l:%s)",
  1334.                               rc, X509_verify_cert_error_string(rc));
  1335.                 goto failed;
  1336.             }

  1338.             u = s->upstream;

  1340.             if (ngx_ssl_check_host(pc, &u->ssl_name) != NGX_OK) {
  1341.                 ngx_log_error(NGX_LOG_ERR, pc->log, 0,
  1342.                               "upstream SSL certificate does not match \"%V\"",
  1343.                               &u->ssl_name);
  1344.                 goto failed;
  1345.             }
  1346.         }

  1348.         if (pc->write->timer_set) {
  1349.             ngx_del_timer(pc->write);
  1350.         }

  1352.         ngx_stream_proxy_init_upstream(s);

  1354.         return;
  1355.     }

  1357. failed:

  1359.     ngx_stream_proxy_next_upstream(s);
  1360. }


  1363. static void
  1364. ‌ngx_stream_proxy_ssl_save_session(ngx_connection_t *c)
  1365. {
  1366.     ngx_stream_session_t   *s;
  1367.     ngx_stream_upstream_t  *u;

  1369.     s = c->data;
  1370.     u = s->upstream;

  1372.     u->peer.save_session(&u->peer, u->peer.data);
  1373. }


  1376. static ngx_int_t
  1377. ‌ngx_stream_proxy_ssl_name(ngx_stream_session_t *s)
  1378. {
  1379.     u_char                       *p, *last;
  1380.     ngx_str_t                     name;
  1381.     ngx_stream_upstream_t        *u;
  1382.     ngx_stream_proxy_srv_conf_t  *pscf;

  1384.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1386.     u = s->upstream;

  1388.     if (pscf->ssl_name) {
  1389.         if (ngx_stream_complex_value(s, pscf->ssl_name, &name) != NGX_OK) {
  1390.             return NGX_ERROR;
  1391.         }

  1393.     } else {
  1394.         name = u->ssl_name;
  1395.     }

  1397.     if (name.len == 0) {
  1398.         goto done;
  1399.     }

  1401.     /*
  1402.      * ssl name here may contain port, strip it for compatibility
  1403.      * with the http module
  1404.      */

  1406.     p = name.data;
  1407.     last = name.data + name.len;

  1409.     if (*p == '[') {
  1410.         p = ngx_strlchr(p, last, ']');

  1412.         if (p == NULL) {
  1413.             p = name.data;
  1414.         }
  1415.     }

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

  1419.     if (p != NULL) {
  1420.         name.len = p - name.data;
  1421.     }

  1423.     if (!pscf->ssl_server_name) {
  1424.         goto done;
  1425.     }

  1427. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  1431.     if (name.len == 0 || *name.data == '[') {
  1432.         goto done;
  1433.     }

  1435.     if (ngx_inet_addr(name.data, name.len) != INADDR_NONE) {
  1436.         goto done;
  1437.     }

  1439.     /*
  1440.      * SSL_set_tlsext_host_name() needs a null-terminated string,
  1441.      * hence we explicitly null-terminate name here
  1442.      */

  1444.     p = ngx_pnalloc(s->connection->pool, name.len + 1);
  1445.     if (p == NULL) {
  1446.         return NGX_ERROR;
  1447.     }

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

  1451.     name.data = p;

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

  1456.     if (SSL_set_tlsext_host_name(u->peer.connection->ssl->connection,
  1457.                                  (char *) name.data)
  1458.         == 0)
  1459.     {
  1460.         ngx_ssl_error(NGX_LOG_ERR, s->connection->log, 0,
  1461.                       "SSL_set_tlsext_host_name(\"%s\") failed", name.data);
  1462.         return NGX_ERROR;
  1463.     }

  1465. #endif

  1467. done:

  1469.     u->ssl_name = name;

  1471.     return NGX_OK;
  1472. }


  1475. static ngx_int_t
  1476. ‌ngx_stream_proxy_ssl_alpn(ngx_stream_session_t *s)
  1477. {
  1478. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1480.     size_t                        len;
  1481.     u_char                       *p, *buf;
  1482.     ngx_str_t                     proto, *value;
  1483.     ngx_uint_t                    i;
  1484.     ngx_array_t                  *values;
  1485.     ngx_connection_t             *c;
  1486.     ngx_stream_upstream_t        *u;
  1487.     ngx_stream_complex_value_t   *cv;
  1488.     ngx_stream_proxy_srv_conf_t  *pscf;

  1490.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1492.     u = s->upstream;
  1493.     c = u->peer.connection;

  1495.     values = NULL;
  1496.     len = 0;

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

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

  1502.         if (ngx_stream_complex_value(s, &cv[i], &proto) != NGX_OK) {
  1503.             return NGX_ERROR;
  1504.         }

  1506.         if (proto.len == 0 || proto.len > 255) {
  1507.             continue;
  1508.         }

  1510.         if (values == NULL) {
  1511.             values = ngx_array_create(c->pool, 1, sizeof(ngx_str_t));
  1512.             if (values == NULL) {
  1513.                 return NGX_ERROR;
  1514.             }
  1515.         }

  1517.         value = ngx_array_push(values);
  1518.         if (value == NULL) {
  1519.             return NGX_ERROR;
  1520.         }

  1522.         *value = proto;

  1524.         len += 1 + proto.len;
  1525.     }

  1527.     if (len == 0) {
  1528.         return NGX_OK;
  1529.     }

  1531.     buf = ngx_pnalloc(c->pool, len);
  1532.     if (buf == NULL) {
  1533.         return NGX_ERROR;
  1534.     }

  1536.     p = buf;
  1537.     value = values->elts;

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

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

  1544.         *p++ = value[i].len;
  1545.         p = ngx_cpymem(p, value[i].data, value[i].len);
  1546.     }

  1548.     if (SSL_set_alpn_protos(c->ssl->connection, buf, p - buf) != 0) {
  1549.         ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  1550.                       "SSL_set_alpn_protos() failed");
  1551.         return NGX_ERROR;
  1552.     }

  1554. #endif

  1556.     return NGX_OK;
  1557. }


  1560. static ngx_int_t
  1561. ‌ngx_stream_proxy_ssl_certificate(ngx_stream_session_t *s)
  1562. {
  1563.     ngx_str_t                     cert, key;
  1564.     ngx_connection_t             *c;
  1565.     ngx_stream_proxy_srv_conf_t  *pscf;

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

  1569.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1571.     if (ngx_stream_complex_value(s, pscf->ssl_certificate, &cert)
  1572.         != NGX_OK)
  1573.     {
  1574.         return NGX_ERROR;
  1575.     }

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

  1580.     if (*cert.data == '\0') {
  1581.         return NGX_OK;
  1582.     }

  1584.     if (ngx_stream_complex_value(s, pscf->ssl_certificate_key, &key)
  1585.         != NGX_OK)
  1586.     {
  1587.         return NGX_ERROR;
  1588.     }

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

  1593.     if (ngx_ssl_connection_certificate(c, c->pool, &cert, &key,
  1594.                                        pscf->ssl_certificate_cache,
  1595.                                        pscf->ssl_passwords)
  1596.         != NGX_OK)
  1597.     {
  1598.         return NGX_ERROR;
  1599.     }

  1601.     return NGX_OK;
  1602. }

  1604. #endif


  1607. static void
  1608. ‌ngx_stream_proxy_downstream_handler(ngx_event_t *ev)
  1609. {
  1610.     ngx_stream_proxy_process_connection(ev, ev->write);
  1611. }


  1614. static void
  1615. ‌ngx_stream_proxy_resolve_handler(ngx_resolver_ctx_t *ctx)
  1616. {
  1617.     ngx_stream_session_t            *s;
  1618.     ngx_stream_upstream_t           *u;
  1619.     ngx_stream_proxy_srv_conf_t     *pscf;
  1620.     ngx_stream_upstream_resolved_t  *ur;

  1622.     s = ctx->data;

  1624.     u = s->upstream;
  1625.     ur = u->resolved;

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

  1630.     if (ctx->state) {
  1631.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1632.                       "%V could not be resolved (%i: %s)",
  1633.                       &ctx->name, ctx->state,
  1634.                       ngx_resolver_strerror(ctx->state));

  1636.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1637.         return;
  1638.     }

  1640.     ur->naddrs = ctx->naddrs;
  1641.     ur->addrs = ctx->addrs;

  1643. #if (NGX_DEBUG)
  1644.     {
  1645.     u_char      text[NGX_SOCKADDR_STRLEN];
  1646.     ngx_str_t   addr;
  1647.     ngx_uint_t  i;

  1649.     addr.data = text;

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

  1655.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  1656.                        "name was resolved to %V", &addr);
  1657.     }
  1658.     }
  1659. #endif

  1661.     if (ngx_stream_upstream_create_round_robin_peer(s, ur) != NGX_OK) {
  1662.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1663.         return;
  1664.     }

  1666.     ngx_resolve_name_done(ctx);
  1667.     ur->ctx = NULL;

  1669.     u->peer.start_time = ngx_current_msec;

  1671.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1673.     if (pscf->next_upstream_tries
  1674.         && u->peer.tries > pscf->next_upstream_tries)
  1675.     {
  1676.         u->peer.tries = pscf->next_upstream_tries;
  1677.     }

  1679.     ngx_stream_proxy_connect(s);
  1680. }


  1683. static void
  1684. ‌ngx_stream_proxy_upstream_handler(ngx_event_t *ev)
  1685. {
  1686.     ngx_stream_proxy_process_connection(ev, !ev->write);
  1687. }


  1690. static void
  1691. ‌ngx_stream_proxy_process_connection(ngx_event_t *ev, ngx_uint_t from_upstream)
  1692. {
  1693.     ngx_connection_t             *c, *pc;
  1694.     ngx_log_handler_pt            handler;
  1695.     ngx_stream_session_t         *s;
  1696.     ngx_stream_upstream_t        *u;
  1697.     ngx_stream_proxy_srv_conf_t  *pscf;

  1699.     c = ev->data;
  1700.     s = c->data;
  1701.     u = s->upstream;

  1703.     if (c->close) {
  1704.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "shutdown timeout");
  1705.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1706.         return;
  1707.     }

  1709.     c = s->connection;
  1710.     pc = u->peer.connection;

  1712.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1714.     if (ev->timedout) {
  1715.         ev->timedout = 0;

  1717.         if (ev->delayed) {
  1718.             ev->delayed = 0;

  1720.             if (!ev->ready) {
  1721.                 if (ngx_handle_read_event(ev, 0) != NGX_OK) {
  1722.                     ngx_stream_proxy_finalize(s,
  1723.                                               NGX_STREAM_INTERNAL_SERVER_ERROR);
  1724.                     return;
  1725.                 }

  1727.                 if (u->connected && !c->read->delayed && !pc->read->delayed) {
  1728.                     ngx_add_timer(c->write, pscf->timeout);
  1729.                 }

  1731.                 return;
  1732.             }

  1734.         } else {
  1735.             if (s->connection->type == SOCK_DGRAM) {

  1737.                 if (pscf->responses == NGX_MAX_INT32_VALUE
  1738.                     || (u->responses >= pscf->responses * u->requests))
  1739.                 {

  1741.                     /*
  1742.                      * successfully terminate timed out UDP session
  1743.                      * if expected number of responses was received
  1744.                      */

  1746.                     handler = c->log->handler;
  1747.                     c->log->handler = NULL;

  1749.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1750.                                   "udp timed out"
  1751.                                   ", packets from/to client:%ui/%ui"
  1752.                                   ", bytes from/to client:%O/%O"
  1753.                                   ", bytes from/to upstream:%O/%O",
  1754.                                   u->requests, u->responses,
  1755.                                   s->received, c->sent, u->received,
  1756.                                   pc ? pc->sent : 0);

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

  1760.                     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1761.                     return;
  1762.                 }

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

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

  1768.                 ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);

  1770.                 return;
  1771.             }

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

  1775.             ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  1777.             return;
  1778.         }

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

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

  1785.         if (ngx_handle_read_event(ev, 0) != NGX_OK) {
  1786.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1787.         }

  1789.         return;
  1790.     }

  1792.     if (from_upstream && !u->connected) {
  1793.         return;
  1794.     }

  1796.     ngx_stream_proxy_process(s, from_upstream, ev->write);
  1797. }


  1800. static void
  1801. ‌ngx_stream_proxy_connect_handler(ngx_event_t *ev)
  1802. {
  1803.     ngx_connection_t      *c;
  1804.     ngx_stream_session_t  *s;

  1806.     c = ev->data;
  1807.     s = c->data;

  1809.     if (ev->timedout) {
  1810.         ngx_log_error(NGX_LOG_ERR, c->log, NGX_ETIMEDOUT, "upstream timed out");
  1811.         ngx_stream_proxy_next_upstream(s);
  1812.         return;
  1813.     }

  1815.     ngx_del_timer(c->write);

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

  1820.     if (ngx_stream_proxy_test_connect(c) != NGX_OK) {
  1821.         ngx_stream_proxy_next_upstream(s);
  1822.         return;
  1823.     }

  1825.     ngx_stream_proxy_init_upstream(s);
  1826. }


  1829. static ngx_int_t
  1830. ‌ngx_stream_proxy_test_connect(ngx_connection_t *c)
  1831. {
  1832.     int        err;
  1833.     socklen_t  len;

  1835. #if (NGX_HAVE_KQUEUE)

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

  1840.         if (err) {
  1841.             (void) ngx_connection_error(c, err,
  1842.                                     "kevent() reported that connect() failed");
  1843.             return NGX_ERROR;
  1844.         }

  1846.     } else
  1847. #endif
  1848.     {
  1849.         err = 0;
  1850.         len = sizeof(int);

  1852.         /*
  1853.          * BSDs and Linux return 0 and set a pending error in err
  1854.          * Solaris returns -1 and sets errno
  1855.          */

  1857.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  1858.             == -1)
  1859.         {
  1860.             err = ngx_socket_errno;
  1861.         }

  1863.         if (err) {
  1864.             (void) ngx_connection_error(c, err, "connect() failed");
  1865.             return NGX_ERROR;
  1866.         }
  1867.     }

  1869.     return NGX_OK;
  1870. }


  1873. static void
  1874. ‌ngx_stream_proxy_process(ngx_stream_session_t *s, ngx_uint_t from_upstream,
  1875.     ngx_uint_t do_write)
  1876. {
  1877.     char                         *recv_action, *send_action;
  1878.     off_t                        *received, limit;
  1879.     size_t                        size, limit_rate;
  1880.     ssize_t                       n;
  1881.     ngx_buf_t                    *b;
  1882.     ngx_int_t                     rc;
  1883.     ngx_uint_t                    flags, *packets;
  1884.     ngx_msec_t                    delay;
  1885.     ngx_chain_t                  *cl, **ll, **out, **busy;
  1886.     ngx_connection_t             *c, *pc, *src, *dst;
  1887.     ngx_log_handler_pt            handler;
  1888.     ngx_stream_upstream_t        *u;
  1889.     ngx_stream_proxy_srv_conf_t  *pscf;

  1891.     u = s->upstream;

  1893.     c = s->connection;
  1894.     pc = u->connected ? u->peer.connection : NULL;

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

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

  1900.         handler = c->log->handler;
  1901.         c->log->handler = NULL;

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

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

  1907.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1908.         return;
  1909.     }

  1911.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1913.     if (from_upstream) {
  1914.         src = pc;
  1915.         dst = c;
  1916.         b = &u->upstream_buf;
  1917.         limit_rate = u->download_rate;
  1918.         received = &u->received;
  1919.         packets = &u->responses;
  1920.         out = &u->downstream_out;
  1921.         busy = &u->downstream_busy;
  1922.         recv_action = "proxying and reading from upstream";
  1923.         send_action = "proxying and sending to client";

  1925.     } else {
  1926.         src = c;
  1927.         dst = pc;
  1928.         b = &u->downstream_buf;
  1929.         limit_rate = u->upload_rate;
  1930.         received = &s->received;
  1931.         packets = &u->requests;
  1932.         out = &u->upstream_out;
  1933.         busy = &u->upstream_busy;
  1934.         recv_action = "proxying and reading from client";
  1935.         send_action = "proxying and sending to upstream";
  1936.     }

  1938.     for ( ;; ) {

  1940.         if (do_write && dst) {

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

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

  1947.                 if (rc == NGX_ERROR) {
  1948.                     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1949.                     return;
  1950.                 }

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

  1955.                 if (*busy == NULL) {
  1956.                     b->pos = b->start;
  1957.                     b->last = b->start;
  1958.                 }
  1959.             }
  1960.         }

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

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

  1966.             if (limit_rate) {
  1967.                 limit = (off_t) limit_rate * (ngx_time() - u->start_sec + 1)
  1968.                         - *received;

  1970.                 if (limit <= 0) {
  1971.                     src->read->delayed = 1;
  1972.                     delay = (ngx_msec_t) (- limit * 1000 / limit_rate + 1);
  1973.                     ngx_add_timer(src->read, delay);
  1974.                     break;
  1975.                 }

  1977.                 if (c->type == SOCK_STREAM && (off_t) size > limit) {
  1978.                     size = (size_t) limit;
  1979.                 }
  1980.             }

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

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

  1986.             if (n == NGX_AGAIN) {
  1987.                 break;
  1988.             }

  1990.             if (n == NGX_ERROR) {
  1991.                 src->read->eof = 1;
  1992.                 n = 0;
  1993.             }

  1995.             if (n >= 0) {
  1996.                 if (limit_rate) {
  1997.                     delay = (ngx_msec_t) (n * 1000 / limit_rate);

  1999.                     if (delay > 0) {
  2000.                         src->read->delayed = 1;
  2001.                         ngx_add_timer(src->read, delay);
  2002.                     }
  2003.                 }

  2005.                 if (from_upstream) {
  2006.                     if (u->state->first_byte_time == (ngx_msec_t) -1) {
  2007.                         u->state->first_byte_time = ngx_current_msec
  2008.                                                     - u->start_time;

  2010.                         if (u->peer.notify) {
  2011.                             u->peer.notify(&u->peer, u->peer.data,
  2012.                                        NGX_STREAM_UPSTREAM_NOTIFY_FIRST_BYTE);
  2013.                         }
  2014.                     }
  2015.                 }

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

  2019.                 cl = ngx_chain_get_free_buf(c->pool, &u->free);
  2020.                 if (cl == NULL) {
  2021.                     ngx_stream_proxy_finalize(s,
  2022.                                               NGX_STREAM_INTERNAL_SERVER_ERROR);
  2023.                     return;
  2024.                 }

  2026.                 *ll = cl;

  2028.                 cl->buf->pos = b->last;
  2029.                 cl->buf->last = b->last + n;
  2030.                 cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;

  2032.                 cl->buf->temporary = (n ? 1 : 0);
  2033.                 cl->buf->last_buf = src->read->eof;
  2034.                 cl->buf->flush = !src->read->eof;

  2036.                 (*packets)++;
  2037.                 *received += n;
  2038.                 b->last += n;
  2039.                 do_write = 1;

  2041.                 continue;
  2042.             }
  2043.         }

  2045.         break;
  2046.     }

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

  2050.     if (ngx_stream_proxy_test_finalize(s, from_upstream) == NGX_OK) {
  2051.         return;
  2052.     }

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

  2056.     if (ngx_handle_read_event(src->read, flags) != NGX_OK) {
  2057.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  2058.         return;
  2059.     }

  2061.     if (dst) {

  2063.         if (dst->type == SOCK_STREAM && pscf->half_close
  2064.             && src->read->eof && !u->half_closed && !dst->buffered)
  2065.         {
  2066.             if (ngx_shutdown_socket(dst->fd, NGX_WRITE_SHUTDOWN) == -1) {
  2067.                 ngx_connection_error(c, ngx_socket_errno,
  2068.                                      ngx_shutdown_socket_n " failed");

  2070.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  2071.                 return;
  2072.             }

  2074.             u->half_closed = 1;
  2075.             ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  2076.                            "stream proxy %s socket shutdown",
  2077.                            from_upstream ? "client" : "upstream");
  2078.         }

  2080.         if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
  2081.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  2082.             return;
  2083.         }

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

  2088.         } else if (c->write->timer_set) {
  2089.             ngx_del_timer(c->write);
  2090.         }
  2091.     }
  2092. }


  2095. static ngx_int_t
  2096. ‌ngx_stream_proxy_test_finalize(ngx_stream_session_t *s,
  2097.     ngx_uint_t from_upstream)
  2098. {
  2099.     ngx_connection_t             *c, *pc;
  2100.     ngx_log_handler_pt            handler;
  2101.     ngx_stream_upstream_t        *u;
  2102.     ngx_stream_proxy_srv_conf_t  *pscf;

  2104.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  2106.     c = s->connection;
  2107.     u = s->upstream;
  2108.     pc = u->connected ? u->peer.connection : NULL;

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

  2112.         if (pscf->requests && u->requests < pscf->requests) {
  2113.             return NGX_DECLINED;
  2114.         }

  2116.         if (pscf->requests) {
  2117.             ngx_delete_udp_connection(c);
  2118.         }

  2120.         if (pscf->responses == NGX_MAX_INT32_VALUE
  2121.             || u->responses < pscf->responses * u->requests)
  2122.         {
  2123.             return NGX_DECLINED;
  2124.         }

  2126.         if (pc == NULL || c->buffered || pc->buffered) {
  2127.             return NGX_DECLINED;
  2128.         }

  2130.         handler = c->log->handler;
  2131.         c->log->handler = NULL;

  2133.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2134.                       "udp done"
  2135.                       ", packets from/to client:%ui/%ui"
  2136.                       ", bytes from/to client:%O/%O"
  2137.                       ", bytes from/to upstream:%O/%O",
  2138.                       u->requests, u->responses,
  2139.                       s->received, c->sent, u->received, pc ? pc->sent : 0);

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

  2143.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  2145.         return NGX_OK;
  2146.     }

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

  2150.     if (pc == NULL
  2151.         || (!c->read->eof && !pc->read->eof)
  2152.         || (!c->read->eof && c->buffered)
  2153.         || (!pc->read->eof && pc->buffered))
  2154.     {
  2155.         return NGX_DECLINED;
  2156.     }

  2158.     if (pscf->half_close) {
  2159.         /* avoid closing live connections until both read ends get EOF */
  2160.         if (!(c->read->eof && pc->read->eof && !c->buffered && !pc->buffered)) {
  2161.              return NGX_DECLINED;
  2162.         }
  2163.     }

  2165.     handler = c->log->handler;
  2166.     c->log->handler = NULL;

  2168.     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2169.                   "%s disconnected"
  2170.                   ", bytes from/to client:%O/%O"
  2171.                   ", bytes from/to upstream:%O/%O",
  2172.                   from_upstream ? "upstream" : "client",
  2173.                   s->received, c->sent, u->received, pc ? pc->sent : 0);

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

  2177.     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  2179.     return NGX_OK;
  2180. }


  2183. static void
  2184. ‌ngx_stream_proxy_next_upstream(ngx_stream_session_t *s)
  2185. {
  2186.     ngx_msec_t                    timeout;
  2187.     ngx_connection_t             *pc;
  2188.     ngx_stream_upstream_t        *u;
  2189.     ngx_stream_proxy_srv_conf_t  *pscf;

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

  2194.     u = s->upstream;
  2195.     pc = u->peer.connection;

  2197.     if (pc && pc->buffered) {
  2198.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  2199.                       "buffered data on next upstream");
  2200.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  2201.         return;
  2202.     }

  2204.     if (s->connection->type == SOCK_DGRAM) {
  2205.         u->upstream_out = NULL;
  2206.     }

  2208.     if (u->peer.sockaddr) {
  2209.         u->peer.free(&u->peer, u->peer.data, NGX_PEER_FAILED);
  2210.         u->peer.sockaddr = NULL;
  2211.     }

  2213.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  2215.     timeout = pscf->next_upstream_timeout;

  2217.     if (u->peer.tries == 0
  2218.         || !pscf->next_upstream
  2219.         || (timeout && ngx_current_msec - u->peer.start_time >= timeout))
  2220.     {
  2221.         ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);
  2222.         return;
  2223.     }

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

  2229. #if (NGX_STREAM_SSL)
  2230.         if (pc->ssl) {
  2231.             pc->ssl->no_wait_shutdown = 1;
  2232.             pc->ssl->no_send_shutdown = 1;

  2234.             (void) ngx_ssl_shutdown(pc);
  2235.         }
  2236. #endif

  2238.         u->state->bytes_received = u->received;
  2239.         u->state->bytes_sent = pc->sent;

  2241.         ngx_close_connection(pc);
  2242.         u->peer.connection = NULL;
  2243.     }

  2245.     ngx_stream_proxy_connect(s);
  2246. }


  2249. static void
  2250. ‌ngx_stream_proxy_finalize(ngx_stream_session_t *s, ngx_uint_t rc)
  2251. {
  2252.     ngx_uint_t              state;
  2253.     ngx_connection_t       *pc;
  2254.     ngx_stream_upstream_t  *u;

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

  2259.     u = s->upstream;

  2261.     if (u == NULL) {
  2262.         goto noupstream;
  2263.     }

  2265.     if (u->resolved && u->resolved->ctx) {
  2266.         ngx_resolve_name_done(u->resolved->ctx);
  2267.         u->resolved->ctx = NULL;
  2268.     }

  2270.     pc = u->peer.connection;

  2272.     if (u->state) {
  2273.         if (u->state->response_time == (ngx_msec_t) -1) {
  2274.             u->state->response_time = ngx_current_msec - u->start_time;
  2275.         }

  2277.         if (pc) {
  2278.             u->state->bytes_received = u->received;
  2279.             u->state->bytes_sent = pc->sent;
  2280.         }
  2281.     }

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

  2286.         if (pc && pc->type == SOCK_DGRAM
  2287.             && (pc->read->error || pc->write->error))
  2288.         {
  2289.             state = NGX_PEER_FAILED;
  2290.         }

  2292.         u->peer.free(&u->peer, u->peer.data, state);
  2293.         u->peer.sockaddr = NULL;
  2294.     }

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

  2300. #if (NGX_STREAM_SSL)
  2301.         if (pc->ssl) {
  2302.             pc->ssl->no_wait_shutdown = 1;
  2303.             (void) ngx_ssl_shutdown(pc);
  2304.         }
  2305. #endif

  2307.         ngx_close_connection(pc);
  2308.         u->peer.connection = NULL;
  2309.     }

  2311. noupstream:

  2313.     ngx_stream_finalize_session(s, rc);
  2314. }


  2317. static u_char *
  2318. ‌ngx_stream_proxy_log_error(ngx_log_t *log, u_char *buf, size_t len)
  2319. {
  2320.     u_char                 *p;
  2321.     ngx_connection_t       *pc;
  2322.     ngx_stream_session_t   *s;
  2323.     ngx_stream_upstream_t  *u;

  2325.     s = log->data;

  2327.     u = s->upstream;

  2329.     p = buf;

  2331.     if (u->peer.name) {
  2332.         p = ngx_snprintf(p, len, ", upstream: \"%V\"", u->peer.name);
  2333.         len -= p - buf;
  2334.     }

  2336.     pc = u->peer.connection;

  2338.     p = ngx_snprintf(p, len,
  2339.                      ", bytes from/to client:%O/%O"
  2340.                      ", bytes from/to upstream:%O/%O",
  2341.                      s->received, s->connection->sent,
  2342.                      u->received, pc ? pc->sent : 0);

  2344.     return p;
  2345. }


  2348. static void *
  2349. ‌ngx_stream_proxy_create_srv_conf(ngx_conf_t *cf)
  2350. {
  2351.     ngx_stream_proxy_srv_conf_t  *conf;

  2353.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_proxy_srv_conf_t));
  2354.     if (conf == NULL) {
  2355.         return NULL;
  2356.     }

  2358.     /*
  2359.      * set by ngx_pcalloc():
  2360.      *
  2361.      *     conf->ssl_protocols = 0;
  2362.      *     conf->ssl_ciphers = { 0, NULL };
  2363.      *     conf->ssl_trusted_certificate = { 0, NULL };
  2364.      *     conf->ssl_crl = { 0, NULL };
  2365.      *
  2366.      *     conf->ssl = NULL;
  2367.      *     conf->upstream = NULL;
  2368.      *     conf->upstream_value = NULL;
  2369.      */

  2371.     conf->connect_timeout = NGX_CONF_UNSET_MSEC;
  2372.     conf->timeout = NGX_CONF_UNSET_MSEC;
  2373.     conf->next_upstream_timeout = NGX_CONF_UNSET_MSEC;
  2374.     conf->buffer_size = NGX_CONF_UNSET_SIZE;
  2375.     conf->upload_rate = NGX_CONF_UNSET_PTR;
  2376.     conf->download_rate = NGX_CONF_UNSET_PTR;
  2377.     conf->requests = NGX_CONF_UNSET_UINT;
  2378.     conf->responses = NGX_CONF_UNSET_UINT;
  2379.     conf->next_upstream_tries = NGX_CONF_UNSET_UINT;
  2380.     conf->next_upstream = NGX_CONF_UNSET;
  2381.     conf->proxy_protocol = NGX_CONF_UNSET;
  2382.     conf->local = NGX_CONF_UNSET_PTR;
  2383.     conf->socket_keepalive = NGX_CONF_UNSET;
  2384.     conf->half_close = NGX_CONF_UNSET;

  2386. #if (NGX_STREAM_SSL)
  2387.     conf->ssl_enable = NGX_CONF_UNSET;
  2388.     conf->ssl_session_reuse = NGX_CONF_UNSET;
  2389.     conf->ssl_name = NGX_CONF_UNSET_PTR;
  2390.     conf->ssl_server_name = NGX_CONF_UNSET;
  2391.     conf->ssl_alpn = NGX_CONF_UNSET_PTR;
  2392.     conf->ssl_verify = NGX_CONF_UNSET;
  2393.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  2394.     conf->ssl_certificate = NGX_CONF_UNSET_PTR;
  2395.     conf->ssl_certificate_key = NGX_CONF_UNSET_PTR;
  2396.     conf->ssl_certificate_cache = NGX_CONF_UNSET_PTR;
  2397.     conf->ssl_passwords = NGX_CONF_UNSET_PTR;
  2398.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  2399. #endif

  2401.     return conf;
  2402. }


  2405. static char *
  2406. ‌ngx_stream_proxy_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  2407. {
  2408.     ngx_stream_proxy_srv_conf_t *prev = parent;
  2409.     ngx_stream_proxy_srv_conf_t *conf = child;

  2411.     ngx_conf_merge_msec_value(conf->connect_timeout,
  2412.                               prev->connect_timeout, 60000);

  2414.     ngx_conf_merge_msec_value(conf->timeout,
  2415.                               prev->timeout, 10 * 60000);

  2417.     ngx_conf_merge_msec_value(conf->next_upstream_timeout,
  2418.                               prev->next_upstream_timeout, 0);

  2420.     ngx_conf_merge_size_value(conf->buffer_size,
  2421.                               prev->buffer_size, 16384);

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

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

  2427.     ngx_conf_merge_uint_value(conf->requests,
  2428.                               prev->requests, 0);

  2430.     ngx_conf_merge_uint_value(conf->responses,
  2431.                               prev->responses, NGX_MAX_INT32_VALUE);

  2433.     ngx_conf_merge_uint_value(conf->next_upstream_tries,
  2434.                               prev->next_upstream_tries, 0);

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

  2438.     ngx_conf_merge_value(conf->proxy_protocol, prev->proxy_protocol, 0);

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

  2442.     ngx_conf_merge_value(conf->socket_keepalive,
  2443.                               prev->socket_keepalive, 0);

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

  2447. #if (NGX_STREAM_SSL)

  2449.     if (ngx_stream_proxy_merge_ssl(cf, conf, prev) != NGX_OK) {
  2450.         return NGX_CONF_ERROR;
  2451.     }

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

  2455.     ngx_conf_merge_value(conf->ssl_session_reuse,
  2456.                               prev->ssl_session_reuse, 1);

  2458.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  2459.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

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

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

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

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

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

  2471.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  2472.                               prev->ssl_verify_depth, 1);

  2474.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  2475.                               prev->ssl_trusted_certificate, "");

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

  2479.     ngx_conf_merge_ptr_value(conf->ssl_certificate,
  2480.                               prev->ssl_certificate, NULL);

  2482.     ngx_conf_merge_ptr_value(conf->ssl_certificate_key,
  2483.                               prev->ssl_certificate_key, NULL);

  2485.     ngx_conf_merge_ptr_value(conf->ssl_certificate_cache,
  2486.                               prev->ssl_certificate_cache, NULL);

  2488.     if (ngx_stream_proxy_merge_ssl_passwords(cf, conf, prev) != NGX_OK) {
  2489.         return NGX_CONF_ERROR;
  2490.     }

  2492.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  2493.                               prev->ssl_conf_commands, NULL);

  2495.     if (conf->ssl_enable && ngx_stream_proxy_set_ssl(cf, conf) != NGX_OK) {
  2496.         return NGX_CONF_ERROR;
  2497.     }

  2499. #endif

  2501.     return NGX_CONF_OK;
  2502. }


  2505. #if (NGX_STREAM_SSL)

  2507. static ngx_int_t
  2508. ‌ngx_stream_proxy_merge_ssl(ngx_conf_t *cf, ngx_stream_proxy_srv_conf_t *conf,
  2509.     ngx_stream_proxy_srv_conf_t *prev)
  2510. {
  2511.     ngx_uint_t  preserve;

  2513.     if (conf->ssl_protocols == 0
  2514.         && conf->ssl_ciphers.data == NULL
  2515.         && conf->ssl_certificate == NGX_CONF_UNSET_PTR
  2516.         && conf->ssl_certificate_key == NGX_CONF_UNSET_PTR
  2517.         && conf->ssl_passwords == NGX_CONF_UNSET_PTR
  2518.         && conf->ssl_verify == NGX_CONF_UNSET
  2519.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  2520.         && conf->ssl_trusted_certificate.data == NULL
  2521.         && conf->ssl_crl.data == NULL
  2522.         && conf->ssl_session_reuse == NGX_CONF_UNSET
  2523.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  2524.     {
  2525.         if (prev->ssl) {
  2526.             conf->ssl = prev->ssl;
  2527.             return NGX_OK;
  2528.         }

  2530.         preserve = 1;

  2532.     } else {
  2533.         preserve = 0;
  2534.     }

  2536.     conf->ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  2537.     if (conf->ssl == NULL) {
  2538.         return NGX_ERROR;
  2539.     }

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

  2543.     /*
  2544.      * special handling to preserve conf->ssl
  2545.      * in the "stream" section to inherit it to all servers
  2546.      */

  2548.     if (preserve) {
  2549.         prev->ssl = conf->ssl;
  2550.     }

  2552.     return NGX_OK;
  2553. }


  2556. static ngx_int_t
  2557. ‌ngx_stream_proxy_merge_ssl_passwords(ngx_conf_t *cf,
  2558.     ngx_stream_proxy_srv_conf_t *conf, ngx_stream_proxy_srv_conf_t *prev)
  2559. {
  2560.     ngx_uint_t  preserve;

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

  2564.     if (conf->ssl_certificate == NULL
  2565.         || conf->ssl_certificate->value.len == 0
  2566.         || conf->ssl_certificate_key == NULL)
  2567.     {
  2568.         return NGX_OK;
  2569.     }

  2571.     if (conf->ssl_certificate->lengths == NULL
  2572.         && conf->ssl_certificate_key->lengths == NULL)
  2573.     {
  2574.         if (conf->ssl_passwords && conf->ssl_passwords->pool == NULL) {
  2575.             /* un-preserve empty password list */
  2576.             conf->ssl_passwords = NULL;
  2577.         }

  2579.         return NGX_OK;
  2580.     }

  2582.     if (conf->ssl_passwords && conf->ssl_passwords->pool != cf->temp_pool) {
  2583.         /* already preserved */
  2584.         return NGX_OK;
  2585.     }

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

  2589.     conf->ssl_passwords = ngx_ssl_preserve_passwords(cf, conf->ssl_passwords);
  2590.     if (conf->ssl_passwords == NULL) {
  2591.         return NGX_ERROR;
  2592.     }

  2594.     /*
  2595.      * special handling to keep a preserved ssl_passwords copy
  2596.      * in the previous configuration to inherit it to all children
  2597.      */

  2599.     if (preserve) {
  2600.         prev->ssl_passwords = conf->ssl_passwords;
  2601.     }

  2603.     return NGX_OK;
  2604. }


  2607. static ngx_int_t
  2608. ‌ngx_stream_proxy_set_ssl(ngx_conf_t *cf, ngx_stream_proxy_srv_conf_t *pscf)
  2609. {
  2610.     ngx_pool_cleanup_t  *cln;

  2612.     if (pscf->ssl->ctx) {
  2613.         return NGX_OK;
  2614.     }

  2616.     if (ngx_ssl_create(pscf->ssl, pscf->ssl_protocols, NULL) != NGX_OK) {
  2617.         return NGX_ERROR;
  2618.     }

  2620.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  2621.     if (cln == NULL) {
  2622.         ngx_ssl_cleanup_ctx(pscf->ssl);
  2623.         return NGX_ERROR;
  2624.     }

  2626.     cln->handler = ngx_ssl_cleanup_ctx;
  2627.     cln->data = pscf->ssl;

  2629.     if (ngx_ssl_ciphers(cf, pscf->ssl, &pscf->ssl_ciphers, 0) != NGX_OK) {
  2630.         return NGX_ERROR;
  2631.     }

  2633.     if (pscf->ssl_certificate
  2634.         && pscf->ssl_certificate->value.len)
  2635.     {
  2636.         if (pscf->ssl_certificate_key == NULL) {
  2637.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2638.                           "no \"proxy_ssl_certificate_key\" is defined "
  2639.                           "for certificate \"%V\"",
  2640.                           &pscf->ssl_certificate->value);
  2641.             return NGX_ERROR;
  2642.         }

  2644.         if (pscf->ssl_certificate->lengths == NULL
  2645.             && pscf->ssl_certificate_key->lengths == NULL)
  2646.         {
  2647.             if (ngx_ssl_certificate(cf, pscf->ssl,
  2648.                                     &pscf->ssl_certificate->value,
  2649.                                     &pscf->ssl_certificate_key->value,
  2650.                                     pscf->ssl_passwords)
  2651.                 != NGX_OK)
  2652.             {
  2653.                 return NGX_ERROR;
  2654.             }
  2655.         }
  2656.     }

  2658.     if (pscf->ssl_verify) {
  2659.         if (pscf->ssl_trusted_certificate.len == 0) {
  2660.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2661.                       "no proxy_ssl_trusted_certificate for proxy_ssl_verify");
  2662.             return NGX_ERROR;
  2663.         }

  2665.         if (ngx_ssl_trusted_certificate(cf, pscf->ssl,
  2666.                                         &pscf->ssl_trusted_certificate,
  2667.                                         pscf->ssl_verify_depth)
  2668.             != NGX_OK)
  2669.         {
  2670.             return NGX_ERROR;
  2671.         }

  2673.         if (ngx_ssl_crl(cf, pscf->ssl, &pscf->ssl_crl) != NGX_OK) {
  2674.             return NGX_ERROR;
  2675.         }
  2676.     }

  2678.     if (ngx_ssl_client_session_cache(cf, pscf->ssl, pscf->ssl_session_reuse)
  2679.         != NGX_OK)
  2680.     {
  2681.         return NGX_ERROR;
  2682.     }

  2684.     if (ngx_ssl_conf_commands(cf, pscf->ssl, pscf->ssl_conf_commands)
  2685.         != NGX_OK)
  2686.     {
  2687.         return NGX_ERROR;
  2688.     }

  2690.     return NGX_OK;
  2691. }

  2693. #endif


  2696. static char *
  2697. ‌ngx_stream_proxy_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2698. {
  2699.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  2701.     ngx_url_t                            u;
  2702.     ngx_str_t                           *value, *url;
  2703.     ngx_stream_complex_value_t           cv;
  2704.     ngx_stream_core_srv_conf_t          *cscf;
  2705.     ngx_stream_compile_complex_value_t   ccv;

  2707.     if (pscf->upstream || pscf->upstream_value) {
  2708.         return "is duplicate";
  2709.     }

  2711.     cscf = ngx_stream_conf_get_module_srv_conf(cf, ngx_stream_core_module);

  2713.     cscf->handler = ngx_stream_proxy_handler;

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

  2717.     url = &value[1];

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

  2721.     ccv.cf = cf;
  2722.     ccv.value = url;
  2723.     ccv.complex_value = &cv;

  2725.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  2726.         return NGX_CONF_ERROR;
  2727.     }

  2729.     if (cv.lengths) {
  2730.         pscf->upstream_value = ngx_palloc(cf->pool,
  2731.                                           sizeof(ngx_stream_complex_value_t));
  2732.         if (pscf->upstream_value == NULL) {
  2733.             return NGX_CONF_ERROR;
  2734.         }

  2736.         *pscf->upstream_value = cv;

  2738.         return NGX_CONF_OK;
  2739.     }

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

  2743.     u.url = *url;
  2744.     u.no_resolve = 1;

  2746.     pscf->upstream = ngx_stream_upstream_add(cf, &u, 0);
  2747.     if (pscf->upstream == NULL) {
  2748.         return NGX_CONF_ERROR;
  2749.     }

  2751.     return NGX_CONF_OK;
  2752. }


  2755. static char *
  2756. ‌ngx_stream_proxy_bind(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2757. {
  2758.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  2760.     ngx_int_t                            rc;
  2761.     ngx_str_t                           *value;
  2762.     ngx_stream_complex_value_t           cv;
  2763.     ngx_stream_upstream_local_t         *local;
  2764.     ngx_stream_compile_complex_value_t   ccv;

  2766.     if (pscf->local != NGX_CONF_UNSET_PTR) {
  2767.         return "is duplicate";
  2768.     }

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

  2772.     if (cf->args->nelts == 2 && ngx_strcmp(value[1].data, "off") == 0) {
  2773.         pscf->local = NULL;
  2774.         return NGX_CONF_OK;
  2775.     }

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

  2779.     ccv.cf = cf;
  2780.     ccv.value = &value[1];
  2781.     ccv.complex_value = &cv;

  2783.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  2784.         return NGX_CONF_ERROR;
  2785.     }

  2787.     local = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_local_t));
  2788.     if (local == NULL) {
  2789.         return NGX_CONF_ERROR;
  2790.     }

  2792.     pscf->local = local;

  2794.     if (cv.lengths) {
  2795.         local->value = ngx_palloc(cf->pool, sizeof(ngx_stream_complex_value_t));
  2796.         if (local->value == NULL) {
  2797.             return NGX_CONF_ERROR;
  2798.         }

  2800.         *local->value = cv;

  2802.     } else {
  2803.         local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
  2804.         if (local->addr == NULL) {
  2805.             return NGX_CONF_ERROR;
  2806.         }

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

  2811.         switch (rc) {
  2812.         case NGX_OK:
  2813.             local->addr->name = value[1];
  2814.             break;

  2816.         case NGX_DECLINED:
  2817.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2818.                                "invalid address \"%V\"", &value[1]);
  2819.             /* fall through */

  2821.         default:
  2822.             return NGX_CONF_ERROR;
  2823.         }
  2824.     }

  2826.     if (cf->args->nelts > 2) {
  2827.         if (ngx_strcmp(value[2].data, "transparent") == 0) {
  2828. #if (NGX_HAVE_TRANSPARENT_PROXY)
  2829.             ngx_core_conf_t  *ccf;

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

  2834.             ccf->transparent = 1;
  2835.             local->transparent = 1;
  2836. #else
  2837.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2838.                                "transparent proxying is not supported "
  2839.                                "on this platform, ignored");
  2840. #endif
  2841.         } else {
  2842.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2843.                                "invalid parameter \"%V\"", &value[2]);
  2844.             return NGX_CONF_ERROR;
  2845.         }
  2846.     }

  2848.     return NGX_CONF_OK;
  2849. }

One Level Up Top Level