One Level Up Top Level

src/stream/ngx_stream_proxy_module.c - nginx source code

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;

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

  55.     ngx_ssl_t                       *ssl;
  56. #endif

  58.     ngx_stream_upstream_srv_conf_t  *upstream;
  59.     ngx_stream_complex_value_t      *upstream_value;
  60. ‌} ngx_stream_proxy_srv_conf_t;


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

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

  94. #if (NGX_STREAM_SSL)

  96. static ngx_int_t ngx_stream_proxy_send_proxy_protocol(ngx_stream_session_t *s);
  97. static char *ngx_stream_proxy_ssl_password_file(ngx_conf_t *cf,
  98.     ngx_command_t *cmd, void *conf);
  99. static char *ngx_stream_proxy_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  100.     void *data);
  101. static void ngx_stream_proxy_ssl_init_connection(ngx_stream_session_t *s);
  102. static void ngx_stream_proxy_ssl_handshake(ngx_connection_t *pc);
  103. static void ngx_stream_proxy_ssl_save_session(ngx_connection_t *c);
  104. static ngx_int_t ngx_stream_proxy_ssl_name(ngx_stream_session_t *s);
  105. static ngx_int_t ngx_stream_proxy_ssl_certificate(ngx_stream_session_t *s);
  106. static ngx_int_t ngx_stream_proxy_merge_ssl(ngx_conf_t *cf,
  107.     ngx_stream_proxy_srv_conf_t *conf, ngx_stream_proxy_srv_conf_t *prev);
  108. static ngx_int_t ngx_stream_proxy_set_ssl(ngx_conf_t *cf,
  109.     ngx_stream_proxy_srv_conf_t *pscf);


  112. ‌static ngx_conf_bitmask_t  ngx_stream_proxy_ssl_protocols[] = {
  113.     { ngx_string("SSLv2"), NGX_SSL_SSLv2 },
  114.     { ngx_string("SSLv3"), NGX_SSL_SSLv3 },
  115.     { ngx_string("TLSv1"), NGX_SSL_TLSv1 },
  116.     { ngx_string("TLSv1.1"), NGX_SSL_TLSv1_1 },
  117.     { ngx_string("TLSv1.2"), NGX_SSL_TLSv1_2 },
  118.     { ngx_string("TLSv1.3"), NGX_SSL_TLSv1_3 },
  119.     { ngx_null_string, 0 }
  120. };

  122. ‌static ngx_conf_post_t  ngx_stream_proxy_ssl_conf_command_post =
  123.     { ngx_stream_proxy_ssl_conf_command_check };

  125. #endif


  128. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_proxy_downstream_buffer = {
  129.     ngx_conf_deprecated, "proxy_downstream_buffer", "proxy_buffer_size"
  130. };

  132. ‌static ngx_conf_deprecated_t  ngx_conf_deprecated_proxy_upstream_buffer = {
  133.     ngx_conf_deprecated, "proxy_upstream_buffer", "proxy_buffer_size"
  134. };


  137. ‌static ngx_command_t  ngx_stream_proxy_commands[] = {

  139.     { ngx_string("proxy_pass"),
  140.       NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  141.       ngx_stream_proxy_pass,
  142.       NGX_STREAM_SRV_CONF_OFFSET,
  143.       0,
  144.       NULL },

  146.     { ngx_string("proxy_bind"),
  147.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE12,
  148.       ngx_stream_proxy_bind,
  149.       NGX_STREAM_SRV_CONF_OFFSET,
  150.       0,
  151.       NULL },

  153.     { ngx_string("proxy_socket_keepalive"),
  154.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  155.       ngx_conf_set_flag_slot,
  156.       NGX_STREAM_SRV_CONF_OFFSET,
  157.       offsetof(ngx_stream_proxy_srv_conf_t, socket_keepalive),
  158.       NULL },

  160.     { ngx_string("proxy_connect_timeout"),
  161.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  162.       ngx_conf_set_msec_slot,
  163.       NGX_STREAM_SRV_CONF_OFFSET,
  164.       offsetof(ngx_stream_proxy_srv_conf_t, connect_timeout),
  165.       NULL },

  167.     { ngx_string("proxy_timeout"),
  168.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  169.       ngx_conf_set_msec_slot,
  170.       NGX_STREAM_SRV_CONF_OFFSET,
  171.       offsetof(ngx_stream_proxy_srv_conf_t, timeout),
  172.       NULL },

  174.     { ngx_string("proxy_buffer_size"),
  175.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  176.       ngx_conf_set_size_slot,
  177.       NGX_STREAM_SRV_CONF_OFFSET,
  178.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  179.       NULL },

  181.     { ngx_string("proxy_downstream_buffer"),
  182.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  183.       ngx_conf_set_size_slot,
  184.       NGX_STREAM_SRV_CONF_OFFSET,
  185.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  186.       &ngx_conf_deprecated_proxy_downstream_buffer },

  188.     { ngx_string("proxy_upstream_buffer"),
  189.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  190.       ngx_conf_set_size_slot,
  191.       NGX_STREAM_SRV_CONF_OFFSET,
  192.       offsetof(ngx_stream_proxy_srv_conf_t, buffer_size),
  193.       &ngx_conf_deprecated_proxy_upstream_buffer },

  195.     { ngx_string("proxy_upload_rate"),
  196.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  197.       ngx_stream_set_complex_value_size_slot,
  198.       NGX_STREAM_SRV_CONF_OFFSET,
  199.       offsetof(ngx_stream_proxy_srv_conf_t, upload_rate),
  200.       NULL },

  202.     { ngx_string("proxy_download_rate"),
  203.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  204.       ngx_stream_set_complex_value_size_slot,
  205.       NGX_STREAM_SRV_CONF_OFFSET,
  206.       offsetof(ngx_stream_proxy_srv_conf_t, download_rate),
  207.       NULL },

  209.     { ngx_string("proxy_requests"),
  210.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  211.       ngx_conf_set_num_slot,
  212.       NGX_STREAM_SRV_CONF_OFFSET,
  213.       offsetof(ngx_stream_proxy_srv_conf_t, requests),
  214.       NULL },

  216.     { ngx_string("proxy_responses"),
  217.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  218.       ngx_conf_set_num_slot,
  219.       NGX_STREAM_SRV_CONF_OFFSET,
  220.       offsetof(ngx_stream_proxy_srv_conf_t, responses),
  221.       NULL },

  223.     { ngx_string("proxy_next_upstream"),
  224.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  225.       ngx_conf_set_flag_slot,
  226.       NGX_STREAM_SRV_CONF_OFFSET,
  227.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream),
  228.       NULL },

  230.     { ngx_string("proxy_next_upstream_tries"),
  231.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  232.       ngx_conf_set_num_slot,
  233.       NGX_STREAM_SRV_CONF_OFFSET,
  234.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream_tries),
  235.       NULL },

  237.     { ngx_string("proxy_next_upstream_timeout"),
  238.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  239.       ngx_conf_set_msec_slot,
  240.       NGX_STREAM_SRV_CONF_OFFSET,
  241.       offsetof(ngx_stream_proxy_srv_conf_t, next_upstream_timeout),
  242.       NULL },

  244.     { ngx_string("proxy_protocol"),
  245.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  246.       ngx_conf_set_flag_slot,
  247.       NGX_STREAM_SRV_CONF_OFFSET,
  248.       offsetof(ngx_stream_proxy_srv_conf_t, proxy_protocol),
  249.       NULL },

  251.     { ngx_string("proxy_half_close"),
  252.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  253.       ngx_conf_set_flag_slot,
  254.       NGX_STREAM_SRV_CONF_OFFSET,
  255.       offsetof(ngx_stream_proxy_srv_conf_t, half_close),
  256.       NULL },

  258. #if (NGX_STREAM_SSL)

  260.     { ngx_string("proxy_ssl"),
  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, ssl_enable),
  265.       NULL },

  267.     { ngx_string("proxy_ssl_session_reuse"),
  268.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  269.       ngx_conf_set_flag_slot,
  270.       NGX_STREAM_SRV_CONF_OFFSET,
  271.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_session_reuse),
  272.       NULL },

  274.     { ngx_string("proxy_ssl_protocols"),
  275.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  276.       ngx_conf_set_bitmask_slot,
  277.       NGX_STREAM_SRV_CONF_OFFSET,
  278.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_protocols),
  279.       &ngx_stream_proxy_ssl_protocols },

  281.     { ngx_string("proxy_ssl_ciphers"),
  282.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  283.       ngx_conf_set_str_slot,
  284.       NGX_STREAM_SRV_CONF_OFFSET,
  285.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_ciphers),
  286.       NULL },

  288.     { ngx_string("proxy_ssl_name"),
  289.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  290.       ngx_stream_set_complex_value_slot,
  291.       NGX_STREAM_SRV_CONF_OFFSET,
  292.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_name),
  293.       NULL },

  295.     { ngx_string("proxy_ssl_server_name"),
  296.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  297.       ngx_conf_set_flag_slot,
  298.       NGX_STREAM_SRV_CONF_OFFSET,
  299.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_server_name),
  300.       NULL },

  302.     { ngx_string("proxy_ssl_verify"),
  303.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  304.       ngx_conf_set_flag_slot,
  305.       NGX_STREAM_SRV_CONF_OFFSET,
  306.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_verify),
  307.       NULL },

  309.     { ngx_string("proxy_ssl_verify_depth"),
  310.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  311.       ngx_conf_set_num_slot,
  312.       NGX_STREAM_SRV_CONF_OFFSET,
  313.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_verify_depth),
  314.       NULL },

  316.     { ngx_string("proxy_ssl_trusted_certificate"),
  317.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  318.       ngx_conf_set_str_slot,
  319.       NGX_STREAM_SRV_CONF_OFFSET,
  320.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_trusted_certificate),
  321.       NULL },

  323.     { ngx_string("proxy_ssl_crl"),
  324.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  325.       ngx_conf_set_str_slot,
  326.       NGX_STREAM_SRV_CONF_OFFSET,
  327.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_crl),
  328.       NULL },

  330.     { ngx_string("proxy_ssl_certificate"),
  331.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  332.       ngx_stream_set_complex_value_zero_slot,
  333.       NGX_STREAM_SRV_CONF_OFFSET,
  334.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_certificate),
  335.       NULL },

  337.     { ngx_string("proxy_ssl_certificate_key"),
  338.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  339.       ngx_stream_set_complex_value_zero_slot,
  340.       NGX_STREAM_SRV_CONF_OFFSET,
  341.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_certificate_key),
  342.       NULL },

  344.     { ngx_string("proxy_ssl_password_file"),
  345.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  346.       ngx_stream_proxy_ssl_password_file,
  347.       NGX_STREAM_SRV_CONF_OFFSET,
  348.       0,
  349.       NULL },

  351.     { ngx_string("proxy_ssl_conf_command"),
  352.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE2,
  353.       ngx_conf_set_keyval_slot,
  354.       NGX_STREAM_SRV_CONF_OFFSET,
  355.       offsetof(ngx_stream_proxy_srv_conf_t, ssl_conf_commands),
  356.       &ngx_stream_proxy_ssl_conf_command_post },

  358. #endif

  360.       ngx_null_command
  361. };


  364. ‌static ngx_stream_module_t  ngx_stream_proxy_module_ctx = {
  365.     NULL,                                  /* preconfiguration */
  366.     NULL,                                  /* postconfiguration */

  368.     NULL,                                  /* create main configuration */
  369.     NULL,                                  /* init main configuration */

  371.     ngx_stream_proxy_create_srv_conf,      /* create server configuration */
  372.     ngx_stream_proxy_merge_srv_conf        /* merge server configuration */
  373. };


  376. ‌ngx_module_t  ngx_stream_proxy_module = {
  377.     NGX_MODULE_V1,
  378.     &ngx_stream_proxy_module_ctx,          /* module context */
  379.     ngx_stream_proxy_commands,             /* module directives */
  380.     NGX_STREAM_MODULE,                     /* module type */
  381.     NULL,                                  /* init master */
  382.     NULL,                                  /* init module */
  383.     NULL,                                  /* init process */
  384.     NULL,                                  /* init thread */
  385.     NULL,                                  /* exit thread */
  386.     NULL,                                  /* exit process */
  387.     NULL,                                  /* exit master */
  388.     NGX_MODULE_V1_PADDING
  389. };


  392. static void
  393. ‌ngx_stream_proxy_handler(ngx_stream_session_t *s)
  394. {
  395.     u_char                           *p;
  396.     ngx_str_t                        *host;
  397.     ngx_uint_t                        i;
  398.     ngx_connection_t                 *c;
  399.     ngx_resolver_ctx_t               *ctx, temp;
  400.     ngx_stream_upstream_t            *u;
  401.     ngx_stream_core_srv_conf_t       *cscf;
  402.     ngx_stream_proxy_srv_conf_t      *pscf;
  403.     ngx_stream_upstream_srv_conf_t   *uscf, **uscfp;
  404.     ngx_stream_upstream_main_conf_t  *umcf;

  406.     c = s->connection;

  408.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

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

  413.     u = ngx_pcalloc(c->pool, sizeof(ngx_stream_upstream_t));
  414.     if (u == NULL) {
  415.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  416.         return;
  417.     }

  419.     s->upstream = u;

  421.     s->log_handler = ngx_stream_proxy_log_error;

  423.     u->requests = 1;

  425.     u->peer.log = c->log;
  426.     u->peer.log_error = NGX_ERROR_ERR;

  428.     if (ngx_stream_proxy_set_local(s, u, pscf->local) != NGX_OK) {
  429.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  430.         return;
  431.     }

  433.     if (pscf->socket_keepalive) {
  434.         u->peer.so_keepalive = 1;
  435.     }

  437.     u->peer.type = c->type;
  438.     u->start_sec = ngx_time();

  440.     c->write->handler = ngx_stream_proxy_downstream_handler;
  441.     c->read->handler = ngx_stream_proxy_downstream_handler;

  443.     s->upstream_states = ngx_array_create(c->pool, 1,
  444.                                           sizeof(ngx_stream_upstream_state_t));
  445.     if (s->upstream_states == NULL) {
  446.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  447.         return;
  448.     }

  450.     p = ngx_pnalloc(c->pool, pscf->buffer_size);
  451.     if (p == NULL) {
  452.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  453.         return;
  454.     }

  456.     u->downstream_buf.start = p;
  457.     u->downstream_buf.end = p + pscf->buffer_size;
  458.     u->downstream_buf.pos = p;
  459.     u->downstream_buf.last = p;

  461.     if (c->read->ready) {
  462.         ngx_post_event(c->read, &ngx_posted_events);
  463.     }

  465.     if (pscf->upstream_value) {
  466.         if (ngx_stream_proxy_eval(s, pscf) != NGX_OK) {
  467.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  468.             return;
  469.         }
  470.     }

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

  474.         uscf = pscf->upstream;

  476.     } else {

  478. #if (NGX_STREAM_SSL)
  479.         u->ssl_name = u->resolved->host;
  480. #endif

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

  484.         umcf = ngx_stream_get_module_main_conf(s, ngx_stream_upstream_module);

  486.         uscfp = umcf->upstreams.elts;

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

  490.             uscf = uscfp[i];

  492.             if (uscf->host.len == host->len
  493.                 && ((uscf->port == 0 && u->resolved->no_port)
  494.                      || uscf->port == u->resolved->port)
  495.                 && ngx_strncasecmp(uscf->host.data, host->data, host->len) == 0)
  496.             {
  497.                 goto found;
  498.             }
  499.         }

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

  503.             if (u->resolved->port == 0
  504.                 && u->resolved->sockaddr->sa_family != AF_UNIX)
  505.             {
  506.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  507.                               "no port in upstream \"%V\"", host);
  508.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  509.                 return;
  510.             }

  512.             if (ngx_stream_upstream_create_round_robin_peer(s, u->resolved)
  513.                 != NGX_OK)
  514.             {
  515.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  516.                 return;
  517.             }

  519.             ngx_stream_proxy_connect(s);

  521.             return;
  522.         }

  524.         if (u->resolved->port == 0) {
  525.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  526.                           "no port in upstream \"%V\"", host);
  527.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  528.             return;
  529.         }

  531.         temp.name = *host;

  533.         cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  535.         ctx = ngx_resolve_start(cscf->resolver, &temp);
  536.         if (ctx == NULL) {
  537.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  538.             return;
  539.         }

  541.         if (ctx == NGX_NO_RESOLVER) {
  542.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  543.                           "no resolver defined to resolve %V", host);
  544.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  545.             return;
  546.         }

  548.         ctx->name = *host;
  549.         ctx->handler = ngx_stream_proxy_resolve_handler;
  550.         ctx->data = s;
  551.         ctx->timeout = cscf->resolver_timeout;

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

  555.         if (ngx_resolve_name(ctx) != NGX_OK) {
  556.             u->resolved->ctx = NULL;
  557.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  558.             return;
  559.         }

  561.         return;
  562.     }

  564. found:

  566.     if (uscf == NULL) {
  567.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "no upstream configuration");
  568.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  569.         return;
  570.     }

  572.     u->upstream = uscf;

  574. #if (NGX_STREAM_SSL)
  575.     u->ssl_name = uscf->host;
  576. #endif

  578.     if (uscf->peer.init(s, uscf) != NGX_OK) {
  579.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  580.         return;
  581.     }

  583.     u->peer.start_time = ngx_current_msec;

  585.     if (pscf->next_upstream_tries
  586.         && u->peer.tries > pscf->next_upstream_tries)
  587.     {
  588.         u->peer.tries = pscf->next_upstream_tries;
  589.     }

  591.     ngx_stream_proxy_connect(s);
  592. }


  595. static ngx_int_t
  596. ‌ngx_stream_proxy_eval(ngx_stream_session_t *s,
  597.     ngx_stream_proxy_srv_conf_t *pscf)
  598. {
  599.     ngx_str_t               host;
  600.     ngx_url_t               url;
  601.     ngx_stream_upstream_t  *u;

  603.     if (ngx_stream_complex_value(s, pscf->upstream_value, &host) != NGX_OK) {
  604.         return NGX_ERROR;
  605.     }

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

  609.     url.url = host;
  610.     url.no_resolve = 1;

  612.     if (ngx_parse_url(s->connection->pool, &url) != NGX_OK) {
  613.         if (url.err) {
  614.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  615.                           "%s in upstream \"%V\"", url.err, &url.url);
  616.         }

  618.         return NGX_ERROR;
  619.     }

  621.     u = s->upstream;

  623.     u->resolved = ngx_pcalloc(s->connection->pool,
  624.                               sizeof(ngx_stream_upstream_resolved_t));
  625.     if (u->resolved == NULL) {
  626.         return NGX_ERROR;
  627.     }

  629.     if (url.addrs) {
  630.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  631.         u->resolved->socklen = url.addrs[0].socklen;
  632.         u->resolved->name = url.addrs[0].name;
  633.         u->resolved->naddrs = 1;
  634.     }

  636.     u->resolved->host = url.host;
  637.     u->resolved->port = url.port;
  638.     u->resolved->no_port = url.no_port;

  640.     return NGX_OK;
  641. }


  644. static ngx_int_t
  645. ‌ngx_stream_proxy_set_local(ngx_stream_session_t *s, ngx_stream_upstream_t *u,
  646.     ngx_stream_upstream_local_t *local)
  647. {
  648.     ngx_int_t    rc;
  649.     ngx_str_t    val;
  650.     ngx_addr_t  *addr;

  652.     if (local == NULL) {
  653.         u->peer.local = NULL;
  654.         return NGX_OK;
  655.     }

  657. #if (NGX_HAVE_TRANSPARENT_PROXY)
  658.     u->peer.transparent = local->transparent;
  659. #endif

  661.     if (local->value == NULL) {
  662.         u->peer.local = local->addr;
  663.         return NGX_OK;
  664.     }

  666.     if (ngx_stream_complex_value(s, local->value, &val) != NGX_OK) {
  667.         return NGX_ERROR;
  668.     }

  670.     if (val.len == 0) {
  671.         return NGX_OK;
  672.     }

  674.     addr = ngx_palloc(s->connection->pool, sizeof(ngx_addr_t));
  675.     if (addr == NULL) {
  676.         return NGX_ERROR;
  677.     }

  679.     rc = ngx_parse_addr_port(s->connection->pool, addr, val.data, val.len);
  680.     if (rc == NGX_ERROR) {
  681.         return NGX_ERROR;
  682.     }

  684.     if (rc != NGX_OK) {
  685.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  686.                       "invalid local address \"%V\"", &val);
  687.         return NGX_OK;
  688.     }

  690.     addr->name = val;
  691.     u->peer.local = addr;

  693.     return NGX_OK;
  694. }


  697. static void
  698. ‌ngx_stream_proxy_connect(ngx_stream_session_t *s)
  699. {
  700.     ngx_int_t                     rc;
  701.     ngx_connection_t             *c, *pc;
  702.     ngx_stream_upstream_t        *u;
  703.     ngx_stream_proxy_srv_conf_t  *pscf;

  705.     c = s->connection;

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

  709.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  711.     u = s->upstream;

  713.     u->connected = 0;
  714.     u->proxy_protocol = pscf->proxy_protocol;

  716.     if (u->state) {
  717.         u->state->response_time = ngx_current_msec - u->start_time;
  718.     }

  720.     u->state = ngx_array_push(s->upstream_states);
  721.     if (u->state == NULL) {
  722.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  723.         return;
  724.     }

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

  728.     u->start_time = ngx_current_msec;

  730.     u->state->connect_time = (ngx_msec_t) -1;
  731.     u->state->first_byte_time = (ngx_msec_t) -1;
  732.     u->state->response_time = (ngx_msec_t) -1;

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

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

  738.     if (rc == NGX_ERROR) {
  739.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  740.         return;
  741.     }

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

  745. #if (NGX_STREAM_UPSTREAM_ZONE)
  746.     if (u->upstream && u->upstream->shm_zone
  747.         && (u->upstream->flags & NGX_STREAM_UPSTREAM_MODIFY))
  748.     {
  749.         u->state->peer = ngx_palloc(s->connection->pool,
  750.                                     sizeof(ngx_str_t) + u->peer.name->len);
  751.         if (u->state->peer == NULL) {
  752.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  753.             return;
  754.         }

  756.         u->state->peer->len = u->peer.name->len;
  757.         u->state->peer->data = (u_char *) (u->state->peer + 1);
  758.         ngx_memcpy(u->state->peer->data, u->peer.name->data, u->peer.name->len);

  760.         u->peer.name = u->state->peer;
  761.     }
  762. #endif

  764.     if (rc == NGX_BUSY) {
  765.         ngx_log_error(NGX_LOG_ERR, c->log, 0, "no live upstreams");
  766.         ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);
  767.         return;
  768.     }

  770.     if (rc == NGX_DECLINED) {
  771.         ngx_stream_proxy_next_upstream(s);
  772.         return;
  773.     }

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

  777.     pc = u->peer.connection;

  779.     pc->data = s;
  780.     pc->log = c->log;
  781.     pc->pool = c->pool;
  782.     pc->read->log = c->log;
  783.     pc->write->log = c->log;

  785.     if (rc != NGX_AGAIN) {
  786.         ngx_stream_proxy_init_upstream(s);
  787.         return;
  788.     }

  790.     pc->read->handler = ngx_stream_proxy_connect_handler;
  791.     pc->write->handler = ngx_stream_proxy_connect_handler;

  793.     ngx_add_timer(pc->write, pscf->connect_timeout);
  794. }


  797. static void
  798. ‌ngx_stream_proxy_init_upstream(ngx_stream_session_t *s)
  799. {
  800.     u_char                       *p;
  801.     ngx_chain_t                  *cl;
  802.     ngx_connection_t             *c, *pc;
  803.     ngx_log_handler_pt            handler;
  804.     ngx_stream_upstream_t        *u;
  805.     ngx_stream_core_srv_conf_t   *cscf;
  806.     ngx_stream_proxy_srv_conf_t  *pscf;

  808.     u = s->upstream;
  809.     pc = u->peer.connection;

  811.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  813.     if (pc->type == SOCK_STREAM
  814.         && cscf->tcp_nodelay
  815.         && ngx_tcp_nodelay(pc) != NGX_OK)
  816.     {
  817.         ngx_stream_proxy_next_upstream(s);
  818.         return;
  819.     }

  821.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  823. #if (NGX_STREAM_SSL)

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

  827.         if (u->proxy_protocol) {
  828.             if (ngx_stream_proxy_send_proxy_protocol(s) != NGX_OK) {
  829.                 return;
  830.             }

  832.             u->proxy_protocol = 0;
  833.         }

  835.         if (pc->ssl == NULL) {
  836.             ngx_stream_proxy_ssl_init_connection(s);
  837.             return;
  838.         }
  839.     }

  841. #endif

  843.     c = s->connection;

  845.     if (c->log->log_level >= NGX_LOG_INFO) {
  846.         ngx_str_t  str;
  847.         u_char     addr[NGX_SOCKADDR_STRLEN];

  849.         str.len = NGX_SOCKADDR_STRLEN;
  850.         str.data = addr;

  852.         if (ngx_connection_local_sockaddr(pc, &str, 1) == NGX_OK) {
  853.             handler = c->log->handler;
  854.             c->log->handler = NULL;

  856.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  857.                           "%sproxy %V connected to %V",
  858.                           pc->type == SOCK_DGRAM ? "udp " : "",
  859.                           &str, u->peer.name);

  861.             c->log->handler = handler;
  862.         }
  863.     }

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

  867.     if (u->peer.notify) {
  868.         u->peer.notify(&u->peer, u->peer.data,
  869.                        NGX_STREAM_UPSTREAM_NOTIFY_CONNECT);
  870.     }

  872.     if (u->upstream_buf.start == NULL) {
  873.         p = ngx_pnalloc(c->pool, pscf->buffer_size);
  874.         if (p == NULL) {
  875.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  876.             return;
  877.         }

  879.         u->upstream_buf.start = p;
  880.         u->upstream_buf.end = p + pscf->buffer_size;
  881.         u->upstream_buf.pos = p;
  882.         u->upstream_buf.last = p;
  883.     }

  885.     if (c->buffer && c->buffer->pos <= c->buffer->last) {
  886.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  887.                        "stream proxy add preread buffer: %uz",
  888.                        c->buffer->last - c->buffer->pos);

  890.         cl = ngx_chain_get_free_buf(c->pool, &u->free);
  891.         if (cl == NULL) {
  892.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  893.             return;
  894.         }

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

  898.         cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;
  899.         cl->buf->temporary = (cl->buf->pos == cl->buf->last) ? 0 : 1;
  900.         cl->buf->flush = 1;

  902.         cl->next = u->upstream_out;
  903.         u->upstream_out = cl;
  904.     }

  906.     if (u->proxy_protocol) {
  907.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  908.                        "stream proxy add PROXY protocol header");

  910.         cl = ngx_chain_get_free_buf(c->pool, &u->free);
  911.         if (cl == NULL) {
  912.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  913.             return;
  914.         }

  916.         p = ngx_pnalloc(c->pool, NGX_PROXY_PROTOCOL_V1_MAX_HEADER);
  917.         if (p == NULL) {
  918.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  919.             return;
  920.         }

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

  924.         p = ngx_proxy_protocol_write(c, p,
  925.                                      p + NGX_PROXY_PROTOCOL_V1_MAX_HEADER);
  926.         if (p == NULL) {
  927.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  928.             return;
  929.         }

  931.         cl->buf->last = p;
  932.         cl->buf->temporary = 1;
  933.         cl->buf->flush = 0;
  934.         cl->buf->last_buf = 0;
  935.         cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;

  937.         cl->next = u->upstream_out;
  938.         u->upstream_out = cl;

  940.         u->proxy_protocol = 0;
  941.     }

  943.     u->upload_rate = ngx_stream_complex_value_size(s, pscf->upload_rate, 0);
  944.     u->download_rate = ngx_stream_complex_value_size(s, pscf->download_rate, 0);

  946.     u->connected = 1;

  948.     pc->read->handler = ngx_stream_proxy_upstream_handler;
  949.     pc->write->handler = ngx_stream_proxy_upstream_handler;

  951.     if (pc->read->ready) {
  952.         ngx_post_event(pc->read, &ngx_posted_events);
  953.     }

  955.     ngx_stream_proxy_process(s, 0, 1);
  956. }


  959. #if (NGX_STREAM_SSL)

  961. static ngx_int_t
  962. ‌ngx_stream_proxy_send_proxy_protocol(ngx_stream_session_t *s)
  963. {
  964.     u_char                       *p;
  965.     ssize_t                       n, size;
  966.     ngx_connection_t             *c, *pc;
  967.     ngx_stream_upstream_t        *u;
  968.     ngx_stream_proxy_srv_conf_t  *pscf;
  969.     u_char                        buf[NGX_PROXY_PROTOCOL_V1_MAX_HEADER];

  971.     c = s->connection;

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

  976.     p = ngx_proxy_protocol_write(c, buf,
  977.                                  buf + NGX_PROXY_PROTOCOL_V1_MAX_HEADER);
  978.     if (p == NULL) {
  979.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  980.         return NGX_ERROR;
  981.     }

  983.     u = s->upstream;

  985.     pc = u->peer.connection;

  987.     size = p - buf;

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

  991.     if (n == NGX_AGAIN) {
  992.         if (ngx_handle_write_event(pc->write, 0) != NGX_OK) {
  993.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  994.             return NGX_ERROR;
  995.         }

  997.         pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

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

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

  1003.         return NGX_AGAIN;
  1004.     }

  1006.     if (n == NGX_ERROR) {
  1007.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1008.         return NGX_ERROR;
  1009.     }

  1011.     if (n != size) {

  1013.         /*
  1014.          * PROXY protocol specification:
  1015.          * The sender must always ensure that the header
  1016.          * is sent at once, so that the transport layer
  1017.          * maintains atomicity along the path to the receiver.
  1018.          */

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

  1023.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);

  1025.         return NGX_ERROR;
  1026.     }

  1028.     return NGX_OK;
  1029. }


  1032. static char *
  1033. ‌ngx_stream_proxy_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd,
  1034.     void *conf)
  1035. {
  1036.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  1038.     ngx_str_t  *value;

  1040.     if (pscf->ssl_passwords != NGX_CONF_UNSET_PTR) {
  1041.         return "is duplicate";
  1042.     }

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

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

  1048.     if (pscf->ssl_passwords == NULL) {
  1049.         return NGX_CONF_ERROR;
  1050.     }

  1052.     return NGX_CONF_OK;
  1053. }


  1056. static char *
  1057. ‌ngx_stream_proxy_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  1058. {
  1059. #ifndef SSL_CONF_FLAG_FILE
  1060.     return "is not supported on this platform";
  1061. #else
  1062.     return NGX_CONF_OK;
  1063. #endif
  1064. }


  1067. static void
  1068. ‌ngx_stream_proxy_ssl_init_connection(ngx_stream_session_t *s)
  1069. {
  1070.     ngx_int_t                     rc;
  1071.     ngx_connection_t             *pc;
  1072.     ngx_stream_upstream_t        *u;
  1073.     ngx_stream_proxy_srv_conf_t  *pscf;

  1075.     u = s->upstream;

  1077.     pc = u->peer.connection;

  1079.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1081.     if (ngx_ssl_create_connection(pscf->ssl, pc, NGX_SSL_BUFFER|NGX_SSL_CLIENT)
  1082.         != NGX_OK)
  1083.     {
  1084.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1085.         return;
  1086.     }

  1088.     if (pscf->ssl_server_name || pscf->ssl_verify) {
  1089.         if (ngx_stream_proxy_ssl_name(s) != NGX_OK) {
  1090.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1091.             return;
  1092.         }
  1093.     }

  1095.     if (pscf->ssl_certificate
  1096.         && pscf->ssl_certificate->value.len
  1097.         && (pscf->ssl_certificate->lengths
  1098.             || pscf->ssl_certificate_key->lengths))
  1099.     {
  1100.         if (ngx_stream_proxy_ssl_certificate(s) != NGX_OK) {
  1101.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1102.             return;
  1103.         }
  1104.     }

  1106.     if (pscf->ssl_session_reuse) {
  1107.         pc->ssl->save_session = ngx_stream_proxy_ssl_save_session;

  1109.         if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
  1110.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1111.             return;
  1112.         }
  1113.     }

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

  1117.     rc = ngx_ssl_handshake(pc);

  1119.     if (rc == NGX_AGAIN) {

  1121.         if (!pc->write->timer_set) {
  1122.             ngx_add_timer(pc->write, pscf->connect_timeout);
  1123.         }

  1125.         pc->ssl->handler = ngx_stream_proxy_ssl_handshake;
  1126.         return;
  1127.     }

  1129.     ngx_stream_proxy_ssl_handshake(pc);
  1130. }


  1133. static void
  1134. ‌ngx_stream_proxy_ssl_handshake(ngx_connection_t *pc)
  1135. {
  1136.     long                          rc;
  1137.     ngx_stream_session_t         *s;
  1138.     ngx_stream_upstream_t        *u;
  1139.     ngx_stream_proxy_srv_conf_t  *pscf;

  1141.     s = pc->data;

  1143.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

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

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

  1150.             if (rc != X509_V_OK) {
  1151.                 ngx_log_error(NGX_LOG_ERR, pc->log, 0,
  1152.                               "upstream SSL certificate verify error: (%l:%s)",
  1153.                               rc, X509_verify_cert_error_string(rc));
  1154.                 goto failed;
  1155.             }

  1157.             u = s->upstream;

  1159.             if (ngx_ssl_check_host(pc, &u->ssl_name) != NGX_OK) {
  1160.                 ngx_log_error(NGX_LOG_ERR, pc->log, 0,
  1161.                               "upstream SSL certificate does not match \"%V\"",
  1162.                               &u->ssl_name);
  1163.                 goto failed;
  1164.             }
  1165.         }

  1167.         if (pc->write->timer_set) {
  1168.             ngx_del_timer(pc->write);
  1169.         }

  1171.         ngx_stream_proxy_init_upstream(s);

  1173.         return;
  1174.     }

  1176. failed:

  1178.     ngx_stream_proxy_next_upstream(s);
  1179. }


  1182. static void
  1183. ‌ngx_stream_proxy_ssl_save_session(ngx_connection_t *c)
  1184. {
  1185.     ngx_stream_session_t   *s;
  1186.     ngx_stream_upstream_t  *u;

  1188.     s = c->data;
  1189.     u = s->upstream;

  1191.     u->peer.save_session(&u->peer, u->peer.data);
  1192. }


  1195. static ngx_int_t
  1196. ‌ngx_stream_proxy_ssl_name(ngx_stream_session_t *s)
  1197. {
  1198.     u_char                       *p, *last;
  1199.     ngx_str_t                     name;
  1200.     ngx_stream_upstream_t        *u;
  1201.     ngx_stream_proxy_srv_conf_t  *pscf;

  1203.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1205.     u = s->upstream;

  1207.     if (pscf->ssl_name) {
  1208.         if (ngx_stream_complex_value(s, pscf->ssl_name, &name) != NGX_OK) {
  1209.             return NGX_ERROR;
  1210.         }

  1212.     } else {
  1213.         name = u->ssl_name;
  1214.     }

  1216.     if (name.len == 0) {
  1217.         goto done;
  1218.     }

  1220.     /*
  1221.      * ssl name here may contain port, strip it for compatibility
  1222.      * with the http module
  1223.      */

  1225.     p = name.data;
  1226.     last = name.data + name.len;

  1228.     if (*p == '[') {
  1229.         p = ngx_strlchr(p, last, ']');

  1231.         if (p == NULL) {
  1232.             p = name.data;
  1233.         }
  1234.     }

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

  1238.     if (p != NULL) {
  1239.         name.len = p - name.data;
  1240.     }

  1242.     if (!pscf->ssl_server_name) {
  1243.         goto done;
  1244.     }

  1246. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  1250.     if (name.len == 0 || *name.data == '[') {
  1251.         goto done;
  1252.     }

  1254.     if (ngx_inet_addr(name.data, name.len) != INADDR_NONE) {
  1255.         goto done;
  1256.     }

  1258.     /*
  1259.      * SSL_set_tlsext_host_name() needs a null-terminated string,
  1260.      * hence we explicitly null-terminate name here
  1261.      */

  1263.     p = ngx_pnalloc(s->connection->pool, name.len + 1);
  1264.     if (p == NULL) {
  1265.         return NGX_ERROR;
  1266.     }

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

  1270.     name.data = p;

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

  1275.     if (SSL_set_tlsext_host_name(u->peer.connection->ssl->connection,
  1276.                                  (char *) name.data)
  1277.         == 0)
  1278.     {
  1279.         ngx_ssl_error(NGX_LOG_ERR, s->connection->log, 0,
  1280.                       "SSL_set_tlsext_host_name(\"%s\") failed", name.data);
  1281.         return NGX_ERROR;
  1282.     }

  1284. #endif

  1286. done:

  1288.     u->ssl_name = name;

  1290.     return NGX_OK;
  1291. }


  1294. static ngx_int_t
  1295. ‌ngx_stream_proxy_ssl_certificate(ngx_stream_session_t *s)
  1296. {
  1297.     ngx_str_t                     cert, key;
  1298.     ngx_connection_t             *c;
  1299.     ngx_stream_proxy_srv_conf_t  *pscf;

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

  1303.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1305.     if (ngx_stream_complex_value(s, pscf->ssl_certificate, &cert)
  1306.         != NGX_OK)
  1307.     {
  1308.         return NGX_ERROR;
  1309.     }

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

  1314.     if (*cert.data == '\0') {
  1315.         return NGX_OK;
  1316.     }

  1318.     if (ngx_stream_complex_value(s, pscf->ssl_certificate_key, &key)
  1319.         != NGX_OK)
  1320.     {
  1321.         return NGX_ERROR;
  1322.     }

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

  1327.     if (ngx_ssl_connection_certificate(c, c->pool, &cert, &key,
  1328.                                        pscf->ssl_passwords)
  1329.         != NGX_OK)
  1330.     {
  1331.         return NGX_ERROR;
  1332.     }

  1334.     return NGX_OK;
  1335. }

  1337. #endif


  1340. static void
  1341. ‌ngx_stream_proxy_downstream_handler(ngx_event_t *ev)
  1342. {
  1343.     ngx_stream_proxy_process_connection(ev, ev->write);
  1344. }


  1347. static void
  1348. ‌ngx_stream_proxy_resolve_handler(ngx_resolver_ctx_t *ctx)
  1349. {
  1350.     ngx_stream_session_t            *s;
  1351.     ngx_stream_upstream_t           *u;
  1352.     ngx_stream_proxy_srv_conf_t     *pscf;
  1353.     ngx_stream_upstream_resolved_t  *ur;

  1355.     s = ctx->data;

  1357.     u = s->upstream;
  1358.     ur = u->resolved;

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

  1363.     if (ctx->state) {
  1364.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1365.                       "%V could not be resolved (%i: %s)",
  1366.                       &ctx->name, ctx->state,
  1367.                       ngx_resolver_strerror(ctx->state));

  1369.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1370.         return;
  1371.     }

  1373.     ur->naddrs = ctx->naddrs;
  1374.     ur->addrs = ctx->addrs;

  1376. #if (NGX_DEBUG)
  1377.     {
  1378.     u_char      text[NGX_SOCKADDR_STRLEN];
  1379.     ngx_str_t   addr;
  1380.     ngx_uint_t  i;

  1382.     addr.data = text;

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

  1388.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  1389.                        "name was resolved to %V", &addr);
  1390.     }
  1391.     }
  1392. #endif

  1394.     if (ngx_stream_upstream_create_round_robin_peer(s, ur) != NGX_OK) {
  1395.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1396.         return;
  1397.     }

  1399.     ngx_resolve_name_done(ctx);
  1400.     ur->ctx = NULL;

  1402.     u->peer.start_time = ngx_current_msec;

  1404.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1406.     if (pscf->next_upstream_tries
  1407.         && u->peer.tries > pscf->next_upstream_tries)
  1408.     {
  1409.         u->peer.tries = pscf->next_upstream_tries;
  1410.     }

  1412.     ngx_stream_proxy_connect(s);
  1413. }


  1416. static void
  1417. ‌ngx_stream_proxy_upstream_handler(ngx_event_t *ev)
  1418. {
  1419.     ngx_stream_proxy_process_connection(ev, !ev->write);
  1420. }


  1423. static void
  1424. ‌ngx_stream_proxy_process_connection(ngx_event_t *ev, ngx_uint_t from_upstream)
  1425. {
  1426.     ngx_connection_t             *c, *pc;
  1427.     ngx_log_handler_pt            handler;
  1428.     ngx_stream_session_t         *s;
  1429.     ngx_stream_upstream_t        *u;
  1430.     ngx_stream_proxy_srv_conf_t  *pscf;

  1432.     c = ev->data;
  1433.     s = c->data;
  1434.     u = s->upstream;

  1436.     if (c->close) {
  1437.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "shutdown timeout");
  1438.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1439.         return;
  1440.     }

  1442.     c = s->connection;
  1443.     pc = u->peer.connection;

  1445.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1447.     if (ev->timedout) {
  1448.         ev->timedout = 0;

  1450.         if (ev->delayed) {
  1451.             ev->delayed = 0;

  1453.             if (!ev->ready) {
  1454.                 if (ngx_handle_read_event(ev, 0) != NGX_OK) {
  1455.                     ngx_stream_proxy_finalize(s,
  1456.                                               NGX_STREAM_INTERNAL_SERVER_ERROR);
  1457.                     return;
  1458.                 }

  1460.                 if (u->connected && !c->read->delayed && !pc->read->delayed) {
  1461.                     ngx_add_timer(c->write, pscf->timeout);
  1462.                 }

  1464.                 return;
  1465.             }

  1467.         } else {
  1468.             if (s->connection->type == SOCK_DGRAM) {

  1470.                 if (pscf->responses == NGX_MAX_INT32_VALUE
  1471.                     || (u->responses >= pscf->responses * u->requests))
  1472.                 {

  1474.                     /*
  1475.                      * successfully terminate timed out UDP session
  1476.                      * if expected number of responses was received
  1477.                      */

  1479.                     handler = c->log->handler;
  1480.                     c->log->handler = NULL;

  1482.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1483.                                   "udp timed out"
  1484.                                   ", packets from/to client:%ui/%ui"
  1485.                                   ", bytes from/to client:%O/%O"
  1486.                                   ", bytes from/to upstream:%O/%O",
  1487.                                   u->requests, u->responses,
  1488.                                   s->received, c->sent, u->received,
  1489.                                   pc ? pc->sent : 0);

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

  1493.                     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1494.                     return;
  1495.                 }

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

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

  1501.                 ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);

  1503.                 return;
  1504.             }

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

  1508.             ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  1510.             return;
  1511.         }

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

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

  1518.         if (ngx_handle_read_event(ev, 0) != NGX_OK) {
  1519.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1520.         }

  1522.         return;
  1523.     }

  1525.     if (from_upstream && !u->connected) {
  1526.         return;
  1527.     }

  1529.     ngx_stream_proxy_process(s, from_upstream, ev->write);
  1530. }


  1533. static void
  1534. ‌ngx_stream_proxy_connect_handler(ngx_event_t *ev)
  1535. {
  1536.     ngx_connection_t      *c;
  1537.     ngx_stream_session_t  *s;

  1539.     c = ev->data;
  1540.     s = c->data;

  1542.     if (ev->timedout) {
  1543.         ngx_log_error(NGX_LOG_ERR, c->log, NGX_ETIMEDOUT, "upstream timed out");
  1544.         ngx_stream_proxy_next_upstream(s);
  1545.         return;
  1546.     }

  1548.     ngx_del_timer(c->write);

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

  1553.     if (ngx_stream_proxy_test_connect(c) != NGX_OK) {
  1554.         ngx_stream_proxy_next_upstream(s);
  1555.         return;
  1556.     }

  1558.     ngx_stream_proxy_init_upstream(s);
  1559. }


  1562. static ngx_int_t
  1563. ‌ngx_stream_proxy_test_connect(ngx_connection_t *c)
  1564. {
  1565.     int        err;
  1566.     socklen_t  len;

  1568. #if (NGX_HAVE_KQUEUE)

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

  1573.         if (err) {
  1574.             (void) ngx_connection_error(c, err,
  1575.                                     "kevent() reported that connect() failed");
  1576.             return NGX_ERROR;
  1577.         }

  1579.     } else
  1580. #endif
  1581.     {
  1582.         err = 0;
  1583.         len = sizeof(int);

  1585.         /*
  1586.          * BSDs and Linux return 0 and set a pending error in err
  1587.          * Solaris returns -1 and sets errno
  1588.          */

  1590.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  1591.             == -1)
  1592.         {
  1593.             err = ngx_socket_errno;
  1594.         }

  1596.         if (err) {
  1597.             (void) ngx_connection_error(c, err, "connect() failed");
  1598.             return NGX_ERROR;
  1599.         }
  1600.     }

  1602.     return NGX_OK;
  1603. }


  1606. static void
  1607. ‌ngx_stream_proxy_process(ngx_stream_session_t *s, ngx_uint_t from_upstream,
  1608.     ngx_uint_t do_write)
  1609. {
  1610.     char                         *recv_action, *send_action;
  1611.     off_t                        *received, limit;
  1612.     size_t                        size, limit_rate;
  1613.     ssize_t                       n;
  1614.     ngx_buf_t                    *b;
  1615.     ngx_int_t                     rc;
  1616.     ngx_uint_t                    flags, *packets;
  1617.     ngx_msec_t                    delay;
  1618.     ngx_chain_t                  *cl, **ll, **out, **busy;
  1619.     ngx_connection_t             *c, *pc, *src, *dst;
  1620.     ngx_log_handler_pt            handler;
  1621.     ngx_stream_upstream_t        *u;
  1622.     ngx_stream_proxy_srv_conf_t  *pscf;

  1624.     u = s->upstream;

  1626.     c = s->connection;
  1627.     pc = u->connected ? u->peer.connection : NULL;

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

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

  1633.         handler = c->log->handler;
  1634.         c->log->handler = NULL;

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

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

  1640.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1641.         return;
  1642.     }

  1644.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1646.     if (from_upstream) {
  1647.         src = pc;
  1648.         dst = c;
  1649.         b = &u->upstream_buf;
  1650.         limit_rate = u->download_rate;
  1651.         received = &u->received;
  1652.         packets = &u->responses;
  1653.         out = &u->downstream_out;
  1654.         busy = &u->downstream_busy;
  1655.         recv_action = "proxying and reading from upstream";
  1656.         send_action = "proxying and sending to client";

  1658.     } else {
  1659.         src = c;
  1660.         dst = pc;
  1661.         b = &u->downstream_buf;
  1662.         limit_rate = u->upload_rate;
  1663.         received = &s->received;
  1664.         packets = &u->requests;
  1665.         out = &u->upstream_out;
  1666.         busy = &u->upstream_busy;
  1667.         recv_action = "proxying and reading from client";
  1668.         send_action = "proxying and sending to upstream";
  1669.     }

  1671.     for ( ;; ) {

  1673.         if (do_write && dst) {

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

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

  1680.                 if (rc == NGX_ERROR) {
  1681.                     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);
  1682.                     return;
  1683.                 }

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

  1688.                 if (*busy == NULL) {
  1689.                     b->pos = b->start;
  1690.                     b->last = b->start;
  1691.                 }
  1692.             }
  1693.         }

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

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

  1699.             if (limit_rate) {
  1700.                 limit = (off_t) limit_rate * (ngx_time() - u->start_sec + 1)
  1701.                         - *received;

  1703.                 if (limit <= 0) {
  1704.                     src->read->delayed = 1;
  1705.                     delay = (ngx_msec_t) (- limit * 1000 / limit_rate + 1);
  1706.                     ngx_add_timer(src->read, delay);
  1707.                     break;
  1708.                 }

  1710.                 if (c->type == SOCK_STREAM && (off_t) size > limit) {
  1711.                     size = (size_t) limit;
  1712.                 }
  1713.             }

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

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

  1719.             if (n == NGX_AGAIN) {
  1720.                 break;
  1721.             }

  1723.             if (n == NGX_ERROR) {
  1724.                 src->read->eof = 1;
  1725.                 n = 0;
  1726.             }

  1728.             if (n >= 0) {
  1729.                 if (limit_rate) {
  1730.                     delay = (ngx_msec_t) (n * 1000 / limit_rate);

  1732.                     if (delay > 0) {
  1733.                         src->read->delayed = 1;
  1734.                         ngx_add_timer(src->read, delay);
  1735.                     }
  1736.                 }

  1738.                 if (from_upstream) {
  1739.                     if (u->state->first_byte_time == (ngx_msec_t) -1) {
  1740.                         u->state->first_byte_time = ngx_current_msec
  1741.                                                     - u->start_time;
  1742.                     }
  1743.                 }

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

  1747.                 cl = ngx_chain_get_free_buf(c->pool, &u->free);
  1748.                 if (cl == NULL) {
  1749.                     ngx_stream_proxy_finalize(s,
  1750.                                               NGX_STREAM_INTERNAL_SERVER_ERROR);
  1751.                     return;
  1752.                 }

  1754.                 *ll = cl;

  1756.                 cl->buf->pos = b->last;
  1757.                 cl->buf->last = b->last + n;
  1758.                 cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;

  1760.                 cl->buf->temporary = (n ? 1 : 0);
  1761.                 cl->buf->last_buf = src->read->eof;
  1762.                 cl->buf->flush = !src->read->eof;

  1764.                 (*packets)++;
  1765.                 *received += n;
  1766.                 b->last += n;
  1767.                 do_write = 1;

  1769.                 continue;
  1770.             }
  1771.         }

  1773.         break;
  1774.     }

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

  1778.     if (ngx_stream_proxy_test_finalize(s, from_upstream) == NGX_OK) {
  1779.         return;
  1780.     }

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

  1784.     if (ngx_handle_read_event(src->read, flags) != NGX_OK) {
  1785.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1786.         return;
  1787.     }

  1789.     if (dst) {

  1791.         if (dst->type == SOCK_STREAM && pscf->half_close
  1792.             && src->read->eof && !u->half_closed && !dst->buffered)
  1793.         {
  1794.             if (ngx_shutdown_socket(dst->fd, NGX_WRITE_SHUTDOWN) == -1) {
  1795.                 ngx_connection_error(c, ngx_socket_errno,
  1796.                                      ngx_shutdown_socket_n " failed");

  1798.                 ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1799.                 return;
  1800.             }

  1802.             u->half_closed = 1;
  1803.             ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  1804.                            "stream proxy %s socket shutdown",
  1805.                            from_upstream ? "client" : "upstream");
  1806.         }

  1808.         if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
  1809.             ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1810.             return;
  1811.         }

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

  1816.         } else if (c->write->timer_set) {
  1817.             ngx_del_timer(c->write);
  1818.         }
  1819.     }
  1820. }


  1823. static ngx_int_t
  1824. ‌ngx_stream_proxy_test_finalize(ngx_stream_session_t *s,
  1825.     ngx_uint_t from_upstream)
  1826. {
  1827.     ngx_connection_t             *c, *pc;
  1828.     ngx_log_handler_pt            handler;
  1829.     ngx_stream_upstream_t        *u;
  1830.     ngx_stream_proxy_srv_conf_t  *pscf;

  1832.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1834.     c = s->connection;
  1835.     u = s->upstream;
  1836.     pc = u->connected ? u->peer.connection : NULL;

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

  1840.         if (pscf->requests && u->requests < pscf->requests) {
  1841.             return NGX_DECLINED;
  1842.         }

  1844.         if (pscf->requests) {
  1845.             ngx_delete_udp_connection(c);
  1846.         }

  1848.         if (pscf->responses == NGX_MAX_INT32_VALUE
  1849.             || u->responses < pscf->responses * u->requests)
  1850.         {
  1851.             return NGX_DECLINED;
  1852.         }

  1854.         if (pc == NULL || c->buffered || pc->buffered) {
  1855.             return NGX_DECLINED;
  1856.         }

  1858.         handler = c->log->handler;
  1859.         c->log->handler = NULL;

  1861.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1862.                       "udp done"
  1863.                       ", packets from/to client:%ui/%ui"
  1864.                       ", bytes from/to client:%O/%O"
  1865.                       ", bytes from/to upstream:%O/%O",
  1866.                       u->requests, u->responses,
  1867.                       s->received, c->sent, u->received, pc ? pc->sent : 0);

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

  1871.         ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  1873.         return NGX_OK;
  1874.     }

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

  1878.     if (pc == NULL
  1879.         || (!c->read->eof && !pc->read->eof)
  1880.         || (!c->read->eof && c->buffered)
  1881.         || (!pc->read->eof && pc->buffered))
  1882.     {
  1883.         return NGX_DECLINED;
  1884.     }

  1886.     if (pscf->half_close) {
  1887.         /* avoid closing live connections until both read ends get EOF */
  1888.         if (!(c->read->eof && pc->read->eof && !c->buffered && !pc->buffered)) {
  1889.              return NGX_DECLINED;
  1890.         }
  1891.     }

  1893.     handler = c->log->handler;
  1894.     c->log->handler = NULL;

  1896.     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1897.                   "%s disconnected"
  1898.                   ", bytes from/to client:%O/%O"
  1899.                   ", bytes from/to upstream:%O/%O",
  1900.                   from_upstream ? "upstream" : "client",
  1901.                   s->received, c->sent, u->received, pc ? pc->sent : 0);

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

  1905.     ngx_stream_proxy_finalize(s, NGX_STREAM_OK);

  1907.     return NGX_OK;
  1908. }


  1911. static void
  1912. ‌ngx_stream_proxy_next_upstream(ngx_stream_session_t *s)
  1913. {
  1914.     ngx_msec_t                    timeout;
  1915.     ngx_connection_t             *pc;
  1916.     ngx_stream_upstream_t        *u;
  1917.     ngx_stream_proxy_srv_conf_t  *pscf;

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

  1922.     u = s->upstream;
  1923.     pc = u->peer.connection;

  1925.     if (pc && pc->buffered) {
  1926.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1927.                       "buffered data on next upstream");
  1928.         ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  1929.         return;
  1930.     }

  1932.     if (s->connection->type == SOCK_DGRAM) {
  1933.         u->upstream_out = NULL;
  1934.     }

  1936.     if (u->peer.sockaddr) {
  1937.         u->peer.free(&u->peer, u->peer.data, NGX_PEER_FAILED);
  1938.         u->peer.sockaddr = NULL;
  1939.     }

  1941.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);

  1943.     timeout = pscf->next_upstream_timeout;

  1945.     if (u->peer.tries == 0
  1946.         || !pscf->next_upstream
  1947.         || (timeout && ngx_current_msec - u->peer.start_time >= timeout))
  1948.     {
  1949.         ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);
  1950.         return;
  1951.     }

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

  1957. #if (NGX_STREAM_SSL)
  1958.         if (pc->ssl) {
  1959.             pc->ssl->no_wait_shutdown = 1;
  1960.             pc->ssl->no_send_shutdown = 1;

  1962.             (void) ngx_ssl_shutdown(pc);
  1963.         }
  1964. #endif

  1966.         u->state->bytes_received = u->received;
  1967.         u->state->bytes_sent = pc->sent;

  1969.         ngx_close_connection(pc);
  1970.         u->peer.connection = NULL;
  1971.     }

  1973.     ngx_stream_proxy_connect(s);
  1974. }


  1977. static void
  1978. ‌ngx_stream_proxy_finalize(ngx_stream_session_t *s, ngx_uint_t rc)
  1979. {
  1980.     ngx_uint_t              state;
  1981.     ngx_connection_t       *pc;
  1982.     ngx_stream_upstream_t  *u;

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

  1987.     u = s->upstream;

  1989.     if (u == NULL) {
  1990.         goto noupstream;
  1991.     }

  1993.     if (u->resolved && u->resolved->ctx) {
  1994.         ngx_resolve_name_done(u->resolved->ctx);
  1995.         u->resolved->ctx = NULL;
  1996.     }

  1998.     pc = u->peer.connection;

  2000.     if (u->state) {
  2001.         if (u->state->response_time == (ngx_msec_t) -1) {
  2002.             u->state->response_time = ngx_current_msec - u->start_time;
  2003.         }

  2005.         if (pc) {
  2006.             u->state->bytes_received = u->received;
  2007.             u->state->bytes_sent = pc->sent;
  2008.         }
  2009.     }

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

  2014.         if (pc && pc->type == SOCK_DGRAM
  2015.             && (pc->read->error || pc->write->error))
  2016.         {
  2017.             state = NGX_PEER_FAILED;
  2018.         }

  2020.         u->peer.free(&u->peer, u->peer.data, state);
  2021.         u->peer.sockaddr = NULL;
  2022.     }

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

  2028. #if (NGX_STREAM_SSL)
  2029.         if (pc->ssl) {
  2030.             pc->ssl->no_wait_shutdown = 1;
  2031.             (void) ngx_ssl_shutdown(pc);
  2032.         }
  2033. #endif

  2035.         ngx_close_connection(pc);
  2036.         u->peer.connection = NULL;
  2037.     }

  2039. noupstream:

  2041.     ngx_stream_finalize_session(s, rc);
  2042. }


  2045. static u_char *
  2046. ‌ngx_stream_proxy_log_error(ngx_log_t *log, u_char *buf, size_t len)
  2047. {
  2048.     u_char                 *p;
  2049.     ngx_connection_t       *pc;
  2050.     ngx_stream_session_t   *s;
  2051.     ngx_stream_upstream_t  *u;

  2053.     s = log->data;

  2055.     u = s->upstream;

  2057.     p = buf;

  2059.     if (u->peer.name) {
  2060.         p = ngx_snprintf(p, len, ", upstream: \"%V\"", u->peer.name);
  2061.         len -= p - buf;
  2062.     }

  2064.     pc = u->peer.connection;

  2066.     p = ngx_snprintf(p, len,
  2067.                      ", bytes from/to client:%O/%O"
  2068.                      ", bytes from/to upstream:%O/%O",
  2069.                      s->received, s->connection->sent,
  2070.                      u->received, pc ? pc->sent : 0);

  2072.     return p;
  2073. }


  2076. static void *
  2077. ‌ngx_stream_proxy_create_srv_conf(ngx_conf_t *cf)
  2078. {
  2079.     ngx_stream_proxy_srv_conf_t  *conf;

  2081.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_proxy_srv_conf_t));
  2082.     if (conf == NULL) {
  2083.         return NULL;
  2084.     }

  2086.     /*
  2087.      * set by ngx_pcalloc():
  2088.      *
  2089.      *     conf->ssl_protocols = 0;
  2090.      *     conf->ssl_ciphers = { 0, NULL };
  2091.      *     conf->ssl_trusted_certificate = { 0, NULL };
  2092.      *     conf->ssl_crl = { 0, NULL };
  2093.      *
  2094.      *     conf->ssl = NULL;
  2095.      *     conf->upstream = NULL;
  2096.      *     conf->upstream_value = NULL;
  2097.      */

  2099.     conf->connect_timeout = NGX_CONF_UNSET_MSEC;
  2100.     conf->timeout = NGX_CONF_UNSET_MSEC;
  2101.     conf->next_upstream_timeout = NGX_CONF_UNSET_MSEC;
  2102.     conf->buffer_size = NGX_CONF_UNSET_SIZE;
  2103.     conf->upload_rate = NGX_CONF_UNSET_PTR;
  2104.     conf->download_rate = NGX_CONF_UNSET_PTR;
  2105.     conf->requests = NGX_CONF_UNSET_UINT;
  2106.     conf->responses = NGX_CONF_UNSET_UINT;
  2107.     conf->next_upstream_tries = NGX_CONF_UNSET_UINT;
  2108.     conf->next_upstream = NGX_CONF_UNSET;
  2109.     conf->proxy_protocol = NGX_CONF_UNSET;
  2110.     conf->local = NGX_CONF_UNSET_PTR;
  2111.     conf->socket_keepalive = NGX_CONF_UNSET;
  2112.     conf->half_close = NGX_CONF_UNSET;

  2114. #if (NGX_STREAM_SSL)
  2115.     conf->ssl_enable = NGX_CONF_UNSET;
  2116.     conf->ssl_session_reuse = NGX_CONF_UNSET;
  2117.     conf->ssl_name = NGX_CONF_UNSET_PTR;
  2118.     conf->ssl_server_name = NGX_CONF_UNSET;
  2119.     conf->ssl_verify = NGX_CONF_UNSET;
  2120.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  2121.     conf->ssl_certificate = NGX_CONF_UNSET_PTR;
  2122.     conf->ssl_certificate_key = NGX_CONF_UNSET_PTR;
  2123.     conf->ssl_passwords = NGX_CONF_UNSET_PTR;
  2124.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  2125. #endif

  2127.     return conf;
  2128. }


  2131. static char *
  2132. ‌ngx_stream_proxy_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  2133. {
  2134.     ngx_stream_proxy_srv_conf_t *prev = parent;
  2135.     ngx_stream_proxy_srv_conf_t *conf = child;

  2137.     ngx_conf_merge_msec_value(conf->connect_timeout,
  2138.                               prev->connect_timeout, 60000);

  2140.     ngx_conf_merge_msec_value(conf->timeout,
  2141.                               prev->timeout, 10 * 60000);

  2143.     ngx_conf_merge_msec_value(conf->next_upstream_timeout,
  2144.                               prev->next_upstream_timeout, 0);

  2146.     ngx_conf_merge_size_value(conf->buffer_size,
  2147.                               prev->buffer_size, 16384);

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

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

  2153.     ngx_conf_merge_uint_value(conf->requests,
  2154.                               prev->requests, 0);

  2156.     ngx_conf_merge_uint_value(conf->responses,
  2157.                               prev->responses, NGX_MAX_INT32_VALUE);

  2159.     ngx_conf_merge_uint_value(conf->next_upstream_tries,
  2160.                               prev->next_upstream_tries, 0);

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

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

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

  2168.     ngx_conf_merge_value(conf->socket_keepalive,
  2169.                               prev->socket_keepalive, 0);

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

  2173. #if (NGX_STREAM_SSL)

  2175.     if (ngx_stream_proxy_merge_ssl(cf, conf, prev) != NGX_OK) {
  2176.         return NGX_CONF_ERROR;
  2177.     }

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

  2181.     ngx_conf_merge_value(conf->ssl_session_reuse,
  2182.                               prev->ssl_session_reuse, 1);

  2184.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  2185.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

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

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

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

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

  2195.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  2196.                               prev->ssl_verify_depth, 1);

  2198.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  2199.                               prev->ssl_trusted_certificate, "");

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

  2203.     ngx_conf_merge_ptr_value(conf->ssl_certificate,
  2204.                               prev->ssl_certificate, NULL);

  2206.     ngx_conf_merge_ptr_value(conf->ssl_certificate_key,
  2207.                               prev->ssl_certificate_key, NULL);

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

  2211.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  2212.                               prev->ssl_conf_commands, NULL);

  2214.     if (conf->ssl_enable && ngx_stream_proxy_set_ssl(cf, conf) != NGX_OK) {
  2215.         return NGX_CONF_ERROR;
  2216.     }

  2218. #endif

  2220.     return NGX_CONF_OK;
  2221. }


  2224. #if (NGX_STREAM_SSL)

  2226. static ngx_int_t
  2227. ‌ngx_stream_proxy_merge_ssl(ngx_conf_t *cf, ngx_stream_proxy_srv_conf_t *conf,
  2228.     ngx_stream_proxy_srv_conf_t *prev)
  2229. {
  2230.     ngx_uint_t  preserve;

  2232.     if (conf->ssl_protocols == 0
  2233.         && conf->ssl_ciphers.data == NULL
  2234.         && conf->ssl_certificate == NGX_CONF_UNSET_PTR
  2235.         && conf->ssl_certificate_key == NGX_CONF_UNSET_PTR
  2236.         && conf->ssl_passwords == NGX_CONF_UNSET_PTR
  2237.         && conf->ssl_verify == NGX_CONF_UNSET
  2238.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  2239.         && conf->ssl_trusted_certificate.data == NULL
  2240.         && conf->ssl_crl.data == NULL
  2241.         && conf->ssl_session_reuse == NGX_CONF_UNSET
  2242.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  2243.     {
  2244.         if (prev->ssl) {
  2245.             conf->ssl = prev->ssl;
  2246.             return NGX_OK;
  2247.         }

  2249.         preserve = 1;

  2251.     } else {
  2252.         preserve = 0;
  2253.     }

  2255.     conf->ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  2256.     if (conf->ssl == NULL) {
  2257.         return NGX_ERROR;
  2258.     }

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

  2262.     /*
  2263.      * special handling to preserve conf->ssl
  2264.      * in the "stream" section to inherit it to all servers
  2265.      */

  2267.     if (preserve) {
  2268.         prev->ssl = conf->ssl;
  2269.     }

  2271.     return NGX_OK;
  2272. }


  2275. static ngx_int_t
  2276. ‌ngx_stream_proxy_set_ssl(ngx_conf_t *cf, ngx_stream_proxy_srv_conf_t *pscf)
  2277. {
  2278.     ngx_pool_cleanup_t  *cln;

  2280.     if (pscf->ssl->ctx) {
  2281.         return NGX_OK;
  2282.     }

  2284.     if (ngx_ssl_create(pscf->ssl, pscf->ssl_protocols, NULL) != NGX_OK) {
  2285.         return NGX_ERROR;
  2286.     }

  2288.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  2289.     if (cln == NULL) {
  2290.         ngx_ssl_cleanup_ctx(pscf->ssl);
  2291.         return NGX_ERROR;
  2292.     }

  2294.     cln->handler = ngx_ssl_cleanup_ctx;
  2295.     cln->data = pscf->ssl;

  2297.     if (ngx_ssl_ciphers(cf, pscf->ssl, &pscf->ssl_ciphers, 0) != NGX_OK) {
  2298.         return NGX_ERROR;
  2299.     }

  2301.     if (pscf->ssl_certificate
  2302.         && pscf->ssl_certificate->value.len)
  2303.     {
  2304.         if (pscf->ssl_certificate_key == NULL) {
  2305.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2306.                           "no \"proxy_ssl_certificate_key\" is defined "
  2307.                           "for certificate \"%V\"",
  2308.                           &pscf->ssl_certificate->value);
  2309.             return NGX_ERROR;
  2310.         }

  2312.         if (pscf->ssl_certificate->lengths
  2313.             || pscf->ssl_certificate_key->lengths)
  2314.         {
  2315.             pscf->ssl_passwords =
  2316.                            ngx_ssl_preserve_passwords(cf, pscf->ssl_passwords);
  2317.             if (pscf->ssl_passwords == NULL) {
  2318.                 return NGX_ERROR;
  2319.             }

  2321.         } else {
  2322.             if (ngx_ssl_certificate(cf, pscf->ssl,
  2323.                                     &pscf->ssl_certificate->value,
  2324.                                     &pscf->ssl_certificate_key->value,
  2325.                                     pscf->ssl_passwords)
  2326.                 != NGX_OK)
  2327.             {
  2328.                 return NGX_ERROR;
  2329.             }
  2330.         }
  2331.     }

  2333.     if (pscf->ssl_verify) {
  2334.         if (pscf->ssl_trusted_certificate.len == 0) {
  2335.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2336.                       "no proxy_ssl_trusted_certificate for proxy_ssl_verify");
  2337.             return NGX_ERROR;
  2338.         }

  2340.         if (ngx_ssl_trusted_certificate(cf, pscf->ssl,
  2341.                                         &pscf->ssl_trusted_certificate,
  2342.                                         pscf->ssl_verify_depth)
  2343.             != NGX_OK)
  2344.         {
  2345.             return NGX_ERROR;
  2346.         }

  2348.         if (ngx_ssl_crl(cf, pscf->ssl, &pscf->ssl_crl) != NGX_OK) {
  2349.             return NGX_ERROR;
  2350.         }
  2351.     }

  2353.     if (ngx_ssl_client_session_cache(cf, pscf->ssl, pscf->ssl_session_reuse)
  2354.         != NGX_OK)
  2355.     {
  2356.         return NGX_ERROR;
  2357.     }

  2359.     if (ngx_ssl_conf_commands(cf, pscf->ssl, pscf->ssl_conf_commands)
  2360.         != NGX_OK)
  2361.     {
  2362.         return NGX_ERROR;
  2363.     }

  2365.     return NGX_OK;
  2366. }

  2368. #endif


  2371. static char *
  2372. ‌ngx_stream_proxy_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2373. {
  2374.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  2376.     ngx_url_t                            u;
  2377.     ngx_str_t                           *value, *url;
  2378.     ngx_stream_complex_value_t           cv;
  2379.     ngx_stream_core_srv_conf_t          *cscf;
  2380.     ngx_stream_compile_complex_value_t   ccv;

  2382.     if (pscf->upstream || pscf->upstream_value) {
  2383.         return "is duplicate";
  2384.     }

  2386.     cscf = ngx_stream_conf_get_module_srv_conf(cf, ngx_stream_core_module);

  2388.     cscf->handler = ngx_stream_proxy_handler;

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

  2392.     url = &value[1];

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

  2396.     ccv.cf = cf;
  2397.     ccv.value = url;
  2398.     ccv.complex_value = &cv;

  2400.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  2401.         return NGX_CONF_ERROR;
  2402.     }

  2404.     if (cv.lengths) {
  2405.         pscf->upstream_value = ngx_palloc(cf->pool,
  2406.                                           sizeof(ngx_stream_complex_value_t));
  2407.         if (pscf->upstream_value == NULL) {
  2408.             return NGX_CONF_ERROR;
  2409.         }

  2411.         *pscf->upstream_value = cv;

  2413.         return NGX_CONF_OK;
  2414.     }

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

  2418.     u.url = *url;
  2419.     u.no_resolve = 1;

  2421.     pscf->upstream = ngx_stream_upstream_add(cf, &u, 0);
  2422.     if (pscf->upstream == NULL) {
  2423.         return NGX_CONF_ERROR;
  2424.     }

  2426.     return NGX_CONF_OK;
  2427. }


  2430. static char *
  2431. ‌ngx_stream_proxy_bind(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2432. {
  2433.     ngx_stream_proxy_srv_conf_t *pscf = conf;

  2435.     ngx_int_t                            rc;
  2436.     ngx_str_t                           *value;
  2437.     ngx_stream_complex_value_t           cv;
  2438.     ngx_stream_upstream_local_t         *local;
  2439.     ngx_stream_compile_complex_value_t   ccv;

  2441.     if (pscf->local != NGX_CONF_UNSET_PTR) {
  2442.         return "is duplicate";
  2443.     }

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

  2447.     if (cf->args->nelts == 2 && ngx_strcmp(value[1].data, "off") == 0) {
  2448.         pscf->local = NULL;
  2449.         return NGX_CONF_OK;
  2450.     }

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

  2454.     ccv.cf = cf;
  2455.     ccv.value = &value[1];
  2456.     ccv.complex_value = &cv;

  2458.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  2459.         return NGX_CONF_ERROR;
  2460.     }

  2462.     local = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_local_t));
  2463.     if (local == NULL) {
  2464.         return NGX_CONF_ERROR;
  2465.     }

  2467.     pscf->local = local;

  2469.     if (cv.lengths) {
  2470.         local->value = ngx_palloc(cf->pool, sizeof(ngx_stream_complex_value_t));
  2471.         if (local->value == NULL) {
  2472.             return NGX_CONF_ERROR;
  2473.         }

  2475.         *local->value = cv;

  2477.     } else {
  2478.         local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
  2479.         if (local->addr == NULL) {
  2480.             return NGX_CONF_ERROR;
  2481.         }

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

  2486.         switch (rc) {
  2487.         case NGX_OK:
  2488.             local->addr->name = value[1];
  2489.             break;

  2491.         case NGX_DECLINED:
  2492.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2493.                                "invalid address \"%V\"", &value[1]);
  2494.             /* fall through */

  2496.         default:
  2497.             return NGX_CONF_ERROR;
  2498.         }
  2499.     }

  2501.     if (cf->args->nelts > 2) {
  2502.         if (ngx_strcmp(value[2].data, "transparent") == 0) {
  2503. #if (NGX_HAVE_TRANSPARENT_PROXY)
  2504.             ngx_core_conf_t  *ccf;

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

  2509.             ccf->transparent = 1;
  2510.             local->transparent = 1;
  2511. #else
  2512.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2513.                                "transparent proxying is not supported "
  2514.                                "on this platform, ignored");
  2515. #endif
  2516.         } else {
  2517.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2518.                                "invalid parameter \"%V\"", &value[2]);
  2519.             return NGX_CONF_ERROR;
  2520.         }
  2521.     }

  2523.     return NGX_CONF_OK;
  2524. }

One Level Up Top Level