One Level Up Top Level

src/stream/ngx_stream.c - nginx source code

Global variables 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_event.h>
  11. #include <ngx_stream.h>


  14. static char *ngx_stream_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  15. static ngx_int_t ngx_stream_init_phases(ngx_conf_t *cf,
  16.     ngx_stream_core_main_conf_t *cmcf);
  17. static ngx_int_t ngx_stream_init_phase_handlers(ngx_conf_t *cf,
  18.     ngx_stream_core_main_conf_t *cmcf);

  20. static ngx_int_t ngx_stream_add_addresses(ngx_conf_t *cf,
  21.     ngx_stream_core_srv_conf_t *cscf, ngx_stream_conf_port_t *port,
  22.     ngx_stream_listen_opt_t *lsopt);
  23. static ngx_int_t ngx_stream_add_address(ngx_conf_t *cf,
  24.     ngx_stream_core_srv_conf_t *cscf, ngx_stream_conf_port_t *port,
  25.     ngx_stream_listen_opt_t *lsopt);
  26. static ngx_int_t ngx_stream_add_server(ngx_conf_t *cf,
  27.     ngx_stream_core_srv_conf_t *cscf, ngx_stream_conf_addr_t *addr);

  29. static ngx_int_t ngx_stream_optimize_servers(ngx_conf_t *cf,
  30.     ngx_stream_core_main_conf_t *cmcf, ngx_array_t *ports);
  31. static ngx_int_t ngx_stream_server_names(ngx_conf_t *cf,
  32.     ngx_stream_core_main_conf_t *cmcf, ngx_stream_conf_addr_t *addr);
  33. static ngx_int_t ngx_stream_cmp_conf_addrs(const void *one, const void *two);
  34. static int ngx_libc_cdecl ngx_stream_cmp_dns_wildcards(const void *one,
  35.     const void *two);

  37. static ngx_int_t ngx_stream_init_listening(ngx_conf_t *cf,
  38.     ngx_stream_conf_port_t *port);
  39. static ngx_listening_t *ngx_stream_add_listening(ngx_conf_t *cf,
  40.     ngx_stream_conf_addr_t *addr);
  41. static ngx_int_t ngx_stream_add_addrs(ngx_conf_t *cf, ngx_stream_port_t *stport,
  42.     ngx_stream_conf_addr_t *addr);
  43. #if (NGX_HAVE_INET6)
  44. static ngx_int_t ngx_stream_add_addrs6(ngx_conf_t *cf,
  45.     ngx_stream_port_t *stport, ngx_stream_conf_addr_t *addr);
  46. #endif


  49. ‌ngx_uint_t  ngx_stream_max_module;


  52. ‌ngx_stream_filter_pt  ngx_stream_top_filter;


  55. ‌static ngx_command_t  ngx_stream_commands[] = {

  57.     { ngx_string("stream"),
  58.       NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  59.       ngx_stream_block,
  60.       0,
  61.       0,
  62.       NULL },

  64.       ngx_null_command
  65. };


  68. ‌static ngx_core_module_t  ngx_stream_module_ctx = {
  69.     ngx_string("stream"),
  70.     NULL,
  71.     NULL
  72. };


  75. ‌ngx_module_t  ngx_stream_module = {
  76.     NGX_MODULE_V1,
  77.     &ngx_stream_module_ctx,                /* module context */
  78.     ngx_stream_commands,                   /* module directives */
  79.     NGX_CORE_MODULE,                       /* module type */
  80.     NULL,                                  /* init master */
  81.     NULL,                                  /* init module */
  82.     NULL,                                  /* init process */
  83.     NULL,                                  /* init thread */
  84.     NULL,                                  /* exit thread */
  85.     NULL,                                  /* exit process */
  86.     NULL,                                  /* exit master */
  87.     NGX_MODULE_V1_PADDING
  88. };


  91. static char *
  92. ‌ngx_stream_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  93. {
  94.     char                          *rv;
  95.     ngx_uint_t                     mi, m, s;
  96.     ngx_conf_t                     pcf;
  97.     ngx_stream_module_t           *module;
  98.     ngx_stream_conf_ctx_t         *ctx;
  99.     ngx_stream_core_srv_conf_t   **cscfp;
  100.     ngx_stream_core_main_conf_t   *cmcf;

  102.     if (*(ngx_stream_conf_ctx_t **) conf) {
  103.         return "is duplicate";
  104.     }

  106.     /* the main stream context */

  108.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_stream_conf_ctx_t));
  109.     if (ctx == NULL) {
  110.         return NGX_CONF_ERROR;
  111.     }

  113.     *(ngx_stream_conf_ctx_t **) conf = ctx;

  115.     /* count the number of the stream modules and set up their indices */

  117.     ngx_stream_max_module = ngx_count_modules(cf->cycle, NGX_STREAM_MODULE);


  120.     /* the stream main_conf context, it's the same in the all stream contexts */

  122.     ctx->main_conf = ngx_pcalloc(cf->pool,
  123.                                  sizeof(void *) * ngx_stream_max_module);
  124.     if (ctx->main_conf == NULL) {
  125.         return NGX_CONF_ERROR;
  126.     }


  129.     /*
  130.      * the stream null srv_conf context, it is used to merge
  131.      * the server{}s' srv_conf's
  132.      */

  134.     ctx->srv_conf = ngx_pcalloc(cf->pool,
  135.                                 sizeof(void *) * ngx_stream_max_module);
  136.     if (ctx->srv_conf == NULL) {
  137.         return NGX_CONF_ERROR;
  138.     }


  141.     /*
  142.      * create the main_conf's and the null srv_conf's of the all stream modules
  143.      */

  145.     for (m = 0; cf->cycle->modules[m]; m++) {
  146.         if (cf->cycle->modules[m]->type != NGX_STREAM_MODULE) {
  147.             continue;
  148.         }

  150.         module = cf->cycle->modules[m]->ctx;
  151.         mi = cf->cycle->modules[m]->ctx_index;

  153.         if (module->create_main_conf) {
  154.             ctx->main_conf[mi] = module->create_main_conf(cf);
  155.             if (ctx->main_conf[mi] == NULL) {
  156.                 return NGX_CONF_ERROR;
  157.             }
  158.         }

  160.         if (module->create_srv_conf) {
  161.             ctx->srv_conf[mi] = module->create_srv_conf(cf);
  162.             if (ctx->srv_conf[mi] == NULL) {
  163.                 return NGX_CONF_ERROR;
  164.             }
  165.         }
  166.     }


  169.     pcf = *cf;
  170.     cf->ctx = ctx;

  172.     for (m = 0; cf->cycle->modules[m]; m++) {
  173.         if (cf->cycle->modules[m]->type != NGX_STREAM_MODULE) {
  174.             continue;
  175.         }

  177.         module = cf->cycle->modules[m]->ctx;

  179.         if (module->preconfiguration) {
  180.             if (module->preconfiguration(cf) != NGX_OK) {
  181.                 return NGX_CONF_ERROR;
  182.             }
  183.         }
  184.     }


  187.     /* parse inside the stream{} block */

  189.     cf->module_type = NGX_STREAM_MODULE;
  190.     cf->cmd_type = NGX_STREAM_MAIN_CONF;
  191.     rv = ngx_conf_parse(cf, NULL);

  193.     if (rv != NGX_CONF_OK) {
  194.         *cf = pcf;
  195.         return rv;
  196.     }


  199.     /* init stream{} main_conf's, merge the server{}s' srv_conf's */

  201.     cmcf = ctx->main_conf[ngx_stream_core_module.ctx_index];
  202.     cscfp = cmcf->servers.elts;

  204.     for (m = 0; cf->cycle->modules[m]; m++) {
  205.         if (cf->cycle->modules[m]->type != NGX_STREAM_MODULE) {
  206.             continue;
  207.         }

  209.         module = cf->cycle->modules[m]->ctx;
  210.         mi = cf->cycle->modules[m]->ctx_index;

  212.         /* init stream{} main_conf's */

  214.         cf->ctx = ctx;

  216.         if (module->init_main_conf) {
  217.             rv = module->init_main_conf(cf, ctx->main_conf[mi]);
  218.             if (rv != NGX_CONF_OK) {
  219.                 *cf = pcf;
  220.                 return rv;
  221.             }
  222.         }

  224.         for (s = 0; s < cmcf->servers.nelts; s++) {

  226.             /* merge the server{}s' srv_conf's */

  228.             cf->ctx = cscfp[s]->ctx;

  230.             if (module->merge_srv_conf) {
  231.                 rv = module->merge_srv_conf(cf,
  232.                                             ctx->srv_conf[mi],
  233.                                             cscfp[s]->ctx->srv_conf[mi]);
  234.                 if (rv != NGX_CONF_OK) {
  235.                     *cf = pcf;
  236.                     return rv;
  237.                 }
  238.             }
  239.         }
  240.     }

  242.     if (ngx_stream_init_phases(cf, cmcf) != NGX_OK) {
  243.         return NGX_CONF_ERROR;
  244.     }

  246.     for (m = 0; cf->cycle->modules[m]; m++) {
  247.         if (cf->cycle->modules[m]->type != NGX_STREAM_MODULE) {
  248.             continue;
  249.         }

  251.         module = cf->cycle->modules[m]->ctx;

  253.         if (module->postconfiguration) {
  254.             if (module->postconfiguration(cf) != NGX_OK) {
  255.                 return NGX_CONF_ERROR;
  256.             }
  257.         }
  258.     }

  260.     if (ngx_stream_variables_init_vars(cf) != NGX_OK) {
  261.         return NGX_CONF_ERROR;
  262.     }

  264.     *cf = pcf;

  266.     if (ngx_stream_init_phase_handlers(cf, cmcf) != NGX_OK) {
  267.         return NGX_CONF_ERROR;
  268.     }

  270.     /* optimize the lists of ports, addresses and server names */

  272.     if (ngx_stream_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
  273.         return NGX_CONF_ERROR;
  274.     }

  276.     return NGX_CONF_OK;
  277. }


  280. static ngx_int_t
  281. ‌ngx_stream_init_phases(ngx_conf_t *cf, ngx_stream_core_main_conf_t *cmcf)
  282. {
  283.     if (ngx_array_init(&cmcf->phases[NGX_STREAM_POST_ACCEPT_PHASE].handlers,
  284.                        cf->pool, 1, sizeof(ngx_stream_handler_pt))
  285.         != NGX_OK)
  286.     {
  287.         return NGX_ERROR;
  288.     }

  290.     if (ngx_array_init(&cmcf->phases[NGX_STREAM_PREACCESS_PHASE].handlers,
  291.                        cf->pool, 1, sizeof(ngx_stream_handler_pt))
  292.         != NGX_OK)
  293.     {
  294.         return NGX_ERROR;
  295.     }

  297.     if (ngx_array_init(&cmcf->phases[NGX_STREAM_ACCESS_PHASE].handlers,
  298.                        cf->pool, 1, sizeof(ngx_stream_handler_pt))
  299.         != NGX_OK)
  300.     {
  301.         return NGX_ERROR;
  302.     }

  304.     if (ngx_array_init(&cmcf->phases[NGX_STREAM_SSL_PHASE].handlers,
  305.                        cf->pool, 1, sizeof(ngx_stream_handler_pt))
  306.         != NGX_OK)
  307.     {
  308.         return NGX_ERROR;
  309.     }

  311.     if (ngx_array_init(&cmcf->phases[NGX_STREAM_PREREAD_PHASE].handlers,
  312.                        cf->pool, 1, sizeof(ngx_stream_handler_pt))
  313.         != NGX_OK)
  314.     {
  315.         return NGX_ERROR;
  316.     }

  318.     if (ngx_array_init(&cmcf->phases[NGX_STREAM_LOG_PHASE].handlers,
  319.                        cf->pool, 1, sizeof(ngx_stream_handler_pt))
  320.         != NGX_OK)
  321.     {
  322.         return NGX_ERROR;
  323.     }

  325.     return NGX_OK;
  326. }


  329. static ngx_int_t
  330. ‌ngx_stream_init_phase_handlers(ngx_conf_t *cf,
  331.     ngx_stream_core_main_conf_t *cmcf)
  332. {
  333.     ngx_int_t                     j;
  334.     ngx_uint_t                    i, n;
  335.     ngx_stream_handler_pt        *h;
  336.     ngx_stream_phase_handler_t   *ph;
  337.     ngx_stream_phase_handler_pt   checker;

  339.     n = 1 /* content phase */;

  341.     for (i = 0; i < NGX_STREAM_LOG_PHASE; i++) {
  342.         n += cmcf->phases[i].handlers.nelts;
  343.     }

  345.     ph = ngx_pcalloc(cf->pool,
  346.                      n * sizeof(ngx_stream_phase_handler_t) + sizeof(void *));
  347.     if (ph == NULL) {
  348.         return NGX_ERROR;
  349.     }

  351.     cmcf->phase_engine.handlers = ph;
  352.     n = 0;

  354.     for (i = 0; i < NGX_STREAM_LOG_PHASE; i++) {
  355.         h = cmcf->phases[i].handlers.elts;

  357.         switch (i) {

  359.         case NGX_STREAM_PREREAD_PHASE:
  360.             checker = ngx_stream_core_preread_phase;
  361.             break;

  363.         case NGX_STREAM_CONTENT_PHASE:
  364.             ph->checker = ngx_stream_core_content_phase;
  365.             n++;
  366.             ph++;

  368.             continue;

  370.         default:
  371.             checker = ngx_stream_core_generic_phase;
  372.         }

  374.         n += cmcf->phases[i].handlers.nelts;

  376.         for (j = cmcf->phases[i].handlers.nelts - 1; j >= 0; j--) {
  377.             ph->checker = checker;
  378.             ph->handler = h[j];
  379.             ph->next = n;
  380.             ph++;
  381.         }
  382.     }

  384.     return NGX_OK;
  385. }


  388. ngx_int_t
  389. ‌ngx_stream_add_listen(ngx_conf_t *cf, ngx_stream_core_srv_conf_t *cscf,
  390.     ngx_stream_listen_opt_t *lsopt)
  391. {
  392.     in_port_t                     p;
  393.     ngx_uint_t                    i;
  394.     struct sockaddr              *sa;
  395.     ngx_stream_conf_port_t       *port;
  396.     ngx_stream_core_main_conf_t  *cmcf;

  398.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  400.     if (cmcf->ports == NULL) {
  401.         cmcf->ports = ngx_array_create(cf->temp_pool, 2,
  402.                                        sizeof(ngx_stream_conf_port_t));
  403.         if (cmcf->ports == NULL) {
  404.             return NGX_ERROR;
  405.         }
  406.     }

  408.     sa = lsopt->sockaddr;
  409.     p = ngx_inet_get_port(sa);

  411.     port = cmcf->ports->elts;
  412.     for (i = 0; i < cmcf->ports->nelts; i++) {

  414.         if (p != port[i].port
  415.             || lsopt->type != port[i].type
  416.             || sa->sa_family != port[i].family)
  417.         {
  418.             continue;
  419.         }

  421.         /* a port is already in the port list */

  423.         return ngx_stream_add_addresses(cf, cscf, &port[i], lsopt);
  424.     }

  426.     /* add a port to the port list */

  428.     port = ngx_array_push(cmcf->ports);
  429.     if (port == NULL) {
  430.         return NGX_ERROR;
  431.     }

  433.     port->family = sa->sa_family;
  434.     port->type = lsopt->type;
  435.     port->port = p;
  436.     port->addrs.elts = NULL;

  438.     return ngx_stream_add_address(cf, cscf, port, lsopt);
  439. }


  442. static ngx_int_t
  443. ‌ngx_stream_add_addresses(ngx_conf_t *cf, ngx_stream_core_srv_conf_t *cscf,
  444.     ngx_stream_conf_port_t *port, ngx_stream_listen_opt_t *lsopt)
  445. {
  446.     ngx_uint_t               i, default_server, proxy_protocol,
  447.                              protocols, protocols_prev;
  448.     ngx_stream_conf_addr_t  *addr;
  449. #if (NGX_STREAM_SSL)
  450.     ngx_uint_t               ssl;
  451. #endif

  453.     /*
  454.      * we cannot compare whole sockaddr struct's as kernel
  455.      * may fill some fields in inherited sockaddr struct's
  456.      */

  458.     addr = port->addrs.elts;

  460.     for (i = 0; i < port->addrs.nelts; i++) {

  462.         if (ngx_cmp_sockaddr(lsopt->sockaddr, lsopt->socklen,
  463.                              addr[i].opt.sockaddr,
  464.                              addr[i].opt.socklen, 0)
  465.             != NGX_OK)
  466.         {
  467.             continue;
  468.         }

  470.         /* the address is already in the address list */

  472.         if (ngx_stream_add_server(cf, cscf, &addr[i]) != NGX_OK) {
  473.             return NGX_ERROR;
  474.         }

  476.         /* preserve default_server bit during listen options overwriting */
  477.         default_server = addr[i].opt.default_server;

  479.         proxy_protocol = lsopt->proxy_protocol || addr[i].opt.proxy_protocol;
  480.         protocols = lsopt->proxy_protocol;
  481.         protocols_prev = addr[i].opt.proxy_protocol;

  483. #if (NGX_STREAM_SSL)
  484.         ssl = lsopt->ssl || addr[i].opt.ssl;
  485.         protocols |= lsopt->ssl << 1;
  486.         protocols_prev |= addr[i].opt.ssl << 1;
  487. #endif

  489.         if (lsopt->set) {

  491.             if (addr[i].opt.set) {
  492.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  493.                                    "duplicate listen options for %V",
  494.                                    &addr[i].opt.addr_text);
  495.                 return NGX_ERROR;
  496.             }

  498.             addr[i].opt = *lsopt;
  499.         }

  501.         /* check the duplicate "default" server for this address:port */

  503.         if (lsopt->default_server) {

  505.             if (default_server) {
  506.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  507.                                    "a duplicate default server for %V",
  508.                                    &addr[i].opt.addr_text);
  509.                 return NGX_ERROR;
  510.             }

  512.             default_server = 1;
  513.             addr[i].default_server = cscf;
  514.         }

  516.         /* check for conflicting protocol options */

  518.         if ((protocols | protocols_prev) != protocols_prev) {

  520.             /* options added */

  522.             if ((addr[i].opt.set && !lsopt->set)
  523.                 || addr[i].protocols_changed
  524.                 || (protocols | protocols_prev) != protocols)
  525.             {
  526.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  527.                                    "protocol options redefined for %V",
  528.                                    &addr[i].opt.addr_text);
  529.             }

  531.             addr[i].protocols = protocols_prev;
  532.             addr[i].protocols_set = 1;
  533.             addr[i].protocols_changed = 1;

  535.         } else if ((protocols_prev | protocols) != protocols) {

  537.             /* options removed */

  539.             if (lsopt->set
  540.                 || (addr[i].protocols_set && protocols != addr[i].protocols))
  541.             {
  542.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  543.                                    "protocol options redefined for %V",
  544.                                    &addr[i].opt.addr_text);
  545.             }

  547.             addr[i].protocols = protocols;
  548.             addr[i].protocols_set = 1;
  549.             addr[i].protocols_changed = 1;

  551.         } else {

  553.             /* the same options */

  555.             if ((lsopt->set && addr[i].protocols_changed)
  556.                 || (addr[i].protocols_set && protocols != addr[i].protocols))
  557.             {
  558.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  559.                                    "protocol options redefined for %V",
  560.                                    &addr[i].opt.addr_text);
  561.             }

  563.             addr[i].protocols = protocols;
  564.             addr[i].protocols_set = 1;
  565.         }

  567.         addr[i].opt.default_server = default_server;
  568.         addr[i].opt.proxy_protocol = proxy_protocol;
  569. #if (NGX_STREAM_SSL)
  570.         addr[i].opt.ssl = ssl;
  571. #endif

  573.         return NGX_OK;
  574.     }

  576.     /* add the address to the addresses list that bound to this port */

  578.     return ngx_stream_add_address(cf, cscf, port, lsopt);
  579. }


  582. /*
  583. * add the server address, the server names and the server core module
  584. * configurations to the port list
  585. */

  587. static ngx_int_t
  588. ‌ngx_stream_add_address(ngx_conf_t *cf, ngx_stream_core_srv_conf_t *cscf,
  589.     ngx_stream_conf_port_t *port, ngx_stream_listen_opt_t *lsopt)
  590. {
  591.     ngx_stream_conf_addr_t  *addr;

  593.     if (port->addrs.elts == NULL) {
  594.         if (ngx_array_init(&port->addrs, cf->temp_pool, 4,
  595.                            sizeof(ngx_stream_conf_addr_t))
  596.             != NGX_OK)
  597.         {
  598.             return NGX_ERROR;
  599.         }
  600.     }

  602.     addr = ngx_array_push(&port->addrs);
  603.     if (addr == NULL) {
  604.         return NGX_ERROR;
  605.     }

  607.     addr->opt = *lsopt;
  608.     addr->protocols = 0;
  609.     addr->protocols_set = 0;
  610.     addr->protocols_changed = 0;
  611.     addr->hash.buckets = NULL;
  612.     addr->hash.size = 0;
  613.     addr->wc_head = NULL;
  614.     addr->wc_tail = NULL;
  615. #if (NGX_PCRE)
  616.     addr->nregex = 0;
  617.     addr->regex = NULL;
  618. #endif
  619.     addr->default_server = cscf;
  620.     addr->servers.elts = NULL;

  622.     return ngx_stream_add_server(cf, cscf, addr);
  623. }


  626. /* add the server core module configuration to the address:port */

  628. static ngx_int_t
  629. ‌ngx_stream_add_server(ngx_conf_t *cf, ngx_stream_core_srv_conf_t *cscf,
  630.     ngx_stream_conf_addr_t *addr)
  631. {
  632.     ngx_uint_t                    i;
  633.     ngx_stream_core_srv_conf_t  **server;

  635.     if (addr->servers.elts == NULL) {
  636.         if (ngx_array_init(&addr->servers, cf->temp_pool, 4,
  637.                            sizeof(ngx_stream_core_srv_conf_t *))
  638.             != NGX_OK)
  639.         {
  640.             return NGX_ERROR;
  641.         }

  643.     } else {
  644.         server = addr->servers.elts;
  645.         for (i = 0; i < addr->servers.nelts; i++) {
  646.             if (server[i] == cscf) {
  647.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  648.                                    "a duplicate listen %V",
  649.                                    &addr->opt.addr_text);
  650.                 return NGX_ERROR;
  651.             }
  652.         }
  653.     }

  655.     server = ngx_array_push(&addr->servers);
  656.     if (server == NULL) {
  657.         return NGX_ERROR;
  658.     }

  660.     *server = cscf;

  662.     return NGX_OK;
  663. }


  666. static ngx_int_t
  667. ‌ngx_stream_optimize_servers(ngx_conf_t *cf, ngx_stream_core_main_conf_t *cmcf,
  668.     ngx_array_t *ports)
  669. {
  670.     ngx_uint_t               p, a;
  671.     ngx_stream_conf_port_t  *port;
  672.     ngx_stream_conf_addr_t  *addr;

  674.     if (ports == NULL) {
  675.         return NGX_OK;
  676.     }

  678.     port = ports->elts;
  679.     for (p = 0; p < ports->nelts; p++) {

  681.         ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts,
  682.                  sizeof(ngx_stream_conf_addr_t), ngx_stream_cmp_conf_addrs);

  684.         /*
  685.          * check whether all name-based servers have the same
  686.          * configuration as a default server for given address:port
  687.          */

  689.         addr = port[p].addrs.elts;
  690.         for (a = 0; a < port[p].addrs.nelts; a++) {

  692.             if (addr[a].servers.nelts > 1
  693. #if (NGX_PCRE)
  694.                 || addr[a].default_server->captures
  695. #endif
  696.                )
  697.             {
  698.                 if (ngx_stream_server_names(cf, cmcf, &addr[a]) != NGX_OK) {
  699.                     return NGX_ERROR;
  700.                 }
  701.             }
  702.         }

  704.         if (ngx_stream_init_listening(cf, &port[p]) != NGX_OK) {
  705.             return NGX_ERROR;
  706.         }
  707.     }

  709.     return NGX_OK;
  710. }


  713. static ngx_int_t
  714. ‌ngx_stream_server_names(ngx_conf_t *cf, ngx_stream_core_main_conf_t *cmcf,
  715.     ngx_stream_conf_addr_t *addr)
  716. {
  717.     ngx_int_t                     rc;
  718.     ngx_uint_t                    n, s;
  719.     ngx_hash_init_t               hash;
  720.     ngx_hash_keys_arrays_t        ha;
  721.     ngx_stream_server_name_t     *name;
  722.     ngx_stream_core_srv_conf_t  **cscfp;
  723. #if (NGX_PCRE)
  724.     ngx_uint_t                    regex, i;

  726.     regex = 0;
  727. #endif

  729.     ngx_memzero(&ha, sizeof(ngx_hash_keys_arrays_t));

  731.     ha.temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
  732.     if (ha.temp_pool == NULL) {
  733.         return NGX_ERROR;
  734.     }

  736.     ha.pool = cf->pool;

  738.     if (ngx_hash_keys_array_init(&ha, NGX_HASH_LARGE) != NGX_OK) {
  739.         goto failed;
  740.     }

  742.     cscfp = addr->servers.elts;

  744.     for (s = 0; s < addr->servers.nelts; s++) {

  746.         name = cscfp[s]->server_names.elts;

  748.         for (n = 0; n < cscfp[s]->server_names.nelts; n++) {

  750. #if (NGX_PCRE)
  751.             if (name[n].regex) {
  752.                 regex++;
  753.                 continue;
  754.             }
  755. #endif

  757.             rc = ngx_hash_add_key(&ha, &name[n].name, name[n].server,
  758.                                   NGX_HASH_WILDCARD_KEY);

  760.             if (rc == NGX_ERROR) {
  761.                 goto failed;
  762.             }

  764.             if (rc == NGX_DECLINED) {
  765.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  766.                               "invalid server name or wildcard \"%V\" on %V",
  767.                               &name[n].name, &addr->opt.addr_text);
  768.                 goto failed;
  769.             }

  771.             if (rc == NGX_BUSY) {
  772.                 ngx_log_error(NGX_LOG_WARN, cf->log, 0,
  773.                               "conflicting server name \"%V\" on %V, ignored",
  774.                               &name[n].name, &addr->opt.addr_text);
  775.             }
  776.         }
  777.     }

  779.     hash.key = ngx_hash_key_lc;
  780.     hash.max_size = cmcf->server_names_hash_max_size;
  781.     hash.bucket_size = cmcf->server_names_hash_bucket_size;
  782.     hash.name = "server_names_hash";
  783.     hash.pool = cf->pool;

  785.     if (ha.keys.nelts) {
  786.         hash.hash = &addr->hash;
  787.         hash.temp_pool = NULL;

  789.         if (ngx_hash_init(&hash, ha.keys.elts, ha.keys.nelts) != NGX_OK) {
  790.             goto failed;
  791.         }
  792.     }

  794.     if (ha.dns_wc_head.nelts) {

  796.         ngx_qsort(ha.dns_wc_head.elts, (size_t) ha.dns_wc_head.nelts,
  797.                   sizeof(ngx_hash_key_t), ngx_stream_cmp_dns_wildcards);

  799.         hash.hash = NULL;
  800.         hash.temp_pool = ha.temp_pool;

  802.         if (ngx_hash_wildcard_init(&hash, ha.dns_wc_head.elts,
  803.                                    ha.dns_wc_head.nelts)
  804.             != NGX_OK)
  805.         {
  806.             goto failed;
  807.         }

  809.         addr->wc_head = (ngx_hash_wildcard_t *) hash.hash;
  810.     }

  812.     if (ha.dns_wc_tail.nelts) {

  814.         ngx_qsort(ha.dns_wc_tail.elts, (size_t) ha.dns_wc_tail.nelts,
  815.                   sizeof(ngx_hash_key_t), ngx_stream_cmp_dns_wildcards);

  817.         hash.hash = NULL;
  818.         hash.temp_pool = ha.temp_pool;

  820.         if (ngx_hash_wildcard_init(&hash, ha.dns_wc_tail.elts,
  821.                                    ha.dns_wc_tail.nelts)
  822.             != NGX_OK)
  823.         {
  824.             goto failed;
  825.         }

  827.         addr->wc_tail = (ngx_hash_wildcard_t *) hash.hash;
  828.     }

  830.     ngx_destroy_pool(ha.temp_pool);

  832. #if (NGX_PCRE)

  834.     if (regex == 0) {
  835.         return NGX_OK;
  836.     }

  838.     addr->nregex = regex;
  839.     addr->regex = ngx_palloc(cf->pool,
  840.                              regex * sizeof(ngx_stream_server_name_t));
  841.     if (addr->regex == NULL) {
  842.         return NGX_ERROR;
  843.     }

  845.     i = 0;

  847.     for (s = 0; s < addr->servers.nelts; s++) {

  849.         name = cscfp[s]->server_names.elts;

  851.         for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
  852.             if (name[n].regex) {
  853.                 addr->regex[i++] = name[n];
  854.             }
  855.         }
  856.     }

  858. #endif

  860.     return NGX_OK;

  862. failed:

  864.     ngx_destroy_pool(ha.temp_pool);

  866.     return NGX_ERROR;
  867. }


  870. static ngx_int_t
  871. ‌ngx_stream_cmp_conf_addrs(const void *one, const void *two)
  872. {
  873.     ngx_stream_conf_addr_t  *first, *second;

  875.     first = (ngx_stream_conf_addr_t *) one;
  876.     second = (ngx_stream_conf_addr_t *) two;

  878.     if (first->opt.wildcard) {
  879.         /* a wildcard address must be the last resort, shift it to the end */
  880.         return 1;
  881.     }

  883.     if (second->opt.wildcard) {
  884.         /* a wildcard address must be the last resort, shift it to the end */
  885.         return -1;
  886.     }

  888.     if (first->opt.bind && !second->opt.bind) {
  889.         /* shift explicit bind()ed addresses to the start */
  890.         return -1;
  891.     }

  893.     if (!first->opt.bind && second->opt.bind) {
  894.         /* shift explicit bind()ed addresses to the start */
  895.         return 1;
  896.     }

  898.     /* do not sort by default */

  900.     return 0;
  901. }


  904. static int ngx_libc_cdecl
  905. ‌ngx_stream_cmp_dns_wildcards(const void *one, const void *two)
  906. {
  907.     ngx_hash_key_t  *first, *second;

  909.     first = (ngx_hash_key_t *) one;
  910.     second = (ngx_hash_key_t *) two;

  912.     return ngx_dns_strcmp(first->key.data, second->key.data);
  913. }


  916. static ngx_int_t
  917. ‌ngx_stream_init_listening(ngx_conf_t *cf, ngx_stream_conf_port_t *port)
  918. {
  919.     ngx_uint_t               i, last, bind_wildcard;
  920.     ngx_listening_t         *ls;
  921.     ngx_stream_port_t       *stport;
  922.     ngx_stream_conf_addr_t  *addr;

  924.     addr = port->addrs.elts;
  925.     last = port->addrs.nelts;

  927.     /*
  928.      * If there is a binding to an "*:port" then we need to bind() to
  929.      * the "*:port" only and ignore other implicit bindings.  The bindings
  930.      * have been already sorted: explicit bindings are on the start, then
  931.      * implicit bindings go, and wildcard binding is in the end.
  932.      */

  934.     if (addr[last - 1].opt.wildcard) {
  935.         addr[last - 1].opt.bind = 1;
  936.         bind_wildcard = 1;

  938.     } else {
  939.         bind_wildcard = 0;
  940.     }

  942.     i = 0;

  944.     while (i < last) {

  946.         if (bind_wildcard && !addr[i].opt.bind) {
  947.             i++;
  948.             continue;
  949.         }

  951.         ls = ngx_stream_add_listening(cf, &addr[i]);
  952.         if (ls == NULL) {
  953.             return NGX_ERROR;
  954.         }

  956.         stport = ngx_pcalloc(cf->pool, sizeof(ngx_stream_port_t));
  957.         if (stport == NULL) {
  958.             return NGX_ERROR;
  959.         }

  961.         ls->servers = stport;

  963.         stport->naddrs = i + 1;

  965.         switch (ls->sockaddr->sa_family) {

  967. #if (NGX_HAVE_INET6)
  968.         case AF_INET6:
  969.             if (ngx_stream_add_addrs6(cf, stport, addr) != NGX_OK) {
  970.                 return NGX_ERROR;
  971.             }
  972.             break;
  973. #endif
  974.         default: /* AF_INET */
  975.             if (ngx_stream_add_addrs(cf, stport, addr) != NGX_OK) {
  976.                 return NGX_ERROR;
  977.             }
  978.             break;
  979.         }

  981.         addr++;
  982.         last--;
  983.     }

  985.     return NGX_OK;
  986. }


  989. static ngx_listening_t *
  990. ‌ngx_stream_add_listening(ngx_conf_t *cf, ngx_stream_conf_addr_t *addr)
  991. {
  992.     ngx_listening_t             *ls;
  993.     ngx_stream_core_srv_conf_t  *cscf;

  995.     ls = ngx_create_listening(cf, addr->opt.sockaddr, addr->opt.socklen);
  996.     if (ls == NULL) {
  997.         return NULL;
  998.     }

  1000.     ls->addr_ntop = 1;

  1002.     ls->handler = ngx_stream_init_connection;

  1004.     ls->pool_size = 256;

  1006.     cscf = addr->default_server;

  1008.     ls->logp = cscf->error_log;
  1009.     ls->log.data = &ls->addr_text;
  1010.     ls->log.handler = ngx_accept_log_error;

  1012.     ls->type = addr->opt.type;
  1013.     ls->backlog = addr->opt.backlog;
  1014.     ls->rcvbuf = addr->opt.rcvbuf;
  1015.     ls->sndbuf = addr->opt.sndbuf;

  1017.     ls->keepalive = addr->opt.so_keepalive;
  1018. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  1019.     ls->keepidle = addr->opt.tcp_keepidle;
  1020.     ls->keepintvl = addr->opt.tcp_keepintvl;
  1021.     ls->keepcnt = addr->opt.tcp_keepcnt;
  1022. #endif

  1024. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  1025.     ls->accept_filter = addr->opt.accept_filter;
  1026. #endif

  1028. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  1029.     ls->deferred_accept = addr->opt.deferred_accept;
  1030. #endif

  1032. #if (NGX_HAVE_INET6)
  1033.     ls->ipv6only = addr->opt.ipv6only;
  1034. #endif

  1036. #if (NGX_HAVE_SETFIB)
  1037.     ls->setfib = addr->opt.setfib;
  1038. #endif

  1040. #if (NGX_HAVE_TCP_FASTOPEN)
  1041.     ls->fastopen = addr->opt.fastopen;
  1042. #endif

  1044. #if (NGX_HAVE_REUSEPORT)
  1045.     ls->reuseport = addr->opt.reuseport;
  1046. #endif

  1048.     ls->wildcard = addr->opt.wildcard;

  1050.     return ls;
  1051. }


  1054. static ngx_int_t
  1055. ‌ngx_stream_add_addrs(ngx_conf_t *cf, ngx_stream_port_t *stport,
  1056.     ngx_stream_conf_addr_t *addr)
  1057. {
  1058.     ngx_uint_t                   i;
  1059.     struct sockaddr_in          *sin;
  1060.     ngx_stream_in_addr_t        *addrs;
  1061.     ngx_stream_virtual_names_t  *vn;

  1063.     stport->addrs = ngx_pcalloc(cf->pool,
  1064.                                 stport->naddrs * sizeof(ngx_stream_in_addr_t));
  1065.     if (stport->addrs == NULL) {
  1066.         return NGX_ERROR;
  1067.     }

  1069.     addrs = stport->addrs;

  1071.     for (i = 0; i < stport->naddrs; i++) {

  1073.         sin = (struct sockaddr_in *) addr[i].opt.sockaddr;
  1074.         addrs[i].addr = sin->sin_addr.s_addr;
  1075.         addrs[i].conf.default_server = addr[i].default_server;
  1076. #if (NGX_STREAM_SSL)
  1077.         addrs[i].conf.ssl = addr[i].opt.ssl;
  1078. #endif
  1079.         addrs[i].conf.proxy_protocol = addr[i].opt.proxy_protocol;

  1081.         if (addr[i].hash.buckets == NULL
  1082.             && (addr[i].wc_head == NULL
  1083.                 || addr[i].wc_head->hash.buckets == NULL)
  1084.             && (addr[i].wc_tail == NULL
  1085.                 || addr[i].wc_tail->hash.buckets == NULL)
  1086. #if (NGX_PCRE)
  1087.             && addr[i].nregex == 0
  1088. #endif
  1089.             )
  1090.         {
  1091.             continue;
  1092.         }

  1094.         vn = ngx_palloc(cf->pool, sizeof(ngx_stream_virtual_names_t));
  1095.         if (vn == NULL) {
  1096.             return NGX_ERROR;
  1097.         }

  1099.         addrs[i].conf.virtual_names = vn;

  1101.         vn->names.hash = addr[i].hash;
  1102.         vn->names.wc_head = addr[i].wc_head;
  1103.         vn->names.wc_tail = addr[i].wc_tail;
  1104. #if (NGX_PCRE)
  1105.         vn->nregex = addr[i].nregex;
  1106.         vn->regex = addr[i].regex;
  1107. #endif
  1108.     }

  1110.     return NGX_OK;
  1111. }


  1114. #if (NGX_HAVE_INET6)

  1116. static ngx_int_t
  1117. ‌ngx_stream_add_addrs6(ngx_conf_t *cf, ngx_stream_port_t *stport,
  1118.     ngx_stream_conf_addr_t *addr)
  1119. {
  1120.     ngx_uint_t                   i;
  1121.     struct sockaddr_in6         *sin6;
  1122.     ngx_stream_in6_addr_t       *addrs6;
  1123.     ngx_stream_virtual_names_t  *vn;

  1125.     stport->addrs = ngx_pcalloc(cf->pool,
  1126.                                 stport->naddrs * sizeof(ngx_stream_in6_addr_t));
  1127.     if (stport->addrs == NULL) {
  1128.         return NGX_ERROR;
  1129.     }

  1131.     addrs6 = stport->addrs;

  1133.     for (i = 0; i < stport->naddrs; i++) {

  1135.         sin6 = (struct sockaddr_in6 *) addr[i].opt.sockaddr;
  1136.         addrs6[i].addr6 = sin6->sin6_addr;
  1137.         addrs6[i].conf.default_server = addr[i].default_server;
  1138. #if (NGX_STREAM_SSL)
  1139.         addrs6[i].conf.ssl = addr[i].opt.ssl;
  1140. #endif
  1141.         addrs6[i].conf.proxy_protocol = addr[i].opt.proxy_protocol;

  1143.         if (addr[i].hash.buckets == NULL
  1144.             && (addr[i].wc_head == NULL
  1145.                 || addr[i].wc_head->hash.buckets == NULL)
  1146.             && (addr[i].wc_tail == NULL
  1147.                 || addr[i].wc_tail->hash.buckets == NULL)
  1148. #if (NGX_PCRE)
  1149.             && addr[i].nregex == 0
  1150. #endif
  1151.             )
  1152.         {
  1153.             continue;
  1154.         }

  1156.         vn = ngx_palloc(cf->pool, sizeof(ngx_stream_virtual_names_t));
  1157.         if (vn == NULL) {
  1158.             return NGX_ERROR;
  1159.         }

  1161.         addrs6[i].conf.virtual_names = vn;

  1163.         vn->names.hash = addr[i].hash;
  1164.         vn->names.wc_head = addr[i].wc_head;
  1165.         vn->names.wc_tail = addr[i].wc_tail;
  1166. #if (NGX_PCRE)
  1167.         vn->nregex = addr[i].nregex;
  1168.         vn->regex = addr[i].regex;
  1169. #endif
  1170.     }

  1172.     return NGX_OK;
  1173. }

  1175. #endif

One Level Up Top Level