One Level Up Top Level

src/stream/ngx_stream_pass_module.c - nginx source code

Global variables defined

Data types defined

Functions defined

Macros 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. ‌#define NGX_STREAM_PASS_MAX_PASSES  10


  16. ‌typedef struct {
  17.     ngx_addr_t                  *addr;
  18.     ngx_stream_complex_value_t  *addr_value;
  19. ‌} ngx_stream_pass_srv_conf_t;


  22. static void ngx_stream_pass_handler(ngx_stream_session_t *s);
  23. static ngx_int_t ngx_stream_pass_check_cycle(ngx_connection_t *c);
  24. static void ngx_stream_pass_cleanup(void *data);
  25. static ngx_int_t ngx_stream_pass_match(ngx_listening_t *ls, ngx_addr_t *addr);
  26. static void *ngx_stream_pass_create_srv_conf(ngx_conf_t *cf);
  27. static char *ngx_stream_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);


  30. ‌static ngx_command_t  ngx_stream_pass_commands[] = {

  32.     { ngx_string("pass"),
  33.       NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  34.       ngx_stream_pass,
  35.       NGX_STREAM_SRV_CONF_OFFSET,
  36.       0,
  37.       NULL },

  39.       ngx_null_command
  40. };


  43. ‌static ngx_stream_module_t  ngx_stream_pass_module_ctx = {
  44.     NULL,                                  /* preconfiguration */
  45.     NULL,                                  /* postconfiguration */

  47.     NULL,                                  /* create main configuration */
  48.     NULL,                                  /* init main configuration */

  50.     ngx_stream_pass_create_srv_conf,       /* create server configuration */
  51.     NULL                                   /* merge server configuration */
  52. };


  55. ‌ngx_module_t  ngx_stream_pass_module = {
  56.     NGX_MODULE_V1,
  57.     &ngx_stream_pass_module_ctx,           /* module context */
  58.     ngx_stream_pass_commands,              /* module directives */
  59.     NGX_STREAM_MODULE,                     /* module type */
  60.     NULL,                                  /* init master */
  61.     NULL,                                  /* init module */
  62.     NULL,                                  /* init process */
  63.     NULL,                                  /* init thread */
  64.     NULL,                                  /* exit thread */
  65.     NULL,                                  /* exit process */
  66.     NULL,                                  /* exit master */
  67.     NGX_MODULE_V1_PADDING
  68. };


  71. static void
  72. ‌ngx_stream_pass_handler(ngx_stream_session_t *s)
  73. {
  74.     ngx_url_t                    u;
  75.     ngx_str_t                    url;
  76.     ngx_addr_t                  *addr;
  77.     ngx_uint_t                   i;
  78.     ngx_listening_t             *ls;
  79.     ngx_connection_t            *c;
  80.     ngx_stream_pass_srv_conf_t  *pscf;

  82.     c = s->connection;

  84.     c->log->action = "passing connection to port";

  86.     if (c->type == SOCK_DGRAM) {
  87.         ngx_log_error(NGX_LOG_ERR, c->log, 0, "cannot pass udp connection");
  88.         goto failed;
  89.     }

  91.     if (c->buffer && c->buffer->pos != c->buffer->last) {
  92.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  93.                       "cannot pass connection with preread data");
  94.         goto failed;
  95.     }

  97.     pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_pass_module);

  99.     addr = pscf->addr;

  101.     if (addr == NULL) {
  102.         if (ngx_stream_complex_value(s, pscf->addr_value, &url) != NGX_OK) {
  103.             goto failed;
  104.         }

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

  108.         u.url = url;
  109.         u.no_resolve = 1;

  111.         if (ngx_parse_url(c->pool, &u) != NGX_OK) {
  112.             if (u.err) {
  113.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  114.                               "%s in pass \"%V\"", u.err, &u.url);
  115.             }

  117.             goto failed;
  118.         }

  120.         if (u.naddrs == 0) {
  121.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  122.                           "no addresses in pass \"%V\"", &u.url);
  123.             goto failed;
  124.         }

  126.         if (u.no_port) {
  127.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  128.                           "no port in pass \"%V\"", &u.url);
  129.             goto failed;
  130.         }

  132.         addr = &u.addrs[0];
  133.     }

  135.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  136.                    "stream pass addr: \"%V\"", &addr->name);

  138.     if (ngx_stream_pass_check_cycle(c) != NGX_OK) {
  139.         goto failed;
  140.     }

  142.     ls = ngx_cycle->listening.elts;

  144.     for (i = 0; i < ngx_cycle->listening.nelts; i++) {

  146.         if (ngx_stream_pass_match(&ls[i], addr) != NGX_OK) {
  147.             continue;
  148.         }

  150.         c->listening = &ls[i];

  152.         c->data = NULL;
  153.         c->buffer = NULL;

  155.         *c->log = c->listening->log;
  156.         c->log->handler = NULL;
  157.         c->log->data = NULL;

  159.         c->local_sockaddr = addr->sockaddr;
  160.         c->local_socklen = addr->socklen;

  162.         c->listening->handler(c);

  164.         return;
  165.     }

  167.     ngx_log_error(NGX_LOG_ERR, c->log, 0,
  168.                   "port not found for \"%V\"", &addr->name);

  170.     ngx_stream_finalize_session(s, NGX_STREAM_OK);

  172.     return;

  174. failed:

  176.     ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  177. }


  180. static ngx_int_t
  181. ‌ngx_stream_pass_check_cycle(ngx_connection_t *c)
  182. {
  183.     ngx_uint_t          *num;
  184.     ngx_pool_cleanup_t  *cln;

  186.     for (cln = c->pool->cleanup; cln; cln = cln->next) {
  187.         if (cln->handler != ngx_stream_pass_cleanup) {
  188.             continue;
  189.         }

  191.         num = cln->data;

  193.         if (++(*num) > NGX_STREAM_PASS_MAX_PASSES) {
  194.             ngx_log_error(NGX_LOG_ERR, c->log, 0, "stream pass cycle");
  195.             return NGX_ERROR;
  196.         }

  198.         return NGX_OK;
  199.     }

  201.     cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_uint_t));
  202.     if (cln == NULL) {
  203.         return NGX_ERROR;
  204.     }

  206.     cln->handler = ngx_stream_pass_cleanup;

  208.     num = cln->data;
  209.     *num = 1;

  211.     return NGX_OK;
  212. }


  215. static void
  216. ‌ngx_stream_pass_cleanup(void *data)
  217. {
  218.     return;
  219. }


  222. static ngx_int_t
  223. ‌ngx_stream_pass_match(ngx_listening_t *ls, ngx_addr_t *addr)
  224. {
  225.     if (ls->type == SOCK_DGRAM) {
  226.         return NGX_DECLINED;
  227.     }

  229.     if (!ls->wildcard) {
  230.         return ngx_cmp_sockaddr(ls->sockaddr, ls->socklen,
  231.                                 addr->sockaddr, addr->socklen, 1);
  232.     }

  234.     if (ls->sockaddr->sa_family == addr->sockaddr->sa_family
  235.         && ngx_inet_get_port(ls->sockaddr) == ngx_inet_get_port(addr->sockaddr))
  236.     {
  237.         return NGX_OK;
  238.     }

  240.     return NGX_DECLINED;
  241. }


  244. static void *
  245. ‌ngx_stream_pass_create_srv_conf(ngx_conf_t *cf)
  246. {
  247.     ngx_stream_pass_srv_conf_t  *conf;

  249.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_pass_srv_conf_t));
  250.     if (conf == NULL) {
  251.         return NULL;
  252.     }

  254.     /*
  255.      * set by ngx_pcalloc():
  256.      *
  257.      *     conf->addr = NULL;
  258.      *     conf->addr_value = NULL;
  259.      */

  261.     return conf;
  262. }


  265. static char *
  266. ‌ngx_stream_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  267. {
  268.     ngx_stream_pass_srv_conf_t *pscf = conf;

  270.     ngx_url_t                            u;
  271.     ngx_str_t                           *value, *url;
  272.     ngx_stream_complex_value_t           cv;
  273.     ngx_stream_core_srv_conf_t          *cscf;
  274.     ngx_stream_compile_complex_value_t   ccv;

  276.     if (pscf->addr || pscf->addr_value) {
  277.         return "is duplicate";
  278.     }

  280.     cscf = ngx_stream_conf_get_module_srv_conf(cf, ngx_stream_core_module);

  282.     cscf->handler = ngx_stream_pass_handler;

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

  286.     url = &value[1];

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

  290.     ccv.cf = cf;
  291.     ccv.value = url;
  292.     ccv.complex_value = &cv;

  294.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  295.         return NGX_CONF_ERROR;
  296.     }

  298.     if (cv.lengths) {
  299.         pscf->addr_value = ngx_palloc(cf->pool,
  300.                                       sizeof(ngx_stream_complex_value_t));
  301.         if (pscf->addr_value == NULL) {
  302.             return NGX_CONF_ERROR;
  303.         }

  305.         *pscf->addr_value = cv;

  307.         return NGX_CONF_OK;
  308.     }

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

  312.     u.url = *url;
  313.     u.no_resolve = 1;

  315.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  316.         if (u.err) {
  317.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  318.                                "%s in \"%V\" of the \"pass\" directive",
  319.                                u.err, &u.url);
  320.         }

  322.         return NGX_CONF_ERROR;
  323.     }

  325.     if (u.naddrs == 0) {
  326.         return "has no addresses";
  327.     }

  329.     if (u.no_port) {
  330.         return "has no port";
  331.     }

  333.     pscf->addr = &u.addrs[0];

  335.     return NGX_CONF_OK;
  336. }

One Level Up Top Level