One Level Up Top Level

src/stream/ngx_stream_core_module.c - nginx

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. static ngx_uint_t ngx_stream_preread_can_peek(ngx_connection_t *c);
  14. static ngx_int_t ngx_stream_preread_peek(ngx_stream_session_t *s,
  15.     ngx_stream_phase_handler_t *ph);
  16. static ngx_int_t ngx_stream_preread(ngx_stream_session_t *s,
  17.     ngx_stream_phase_handler_t *ph);
  18. static ngx_int_t ngx_stream_core_preconfiguration(ngx_conf_t *cf);
  19. static void *ngx_stream_core_create_main_conf(ngx_conf_t *cf);
  20. static char *ngx_stream_core_init_main_conf(ngx_conf_t *cf, void *conf);
  21. static void *ngx_stream_core_create_srv_conf(ngx_conf_t *cf);
  22. static char *ngx_stream_core_merge_srv_conf(ngx_conf_t *cf, void *parent,
  23.     void *child);
  24. static char *ngx_stream_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd,
  25.     void *conf);
  26. static char *ngx_stream_core_server(ngx_conf_t *cf, ngx_command_t *cmd,
  27.     void *conf);
  28. static char *ngx_stream_core_listen(ngx_conf_t *cf, ngx_command_t *cmd,
  29.     void *conf);
  30. static char *ngx_stream_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd,
  31.     void *conf);
  32. static char *ngx_stream_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd,
  33.     void *conf);


  36. ‌static ngx_command_t  ngx_stream_core_commands[] = {

  38.     { ngx_string("variables_hash_max_size"),
  39.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE1,
  40.       ngx_conf_set_num_slot,
  41.       NGX_STREAM_MAIN_CONF_OFFSET,
  42.       offsetof(ngx_stream_core_main_conf_t, variables_hash_max_size),
  43.       NULL },

  45.     { ngx_string("variables_hash_bucket_size"),
  46.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE1,
  47.       ngx_conf_set_num_slot,
  48.       NGX_STREAM_MAIN_CONF_OFFSET,
  49.       offsetof(ngx_stream_core_main_conf_t, variables_hash_bucket_size),
  50.       NULL },

  52.     { ngx_string("server_names_hash_max_size"),
  53.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE1,
  54.       ngx_conf_set_num_slot,
  55.       NGX_STREAM_MAIN_CONF_OFFSET,
  56.       offsetof(ngx_stream_core_main_conf_t, server_names_hash_max_size),
  57.       NULL },

  59.     { ngx_string("server_names_hash_bucket_size"),
  60.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE1,
  61.       ngx_conf_set_num_slot,
  62.       NGX_STREAM_MAIN_CONF_OFFSET,
  63.       offsetof(ngx_stream_core_main_conf_t, server_names_hash_bucket_size),
  64.       NULL },

  66.     { ngx_string("server"),
  67.       NGX_STREAM_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  68.       ngx_stream_core_server,
  69.       0,
  70.       0,
  71.       NULL },

  73.     { ngx_string("listen"),
  74.       NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  75.       ngx_stream_core_listen,
  76.       NGX_STREAM_SRV_CONF_OFFSET,
  77.       0,
  78.       NULL },

  80.     { ngx_string("server_name"),
  81.       NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  82.       ngx_stream_core_server_name,
  83.       NGX_STREAM_SRV_CONF_OFFSET,
  84.       0,
  85.       NULL },

  87.     { ngx_string("error_log"),
  88.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  89.       ngx_stream_core_error_log,
  90.       NGX_STREAM_SRV_CONF_OFFSET,
  91.       0,
  92.       NULL },

  94.     { ngx_string("resolver"),
  95.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  96.       ngx_stream_core_resolver,
  97.       NGX_STREAM_SRV_CONF_OFFSET,
  98.       0,
  99.       NULL },

  101.     { ngx_string("resolver_timeout"),
  102.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  103.       ngx_conf_set_msec_slot,
  104.       NGX_STREAM_SRV_CONF_OFFSET,
  105.       offsetof(ngx_stream_core_srv_conf_t, resolver_timeout),
  106.       NULL },

  108.     { ngx_string("proxy_protocol_timeout"),
  109.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  110.       ngx_conf_set_msec_slot,
  111.       NGX_STREAM_SRV_CONF_OFFSET,
  112.       offsetof(ngx_stream_core_srv_conf_t, proxy_protocol_timeout),
  113.       NULL },

  115.     { ngx_string("tcp_nodelay"),
  116.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  117.       ngx_conf_set_flag_slot,
  118.       NGX_STREAM_SRV_CONF_OFFSET,
  119.       offsetof(ngx_stream_core_srv_conf_t, tcp_nodelay),
  120.       NULL },

  122.     { ngx_string("preread_buffer_size"),
  123.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  124.       ngx_conf_set_size_slot,
  125.       NGX_STREAM_SRV_CONF_OFFSET,
  126.       offsetof(ngx_stream_core_srv_conf_t, preread_buffer_size),
  127.       NULL },

  129.     { ngx_string("preread_timeout"),
  130.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  131.       ngx_conf_set_msec_slot,
  132.       NGX_STREAM_SRV_CONF_OFFSET,
  133.       offsetof(ngx_stream_core_srv_conf_t, preread_timeout),
  134.       NULL },

  136.       ngx_null_command
  137. };


  140. ‌static ngx_stream_module_t  ngx_stream_core_module_ctx = {
  141.     ngx_stream_core_preconfiguration,      /* preconfiguration */
  142.     NULL,                                  /* postconfiguration */

  144.     ngx_stream_core_create_main_conf,      /* create main configuration */
  145.     ngx_stream_core_init_main_conf,        /* init main configuration */

  147.     ngx_stream_core_create_srv_conf,       /* create server configuration */
  148.     ngx_stream_core_merge_srv_conf         /* merge server configuration */
  149. };


  152. ‌ngx_module_t  ngx_stream_core_module = {
  153.     NGX_MODULE_V1,
  154.     &ngx_stream_core_module_ctx,           /* module context */
  155.     ngx_stream_core_commands,              /* module directives */
  156.     NGX_STREAM_MODULE,                     /* module type */
  157.     NULL,                                  /* init master */
  158.     NULL,                                  /* init module */
  159.     NULL,                                  /* init process */
  160.     NULL,                                  /* init thread */
  161.     NULL,                                  /* exit thread */
  162.     NULL,                                  /* exit process */
  163.     NULL,                                  /* exit master */
  164.     NGX_MODULE_V1_PADDING
  165. };


  168. void
  169. ‌ngx_stream_core_run_phases(ngx_stream_session_t *s)
  170. {
  171.     ngx_int_t                     rc;
  172.     ngx_stream_phase_handler_t   *ph;
  173.     ngx_stream_core_main_conf_t  *cmcf;

  175.     cmcf = ngx_stream_get_module_main_conf(s, ngx_stream_core_module);

  177.     ph = cmcf->phase_engine.handlers;

  179.     while (ph[s->phase_handler].checker) {

  181.         rc = ph[s->phase_handler].checker(s, &ph[s->phase_handler]);

  183.         if (rc == NGX_OK) {
  184.             return;
  185.         }
  186.     }
  187. }


  190. ngx_int_t
  191. ‌ngx_stream_core_generic_phase(ngx_stream_session_t *s,
  192.     ngx_stream_phase_handler_t *ph)
  193. {
  194.     ngx_int_t  rc;

  196.     /*
  197.      * generic phase checker,
  198.      * used by all phases, except for preread and content
  199.      */

  201.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  202.                    "generic phase: %ui", s->phase_handler);

  204.     rc = ph->handler(s);

  206.     if (rc == NGX_OK) {
  207.         s->phase_handler = ph->next;
  208.         return NGX_AGAIN;
  209.     }

  211.     if (rc == NGX_DECLINED) {
  212.         s->phase_handler++;
  213.         return NGX_AGAIN;
  214.     }

  216.     if (rc == NGX_AGAIN || rc == NGX_DONE) {
  217.         return NGX_OK;
  218.     }

  220.     if (rc == NGX_ERROR) {
  221.         rc = NGX_STREAM_INTERNAL_SERVER_ERROR;
  222.     }

  224.     ngx_stream_finalize_session(s, rc);

  226.     return NGX_OK;
  227. }


  230. ngx_int_t
  231. ‌ngx_stream_core_preread_phase(ngx_stream_session_t *s,
  232.     ngx_stream_phase_handler_t *ph)
  233. {
  234.     ngx_int_t                    rc;
  235.     ngx_connection_t            *c;
  236.     ngx_stream_core_srv_conf_t  *cscf;

  238.     c = s->connection;

  240.     c->log->action = "prereading client data";

  242.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  244.     if (c->read->timedout) {
  245.         rc = NGX_STREAM_OK;
  246.         goto done;
  247.     }

  249.     if (!c->read->timer_set) {
  250.         rc = ph->handler(s);

  252.         if (rc != NGX_AGAIN) {
  253.             goto done;
  254.         }
  255.     }

  257.     if (c->buffer == NULL) {
  258.         c->buffer = ngx_create_temp_buf(c->pool, cscf->preread_buffer_size);
  259.         if (c->buffer == NULL) {
  260.             rc = NGX_ERROR;
  261.             goto done;
  262.         }
  263.     }

  265.     if (ngx_stream_preread_can_peek(c)) {
  266.         rc = ngx_stream_preread_peek(s, ph);

  268.     } else {
  269.         rc = ngx_stream_preread(s, ph);
  270.     }

  272. done:

  274.     if (rc == NGX_AGAIN) {
  275.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  276.             ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  277.             return NGX_OK;
  278.         }

  280.         if (!c->read->timer_set) {
  281.             ngx_add_timer(c->read, cscf->preread_timeout);
  282.         }

  284.         c->read->handler = ngx_stream_session_handler;

  286.         return NGX_OK;
  287.     }

  289.     if (c->read->timer_set) {
  290.         ngx_del_timer(c->read);
  291.     }

  293.     if (rc == NGX_OK) {
  294.         s->phase_handler = ph->next;
  295.         return NGX_AGAIN;
  296.     }

  298.     if (rc == NGX_DECLINED) {
  299.         s->phase_handler++;
  300.         return NGX_AGAIN;
  301.     }

  303.     if (rc == NGX_DONE) {
  304.         return NGX_OK;
  305.     }

  307.     if (rc == NGX_ERROR) {
  308.         rc = NGX_STREAM_INTERNAL_SERVER_ERROR;
  309.     }

  311.     ngx_stream_finalize_session(s, rc);

  313.     return NGX_OK;
  314. }


  317. static ngx_uint_t
  318. ‌ngx_stream_preread_can_peek(ngx_connection_t *c)
  319. {
  320. #if (NGX_STREAM_SSL)
  321.     if (c->ssl) {
  322.         return 0;
  323.     }
  324. #endif

  326.     if ((ngx_event_flags & NGX_USE_CLEAR_EVENT) == 0) {
  327.         return 0;
  328.     }

  330. #if (NGX_HAVE_KQUEUE)
  331.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  332.         return 1;
  333.     }
  334. #endif

  336. #if (NGX_HAVE_EPOLLRDHUP)
  337.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  338.         return 1;
  339.     }
  340. #endif

  342.     return 0;
  343. }


  346. static ngx_int_t
  347. ‌ngx_stream_preread_peek(ngx_stream_session_t *s, ngx_stream_phase_handler_t *ph)
  348. {
  349.     ssize_t            n;
  350.     ngx_int_t          rc;
  351.     ngx_err_t          err;
  352.     ngx_connection_t  *c;

  354.     c = s->connection;

  356.     n = recv(c->fd, (char *) c->buffer->last,
  357.              c->buffer->end - c->buffer->last, MSG_PEEK);

  359.     err = ngx_socket_errno;

  361.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0, "stream recv(): %z", n);

  363.     if (n == -1) {
  364.         if (err == NGX_EAGAIN) {
  365.             c->read->ready = 0;
  366.             return NGX_AGAIN;
  367.         }

  369.         ngx_connection_error(c, err, "recv() failed");
  370.         return NGX_STREAM_OK;
  371.     }

  373.     if (n == 0) {
  374.         return NGX_STREAM_OK;
  375.     }

  377.     c->buffer->last += n;

  379.     rc = ph->handler(s);

  381.     if (rc != NGX_AGAIN) {
  382.         c->buffer->last = c->buffer->pos;
  383.         return rc;
  384.     }

  386.     if (c->buffer->last == c->buffer->end) {
  387.         ngx_log_error(NGX_LOG_ERR, c->log, 0, "preread buffer full");
  388.         return NGX_STREAM_BAD_REQUEST;
  389.     }

  391.     if (c->read->pending_eof) {
  392.         return NGX_STREAM_OK;
  393.     }

  395.     c->buffer->last = c->buffer->pos;

  397.     return NGX_AGAIN;
  398. }


  401. static ngx_int_t
  402. ‌ngx_stream_preread(ngx_stream_session_t *s, ngx_stream_phase_handler_t *ph)
  403. {
  404.     ssize_t            n;
  405.     ngx_int_t          rc;
  406.     ngx_connection_t  *c;

  408.     c = s->connection;

  410.     while (c->read->ready) {

  412.         n = c->recv(c, c->buffer->last, c->buffer->end - c->buffer->last);

  414.         if (n == NGX_AGAIN) {
  415.             return NGX_AGAIN;
  416.         }

  418.         if (n == NGX_ERROR || n == 0) {
  419.             return NGX_STREAM_OK;
  420.         }

  422.         c->buffer->last += n;

  424.         rc = ph->handler(s);

  426.         if (rc != NGX_AGAIN) {
  427.             return rc;
  428.         }

  430.         if (c->buffer->last == c->buffer->end) {
  431.             ngx_log_error(NGX_LOG_ERR, c->log, 0, "preread buffer full");
  432.             return NGX_STREAM_BAD_REQUEST;
  433.         }
  434.     }

  436.     return NGX_AGAIN;
  437. }


  440. ngx_int_t
  441. ‌ngx_stream_core_content_phase(ngx_stream_session_t *s,
  442.     ngx_stream_phase_handler_t *ph)
  443. {
  444.     ngx_connection_t            *c;
  445.     ngx_stream_core_srv_conf_t  *cscf;

  447.     c = s->connection;

  449.     c->log->action = NULL;

  451.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  453.     if (c->type == SOCK_STREAM
  454.         && cscf->tcp_nodelay
  455.         && ngx_tcp_nodelay(c) != NGX_OK)
  456.     {
  457.         ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  458.         return NGX_OK;
  459.     }

  461.     if (cscf->handler == NULL) {
  462.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  463.                        "no handler for server");
  464.         ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  465.         return NGX_OK;
  466.     }

  468.     cscf->handler(s);

  470.     return NGX_OK;
  471. }


  474. ngx_int_t
  475. ‌ngx_stream_validate_host(ngx_str_t *host, ngx_pool_t *pool, ngx_uint_t alloc)
  476. {
  477.     u_char     *h, ch;
  478.     size_t      i, dot_pos, host_len;
  479.     ngx_int_t   port;

  481. ‌    enum {
  482.         sw_host_start = 0,
  483.         sw_host,
  484.         sw_host_ip_literal,
  485.         sw_host_end,
  486.         sw_port,
  487.     } state;

  489.     dot_pos = host->len;
  490.     host_len = host->len;
  491.     port = 0;

  493.     h = host->data;

  495.     state = sw_host_start;

  497.     for (i = 0; i < host->len; i++) {
  498.         ch = h[i];

  500.         switch (state) {

  502.         case sw_host_start:

  504.             if (ch == '[') {
  505.                 state = sw_host_ip_literal;
  506.                 break;
  507.             }

  509.             state = sw_host;

  511.             /* fall through */

  513.         case sw_host:

  515.             if (ch >= 'A' && ch <= 'Z') {
  516.                 alloc = 1;
  517.                 break;
  518.             }

  520.             if (ch >= 'a' && ch <= 'z') {
  521.                 break;
  522.             }

  524.             if (ch >= '0' && ch <= '9') {
  525.                 break;
  526.             }

  528.             switch (ch) {
  529.             case ':':
  530.                 host_len = i;
  531.                 state = sw_port;
  532.                 break;
  533.             case '-':
  534.                 break;
  535.             case '.':
  536.                 if (dot_pos == i - 1) {
  537.                     return NGX_DECLINED;
  538.                 }
  539.                 dot_pos = i;
  540.                 break;
  541.             case '_':
  542.             case '~':
  543.                 /* unreserved */
  544.                 break;
  545.             case '!':
  546.             case '$':
  547.             case '&':
  548.             case '\'':
  549.             case '(':
  550.             case ')':
  551.             case '*':
  552.             case '+':
  553.             case ',':
  554.             case ';':
  555.             case '=':
  556.                 /* sub-delims */
  557.                 break;
  558.             case '%':
  559.                 /* pct-encoded */
  560.                 break;
  561.             default:
  562.                 return NGX_DECLINED;
  563.             }
  564.             break;

  566.         case sw_host_ip_literal:

  568.             if (ch >= 'A' && ch <= 'Z') {
  569.                 alloc = 1;
  570.                 break;
  571.             }

  573.             if (ch >= 'a' && ch <= 'z') {
  574.                 break;
  575.             }

  577.             if (ch >= '0' && ch <= '9') {
  578.                 break;
  579.             }

  581.             switch (ch) {
  582.             case ':':
  583.                 break;
  584.             case ']':
  585.                 host_len = i + 1;
  586.                 state = sw_host_end;
  587.                 break;
  588.             case '-':
  589.                 break;
  590.             case '.':
  591.                 if (dot_pos == i - 1) {
  592.                     return NGX_DECLINED;
  593.                 }
  594.                 dot_pos = i;
  595.                 break;
  596.             case '_':
  597.             case '~':
  598.                 /* unreserved */
  599.                 break;
  600.             case '!':
  601.             case '$':
  602.             case '&':
  603.             case '\'':
  604.             case '(':
  605.             case ')':
  606.             case '*':
  607.             case '+':
  608.             case ',':
  609.             case ';':
  610.             case '=':
  611.                 /* sub-delims */
  612.                 break;
  613.             default:
  614.                 return NGX_DECLINED;
  615.             }
  616.             break;

  618.         case sw_host_end:

  620.             if (ch == ':') {
  621.                 state = sw_port;
  622.                 break;
  623.             }
  624.             return NGX_DECLINED;

  626.         case sw_port:

  628.             if (ch >= '0' && ch <= '9') {
  629.                 if (port >= 6553 && (port > 6553 || (ch - '0') > 5)) {
  630.                     return NGX_DECLINED;
  631.                 }

  633.                 port = port * 10 + (ch - '0');
  634.                 break;
  635.             }
  636.             return NGX_DECLINED;
  637.         }
  638.     }

  640.     if (state == sw_host_ip_literal) {
  641.         return NGX_DECLINED;
  642.     }

  644.     if (dot_pos == host_len - 1) {
  645.         host_len--;
  646.     }

  648.     if (host_len == 0) {
  649.         return NGX_DECLINED;
  650.     }

  652.     if (alloc) {
  653.         host->data = ngx_pnalloc(pool, host_len);
  654.         if (host->data == NULL) {
  655.             return NGX_ERROR;
  656.         }

  658.         ngx_strlow(host->data, h, host_len);
  659.     }

  661.     host->len = host_len;

  663.     return NGX_OK;
  664. }


  667. ngx_int_t
  668. ‌ngx_stream_find_virtual_server(ngx_stream_session_t *s,
  669.     ngx_str_t *host, ngx_stream_core_srv_conf_t **cscfp)
  670. {
  671.     ngx_stream_core_srv_conf_t  *cscf;

  673.     if (s->virtual_names == NULL) {
  674.         return NGX_DECLINED;
  675.     }

  677.     cscf = ngx_hash_find_combined(&s->virtual_names->names,
  678.                                   ngx_hash_key(host->data, host->len),
  679.                                   host->data, host->len);

  681.     if (cscf) {
  682.         *cscfp = cscf;
  683.         return NGX_OK;
  684.     }

  686. #if (NGX_PCRE)

  688.     if (host->len && s->virtual_names->nregex) {
  689.         ngx_int_t                  n;
  690.         ngx_uint_t                 i;
  691.         ngx_stream_server_name_t  *sn;

  693.         sn = s->virtual_names->regex;

  695.         for (i = 0; i < s->virtual_names->nregex; i++) {

  697.             n = ngx_stream_regex_exec(s, sn[i].regex, host);

  699.             if (n == NGX_DECLINED) {
  700.                 continue;
  701.             }

  703.             if (n == NGX_OK) {
  704.                 *cscfp = sn[i].server;
  705.                 return NGX_OK;
  706.             }

  708.             return NGX_ERROR;
  709.         }
  710.     }

  712. #endif /* NGX_PCRE */

  714.     return NGX_DECLINED;
  715. }


  718. static ngx_int_t
  719. ‌ngx_stream_core_preconfiguration(ngx_conf_t *cf)
  720. {
  721.     return ngx_stream_variables_add_core_vars(cf);
  722. }


  725. static void *
  726. ‌ngx_stream_core_create_main_conf(ngx_conf_t *cf)
  727. {
  728.     ngx_stream_core_main_conf_t  *cmcf;

  730.     cmcf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_core_main_conf_t));
  731.     if (cmcf == NULL) {
  732.         return NULL;
  733.     }

  735.     if (ngx_array_init(&cmcf->servers, cf->pool, 4,
  736.                        sizeof(ngx_stream_core_srv_conf_t *))
  737.         != NGX_OK)
  738.     {
  739.         return NULL;
  740.     }

  742.     cmcf->server_names_hash_max_size = NGX_CONF_UNSET_UINT;
  743.     cmcf->server_names_hash_bucket_size = NGX_CONF_UNSET_UINT;

  745.     cmcf->variables_hash_max_size = NGX_CONF_UNSET_UINT;
  746.     cmcf->variables_hash_bucket_size = NGX_CONF_UNSET_UINT;

  748.     return cmcf;
  749. }


  752. static char *
  753. ‌ngx_stream_core_init_main_conf(ngx_conf_t *cf, void *conf)
  754. {
  755.     ngx_stream_core_main_conf_t *cmcf = conf;

  757.     ngx_conf_init_uint_value(cmcf->server_names_hash_max_size, 512);
  758.     ngx_conf_init_uint_value(cmcf->server_names_hash_bucket_size,
  759.                              ngx_cacheline_size);

  761.     cmcf->server_names_hash_bucket_size =
  762.             ngx_align(cmcf->server_names_hash_bucket_size, ngx_cacheline_size);


  765.     ngx_conf_init_uint_value(cmcf->variables_hash_max_size, 1024);
  766.     ngx_conf_init_uint_value(cmcf->variables_hash_bucket_size, 64);

  768.     cmcf->variables_hash_bucket_size =
  769.                ngx_align(cmcf->variables_hash_bucket_size, ngx_cacheline_size);

  771.     if (cmcf->ncaptures) {
  772.         cmcf->ncaptures = (cmcf->ncaptures + 1) * 3;
  773.     }

  775.     return NGX_CONF_OK;
  776. }


  779. static void *
  780. ‌ngx_stream_core_create_srv_conf(ngx_conf_t *cf)
  781. {
  782.     ngx_stream_core_srv_conf_t  *cscf;

  784.     cscf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_core_srv_conf_t));
  785.     if (cscf == NULL) {
  786.         return NULL;
  787.     }

  789.     /*
  790.      * set by ngx_pcalloc():
  791.      *
  792.      *     cscf->handler = NULL;
  793.      *     cscf->error_log = NULL;
  794.      */

  796.     if (ngx_array_init(&cscf->server_names, cf->temp_pool, 4,
  797.                        sizeof(ngx_stream_server_name_t))
  798.         != NGX_OK)
  799.     {
  800.         return NULL;
  801.     }

  803.     cscf->file_name = cf->conf_file->file.name.data;
  804.     cscf->line = cf->conf_file->line;
  805.     cscf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  806.     cscf->proxy_protocol_timeout = NGX_CONF_UNSET_MSEC;
  807.     cscf->tcp_nodelay = NGX_CONF_UNSET;
  808.     cscf->preread_buffer_size = NGX_CONF_UNSET_SIZE;
  809.     cscf->preread_timeout = NGX_CONF_UNSET_MSEC;

  811.     return cscf;
  812. }


  815. static char *
  816. ‌ngx_stream_core_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  817. {
  818.     ngx_stream_core_srv_conf_t *prev = parent;
  819.     ngx_stream_core_srv_conf_t *conf = child;

  821.     ngx_str_t                  name;
  822.     ngx_stream_server_name_t  *sn;

  824.     ngx_conf_merge_msec_value(conf->resolver_timeout,
  825.                               prev->resolver_timeout, 30000);

  827.     if (conf->resolver == NULL) {

  829.         if (prev->resolver == NULL) {

  831.             /*
  832.              * create dummy resolver in stream {} context
  833.              * to inherit it in all servers
  834.              */

  836.             prev->resolver = ngx_resolver_create(cf, NULL, 0);
  837.             if (prev->resolver == NULL) {
  838.                 return NGX_CONF_ERROR;
  839.             }
  840.         }

  842.         conf->resolver = prev->resolver;
  843.     }

  845.     if (conf->error_log == NULL) {
  846.         if (prev->error_log) {
  847.             conf->error_log = prev->error_log;
  848.         } else {
  849.             conf->error_log = &cf->cycle->new_log;
  850.         }
  851.     }

  853.     ngx_conf_merge_msec_value(conf->proxy_protocol_timeout,
  854.                               prev->proxy_protocol_timeout, 30000);

  856.     ngx_conf_merge_value(conf->tcp_nodelay, prev->tcp_nodelay, 1);

  858.     ngx_conf_merge_size_value(conf->preread_buffer_size,
  859.                               prev->preread_buffer_size, 16384);

  861.     ngx_conf_merge_msec_value(conf->preread_timeout,
  862.                               prev->preread_timeout, 30000);

  864.     if (conf->server_names.nelts == 0) {
  865.         /* the array has 4 empty preallocated elements, so push cannot fail */
  866.         sn = ngx_array_push(&conf->server_names);
  867. #if (NGX_PCRE)
  868.         sn->regex = NULL;
  869. #endif
  870.         sn->server = conf;
  871.         ngx_str_set(&sn->name, "");
  872.     }

  874.     sn = conf->server_names.elts;
  875.     name = sn[0].name;

  877. #if (NGX_PCRE)
  878.     if (sn->regex) {
  879.         name.len++;
  880.         name.data--;
  881.     } else
  882. #endif

  884.     if (name.data[0] == '.') {
  885.         name.len--;
  886.         name.data++;
  887.     }

  889.     conf->server_name.len = name.len;
  890.     conf->server_name.data = ngx_pstrdup(cf->pool, &name);
  891.     if (conf->server_name.data == NULL) {
  892.         return NGX_CONF_ERROR;
  893.     }

  895.     return NGX_CONF_OK;
  896. }


  899. static char *
  900. ‌ngx_stream_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  901. {
  902.     ngx_stream_core_srv_conf_t  *cscf = conf;

  904.     return ngx_log_set_log(cf, &cscf->error_log);
  905. }


  908. static char *
  909. ‌ngx_stream_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  910. {
  911.     char                         *rv;
  912.     void                         *mconf;
  913.     ngx_uint_t                    m;
  914.     ngx_conf_t                    pcf;
  915.     ngx_stream_module_t          *module;
  916.     ngx_stream_conf_ctx_t        *ctx, *stream_ctx;
  917.     ngx_stream_core_srv_conf_t   *cscf, **cscfp;
  918.     ngx_stream_core_main_conf_t  *cmcf;

  920.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_stream_conf_ctx_t));
  921.     if (ctx == NULL) {
  922.         return NGX_CONF_ERROR;
  923.     }

  925.     stream_ctx = cf->ctx;
  926.     ctx->main_conf = stream_ctx->main_conf;

  928.     /* the server{}'s srv_conf */

  930.     ctx->srv_conf = ngx_pcalloc(cf->pool,
  931.                                 sizeof(void *) * ngx_stream_max_module);
  932.     if (ctx->srv_conf == NULL) {
  933.         return NGX_CONF_ERROR;
  934.     }

  936.     for (m = 0; cf->cycle->modules[m]; m++) {
  937.         if (cf->cycle->modules[m]->type != NGX_STREAM_MODULE) {
  938.             continue;
  939.         }

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

  943.         if (module->create_srv_conf) {
  944.             mconf = module->create_srv_conf(cf);
  945.             if (mconf == NULL) {
  946.                 return NGX_CONF_ERROR;
  947.             }

  949.             ctx->srv_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  950.         }
  951.     }

  953.     /* the server configuration context */

  955.     cscf = ctx->srv_conf[ngx_stream_core_module.ctx_index];
  956.     cscf->ctx = ctx;

  958.     cmcf = ctx->main_conf[ngx_stream_core_module.ctx_index];

  960.     cscfp = ngx_array_push(&cmcf->servers);
  961.     if (cscfp == NULL) {
  962.         return NGX_CONF_ERROR;
  963.     }

  965.     *cscfp = cscf;


  968.     /* parse inside server{} */

  970.     pcf = *cf;
  971.     cf->ctx = ctx;
  972.     cf->cmd_type = NGX_STREAM_SRV_CONF;

  974.     rv = ngx_conf_parse(cf, NULL);

  976.     *cf = pcf;

  978.     if (rv == NGX_CONF_OK && !cscf->listen) {
  979.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  980.                       "no \"listen\" is defined for server in %s:%ui",
  981.                       cscf->file_name, cscf->line);
  982.         return NGX_CONF_ERROR;
  983.     }

  985.     return rv;
  986. }


  989. static char *
  990. ‌ngx_stream_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  991. {
  992.     ngx_stream_core_srv_conf_t  *cscf = conf;

  994.     ngx_str_t                *value, size;
  995.     ngx_url_t                 u;
  996.     ngx_uint_t                n, i, backlog;
  997.     ngx_stream_listen_opt_t   lsopt;

  999.     cscf->listen = 1;

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

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

  1005.     u.url = value[1];
  1006.     u.listen = 1;

  1008.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  1009.         if (u.err) {
  1010.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1011.                                "%s in \"%V\" of the \"listen\" directive",
  1012.                                u.err, &u.url);
  1013.         }

  1015.         return NGX_CONF_ERROR;
  1016.     }

  1018.     ngx_memzero(&lsopt, sizeof(ngx_stream_listen_opt_t));

  1020.     lsopt.backlog = NGX_LISTEN_BACKLOG;
  1021.     lsopt.type = SOCK_STREAM;
  1022.     lsopt.rcvbuf = -1;
  1023.     lsopt.sndbuf = -1;
  1024. #if (NGX_HAVE_SETFIB)
  1025.     lsopt.setfib = -1;
  1026. #endif
  1027. #if (NGX_HAVE_TCP_FASTOPEN)
  1028.     lsopt.fastopen = -1;
  1029. #endif
  1030. #if (NGX_HAVE_INET6)
  1031.     lsopt.ipv6only = 1;
  1032. #endif

  1034.     backlog = 0;

  1036.     for (i = 2; i < cf->args->nelts; i++) {

  1038.         if (ngx_strcmp(value[i].data, "default_server") == 0) {
  1039.             lsopt.default_server = 1;
  1040.             continue;
  1041.         }

  1043. #if !(NGX_WIN32)
  1044.         if (ngx_strcmp(value[i].data, "udp") == 0) {
  1045.             lsopt.type = SOCK_DGRAM;
  1046.             continue;
  1047.         }
  1048. #endif

  1050.         if (ngx_strcmp(value[i].data, "bind") == 0) {
  1051.             lsopt.set = 1;
  1052.             lsopt.bind = 1;
  1053.             continue;
  1054.         }

  1056. #if (NGX_HAVE_SETFIB)
  1057.         if (ngx_strncmp(value[i].data, "setfib=", 7) == 0) {
  1058.             lsopt.setfib = ngx_atoi(value[i].data + 7, value[i].len - 7);
  1059.             lsopt.set = 1;
  1060.             lsopt.bind = 1;

  1062.             if (lsopt.setfib == NGX_ERROR) {
  1063.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1064.                                    "invalid setfib \"%V\"", &value[i]);
  1065.                 return NGX_CONF_ERROR;
  1066.             }

  1068.             continue;
  1069.         }
  1070. #endif

  1072. #if (NGX_HAVE_TCP_FASTOPEN)
  1073.         if (ngx_strncmp(value[i].data, "fastopen=", 9) == 0) {
  1074.             lsopt.fastopen = ngx_atoi(value[i].data + 9, value[i].len - 9);
  1075.             lsopt.set = 1;
  1076.             lsopt.bind = 1;

  1078.             if (lsopt.fastopen == NGX_ERROR) {
  1079.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1080.                                    "invalid fastopen \"%V\"", &value[i]);
  1081.                 return NGX_CONF_ERROR;
  1082.             }

  1084.             continue;
  1085.         }
  1086. #endif

  1088.         if (ngx_strncmp(value[i].data, "backlog=", 8) == 0) {
  1089.             lsopt.backlog = ngx_atoi(value[i].data + 8, value[i].len - 8);
  1090.             lsopt.set = 1;
  1091.             lsopt.bind = 1;

  1093.             if (lsopt.backlog == NGX_ERROR || lsopt.backlog == 0) {
  1094.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1095.                                    "invalid backlog \"%V\"", &value[i]);
  1096.                 return NGX_CONF_ERROR;
  1097.             }

  1099.             backlog = 1;

  1101.             continue;
  1102.         }

  1104.         if (ngx_strncmp(value[i].data, "rcvbuf=", 7) == 0) {
  1105.             size.len = value[i].len - 7;
  1106.             size.data = value[i].data + 7;

  1108.             lsopt.rcvbuf = ngx_parse_size(&size);
  1109.             lsopt.set = 1;
  1110.             lsopt.bind = 1;

  1112.             if (lsopt.rcvbuf == NGX_ERROR) {
  1113.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1114.                                    "invalid rcvbuf \"%V\"", &value[i]);
  1115.                 return NGX_CONF_ERROR;
  1116.             }

  1118.             continue;
  1119.         }

  1121.         if (ngx_strncmp(value[i].data, "sndbuf=", 7) == 0) {
  1122.             size.len = value[i].len - 7;
  1123.             size.data = value[i].data + 7;

  1125.             lsopt.sndbuf = ngx_parse_size(&size);
  1126.             lsopt.set = 1;
  1127.             lsopt.bind = 1;

  1129.             if (lsopt.sndbuf == NGX_ERROR) {
  1130.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1131.                                    "invalid sndbuf \"%V\"", &value[i]);
  1132.                 return NGX_CONF_ERROR;
  1133.             }

  1135.             continue;
  1136.         }

  1138.         if (ngx_strncmp(value[i].data, "accept_filter=", 14) == 0) {
  1139. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  1140.             lsopt.accept_filter = (char *) &value[i].data[14];
  1141.             lsopt.set = 1;
  1142.             lsopt.bind = 1;
  1143. #else
  1144.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1145.                                "accept filters \"%V\" are not supported "
  1146.                                "on this platform, ignored",
  1147.                                &value[i]);
  1148. #endif
  1149.             continue;
  1150.         }

  1152.         if (ngx_strcmp(value[i].data, "deferred") == 0) {
  1153. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  1154.             lsopt.deferred_accept = 1;
  1155.             lsopt.set = 1;
  1156.             lsopt.bind = 1;
  1157. #else
  1158.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1159.                                "the deferred accept is not supported "
  1160.                                "on this platform, ignored");
  1161. #endif
  1162.             continue;
  1163.         }

  1165.         if (ngx_strncmp(value[i].data, "ipv6only=o", 10) == 0) {
  1166. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  1167.             if (ngx_strcmp(&value[i].data[10], "n") == 0) {
  1168.                 lsopt.ipv6only = 1;

  1170.             } else if (ngx_strcmp(&value[i].data[10], "ff") == 0) {
  1171.                 lsopt.ipv6only = 0;

  1173.             } else {
  1174.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1175.                                    "invalid ipv6only flags \"%s\"",
  1176.                                    &value[i].data[9]);
  1177.                 return NGX_CONF_ERROR;
  1178.             }

  1180.             lsopt.set = 1;
  1181.             lsopt.bind = 1;

  1183.             continue;
  1184. #else
  1185.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1186.                                "ipv6only is not supported "
  1187.                                "on this platform");
  1188.             return NGX_CONF_ERROR;
  1189. #endif
  1190.         }

  1192.         if (ngx_strcmp(value[i].data, "reuseport") == 0) {
  1193. #if (NGX_HAVE_REUSEPORT)
  1194.             lsopt.reuseport = 1;
  1195.             lsopt.set = 1;
  1196.             lsopt.bind = 1;
  1197. #else
  1198.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1199.                                "reuseport is not supported "
  1200.                                "on this platform, ignored");
  1201. #endif
  1202.             continue;
  1203.         }

  1205.         if (ngx_strcmp(value[i].data, "multipath") == 0) {
  1206. #ifdef IPPROTO_MPTCP
  1207.             lsopt.protocol = IPPROTO_MPTCP;
  1208.             lsopt.set = 1;
  1209.             lsopt.bind = 1;
  1210. #else
  1211.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1212.                                "multipath is not supported "
  1213.                                "on this platform, ignored");
  1214. #endif
  1215.             continue;
  1216.         }

  1218.         if (ngx_strcmp(value[i].data, "ssl") == 0) {
  1219. #if (NGX_STREAM_SSL)
  1220.             lsopt.ssl = 1;
  1221.             continue;
  1222. #else
  1223.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1224.                                "the \"ssl\" parameter requires "
  1225.                                "ngx_stream_ssl_module");
  1226.             return NGX_CONF_ERROR;
  1227. #endif
  1228.         }

  1230.         if (ngx_strncmp(value[i].data, "so_keepalive=", 13) == 0) {

  1232.             if (ngx_strcmp(&value[i].data[13], "on") == 0) {
  1233.                 lsopt.so_keepalive = 1;

  1235.             } else if (ngx_strcmp(&value[i].data[13], "off") == 0) {
  1236.                 lsopt.so_keepalive = 2;

  1238.             } else {

  1240. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  1241.                 u_char     *p, *end;
  1242.                 ngx_str_t   s;

  1244.                 end = value[i].data + value[i].len;
  1245.                 s.data = value[i].data + 13;

  1247.                 p = ngx_strlchr(s.data, end, ':');
  1248.                 if (p == NULL) {
  1249.                     p = end;
  1250.                 }

  1252.                 if (p > s.data) {
  1253.                     s.len = p - s.data;

  1255.                     lsopt.tcp_keepidle = ngx_parse_time(&s, 1);
  1256.                     if (lsopt.tcp_keepidle == (time_t) NGX_ERROR) {
  1257.                         goto invalid_so_keepalive;
  1258.                     }
  1259.                 }

  1261.                 s.data = (p < end) ? (p + 1) : end;

  1263.                 p = ngx_strlchr(s.data, end, ':');
  1264.                 if (p == NULL) {
  1265.                     p = end;
  1266.                 }

  1268.                 if (p > s.data) {
  1269.                     s.len = p - s.data;

  1271.                     lsopt.tcp_keepintvl = ngx_parse_time(&s, 1);
  1272.                     if (lsopt.tcp_keepintvl == (time_t) NGX_ERROR) {
  1273.                         goto invalid_so_keepalive;
  1274.                     }
  1275.                 }

  1277.                 s.data = (p < end) ? (p + 1) : end;

  1279.                 if (s.data < end) {
  1280.                     s.len = end - s.data;

  1282.                     lsopt.tcp_keepcnt = ngx_atoi(s.data, s.len);
  1283.                     if (lsopt.tcp_keepcnt == NGX_ERROR) {
  1284.                         goto invalid_so_keepalive;
  1285.                     }
  1286.                 }

  1288.                 if (lsopt.tcp_keepidle == 0 && lsopt.tcp_keepintvl == 0
  1289.                     && lsopt.tcp_keepcnt == 0)
  1290.                 {
  1291.                     goto invalid_so_keepalive;
  1292.                 }

  1294.                 lsopt.so_keepalive = 1;

  1296. #else

  1298.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1299.                                    "the \"so_keepalive\" parameter accepts "
  1300.                                    "only \"on\" or \"off\" on this platform");
  1301.                 return NGX_CONF_ERROR;

  1303. #endif
  1304.             }

  1306.             lsopt.set = 1;
  1307.             lsopt.bind = 1;

  1309.             continue;

  1311. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  1312.         invalid_so_keepalive:

  1314.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1315.                                "invalid so_keepalive value: \"%s\"",
  1316.                                &value[i].data[13]);
  1317.             return NGX_CONF_ERROR;
  1318. #endif
  1319.         }

  1321.         if (ngx_strcmp(value[i].data, "proxy_protocol") == 0) {
  1322.             lsopt.proxy_protocol = 1;
  1323.             continue;
  1324.         }

  1326.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1327.                            "invalid parameter \"%V\"", &value[i]);
  1328.         return NGX_CONF_ERROR;
  1329.     }

  1331.     if (lsopt.type == SOCK_DGRAM) {
  1332. #if (NGX_HAVE_TCP_FASTOPEN)
  1333.         if (lsopt.fastopen != -1) {
  1334.             return "\"fastopen\" parameter is incompatible with \"udp\"";
  1335.         }
  1336. #endif

  1338.         if (backlog) {
  1339.             return "\"backlog\" parameter is incompatible with \"udp\"";
  1340.         }

  1342. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  1343.         if (lsopt.accept_filter) {
  1344.             return "\"accept_filter\" parameter is incompatible with \"udp\"";
  1345.         }
  1346. #endif

  1348. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  1349.         if (lsopt.deferred_accept) {
  1350.             return "\"deferred\" parameter is incompatible with \"udp\"";
  1351.         }
  1352. #endif

  1354. #ifdef IPPROTO_MPTCP
  1355.         if (lsopt.protocol == IPPROTO_MPTCP) {
  1356.             return "\"multipath\" parameter is incompatible with \"udp\"";
  1357.         }
  1358. #endif

  1360. #if (NGX_STREAM_SSL)
  1361.         if (lsopt.ssl) {
  1362.             return "\"ssl\" parameter is incompatible with \"udp\"";
  1363.         }
  1364. #endif

  1366.         if (lsopt.so_keepalive) {
  1367.             return "\"so_keepalive\" parameter is incompatible with \"udp\"";
  1368.         }

  1370.         if (lsopt.proxy_protocol) {
  1371.             return "\"proxy_protocol\" parameter is incompatible with \"udp\"";
  1372.         }
  1373.     }

  1375.     for (n = 0; n < u.naddrs; n++) {

  1377.         for (i = 0; i < n; i++) {
  1378.             if (ngx_cmp_sockaddr(u.addrs[n].sockaddr, u.addrs[n].socklen,
  1379.                                  u.addrs[i].sockaddr, u.addrs[i].socklen, 1)
  1380.                 == NGX_OK)
  1381.             {
  1382.                 goto next;
  1383.             }
  1384.         }

  1386.         lsopt.sockaddr = u.addrs[n].sockaddr;
  1387.         lsopt.socklen = u.addrs[n].socklen;
  1388.         lsopt.addr_text = u.addrs[n].name;
  1389.         lsopt.wildcard = ngx_inet_wildcard(lsopt.sockaddr);

  1391.         if (ngx_stream_add_listen(cf, cscf, &lsopt) != NGX_OK) {
  1392.             return NGX_CONF_ERROR;
  1393.         }

  1395.     next:
  1396.         continue;
  1397.     }

  1399.     return NGX_CONF_OK;
  1400. }


  1403. static char *
  1404. ‌ngx_stream_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1405. {
  1406.     ngx_stream_core_srv_conf_t *cscf = conf;

  1408.     u_char                     ch;
  1409.     ngx_str_t                 *value;
  1410.     ngx_uint_t                 i;
  1411.     ngx_stream_server_name_t  *sn;

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

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

  1417.         ch = value[i].data[0];

  1419.         if ((ch == '*' && (value[i].len < 3 || value[i].data[1] != '.'))
  1420.             || (ch == '.' && value[i].len < 2))
  1421.         {
  1422.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1423.                                "server name \"%V\" is invalid", &value[i]);
  1424.             return NGX_CONF_ERROR;
  1425.         }

  1427.         if (ngx_strchr(value[i].data, '/')) {
  1428.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1429.                                "server name \"%V\" has suspicious symbols",
  1430.                                &value[i]);
  1431.         }

  1433.         sn = ngx_array_push(&cscf->server_names);
  1434.         if (sn == NULL) {
  1435.             return NGX_CONF_ERROR;
  1436.         }

  1438. #if (NGX_PCRE)
  1439.         sn->regex = NULL;
  1440. #endif
  1441.         sn->server = cscf;

  1443.         if (ngx_strcasecmp(value[i].data, (u_char *) "$hostname") == 0) {
  1444.             sn->name = cf->cycle->hostname;

  1446.         } else {
  1447.             sn->name = value[i];
  1448.         }

  1450.         if (value[i].data[0] != '~') {
  1451.             ngx_strlow(sn->name.data, sn->name.data, sn->name.len);
  1452.             continue;
  1453.         }

  1455. #if (NGX_PCRE)
  1456.         {
  1457.         u_char               *p;
  1458.         ngx_regex_compile_t   rc;
  1459.         u_char                errstr[NGX_MAX_CONF_ERRSTR];

  1461.         if (value[i].len == 1) {
  1462.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1463.                                "empty regex in server name \"%V\"", &value[i]);
  1464.             return NGX_CONF_ERROR;
  1465.         }

  1467.         value[i].len--;
  1468.         value[i].data++;

  1470.         ngx_memzero(&rc, sizeof(ngx_regex_compile_t));

  1472.         rc.pattern = value[i];
  1473.         rc.err.len = NGX_MAX_CONF_ERRSTR;
  1474.         rc.err.data = errstr;

  1476.         for (p = value[i].data; p < value[i].data + value[i].len; p++) {
  1477.             if (*p >= 'A' && *p <= 'Z') {
  1478.                 rc.options = NGX_REGEX_CASELESS;
  1479.                 break;
  1480.             }
  1481.         }

  1483.         sn->regex = ngx_stream_regex_compile(cf, &rc);
  1484.         if (sn->regex == NULL) {
  1485.             return NGX_CONF_ERROR;
  1486.         }

  1488.         sn->name = value[i];
  1489.         cscf->captures = (rc.captures > 0);
  1490.         }
  1491. #else
  1492.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1493.                            "using regex \"%V\" "
  1494.                            "requires PCRE library", &value[i]);

  1496.         return NGX_CONF_ERROR;
  1497. #endif
  1498.     }

  1500.     return NGX_CONF_OK;
  1501. }


  1504. static char *
  1505. ‌ngx_stream_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1506. {
  1507.     ngx_stream_core_srv_conf_t  *cscf = conf;

  1509.     ngx_str_t  *value;

  1511.     if (cscf->resolver) {
  1512.         return "is duplicate";
  1513.     }

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

  1517.     cscf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  1518.     if (cscf->resolver == NULL) {
  1519.         return NGX_CONF_ERROR;
  1520.     }

  1522.     return NGX_CONF_OK;
  1523. }

One Level Up Top Level