One Level Up Top Level

src/stream/ngx_stream_core_module.c - nginx source code

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Roman Arutyunyan
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_stream.h>


  13. 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;

  480. ‌    enum {
  481.         sw_usual = 0,
  482.         sw_literal,
  483.         sw_rest
  484.     } state;

  486.     dot_pos = host->len;
  487.     host_len = host->len;

  489.     h = host->data;

  491.     state = sw_usual;

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

  496.         switch (ch) {

  498.         case '.':
  499.             if (dot_pos == i - 1) {
  500.                 return NGX_DECLINED;
  501.             }
  502.             dot_pos = i;
  503.             break;

  505.         case ':':
  506.             if (state == sw_usual) {
  507.                 host_len = i;
  508.                 state = sw_rest;
  509.             }
  510.             break;

  512.         case '[':
  513.             if (i == 0) {
  514.                 state = sw_literal;
  515.             }
  516.             break;

  518.         case ']':
  519.             if (state == sw_literal) {
  520.                 host_len = i + 1;
  521.                 state = sw_rest;
  522.             }
  523.             break;

  525.         default:

  527.             if (ngx_path_separator(ch)) {
  528.                 return NGX_DECLINED;
  529.             }

  531.             if (ch <= 0x20 || ch == 0x7f) {
  532.                 return NGX_DECLINED;
  533.             }

  535.             if (ch >= 'A' && ch <= 'Z') {
  536.                 alloc = 1;
  537.             }

  539.             break;
  540.         }
  541.     }

  543.     if (dot_pos == host_len - 1) {
  544.         host_len--;
  545.     }

  547.     if (host_len == 0) {
  548.         return NGX_DECLINED;
  549.     }

  551.     if (alloc) {
  552.         host->data = ngx_pnalloc(pool, host_len);
  553.         if (host->data == NULL) {
  554.             return NGX_ERROR;
  555.         }

  557.         ngx_strlow(host->data, h, host_len);
  558.     }

  560.     host->len = host_len;

  562.     return NGX_OK;
  563. }


  566. ngx_int_t
  567. ‌ngx_stream_find_virtual_server(ngx_stream_session_t *s,
  568.     ngx_str_t *host, ngx_stream_core_srv_conf_t **cscfp)
  569. {
  570.     ngx_stream_core_srv_conf_t  *cscf;

  572.     if (s->virtual_names == NULL) {
  573.         return NGX_DECLINED;
  574.     }

  576.     cscf = ngx_hash_find_combined(&s->virtual_names->names,
  577.                                   ngx_hash_key(host->data, host->len),
  578.                                   host->data, host->len);

  580.     if (cscf) {
  581.         *cscfp = cscf;
  582.         return NGX_OK;
  583.     }

  585. #if (NGX_PCRE)

  587.     if (host->len && s->virtual_names->nregex) {
  588.         ngx_int_t                  n;
  589.         ngx_uint_t                 i;
  590.         ngx_stream_server_name_t  *sn;

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

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

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

  598.             if (n == NGX_DECLINED) {
  599.                 continue;
  600.             }

  602.             if (n == NGX_OK) {
  603.                 *cscfp = sn[i].server;
  604.                 return NGX_OK;
  605.             }

  607.             return NGX_ERROR;
  608.         }
  609.     }

  611. #endif /* NGX_PCRE */

  613.     return NGX_DECLINED;
  614. }


  617. static ngx_int_t
  618. ‌ngx_stream_core_preconfiguration(ngx_conf_t *cf)
  619. {
  620.     return ngx_stream_variables_add_core_vars(cf);
  621. }


  624. static void *
  625. ‌ngx_stream_core_create_main_conf(ngx_conf_t *cf)
  626. {
  627.     ngx_stream_core_main_conf_t  *cmcf;

  629.     cmcf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_core_main_conf_t));
  630.     if (cmcf == NULL) {
  631.         return NULL;
  632.     }

  634.     if (ngx_array_init(&cmcf->servers, cf->pool, 4,
  635.                        sizeof(ngx_stream_core_srv_conf_t *))
  636.         != NGX_OK)
  637.     {
  638.         return NULL;
  639.     }

  641.     cmcf->server_names_hash_max_size = NGX_CONF_UNSET_UINT;
  642.     cmcf->server_names_hash_bucket_size = NGX_CONF_UNSET_UINT;

  644.     cmcf->variables_hash_max_size = NGX_CONF_UNSET_UINT;
  645.     cmcf->variables_hash_bucket_size = NGX_CONF_UNSET_UINT;

  647.     return cmcf;
  648. }


  651. static char *
  652. ‌ngx_stream_core_init_main_conf(ngx_conf_t *cf, void *conf)
  653. {
  654.     ngx_stream_core_main_conf_t *cmcf = conf;

  656.     ngx_conf_init_uint_value(cmcf->server_names_hash_max_size, 512);
  657.     ngx_conf_init_uint_value(cmcf->server_names_hash_bucket_size,
  658.                              ngx_cacheline_size);

  660.     cmcf->server_names_hash_bucket_size =
  661.             ngx_align(cmcf->server_names_hash_bucket_size, ngx_cacheline_size);


  664.     ngx_conf_init_uint_value(cmcf->variables_hash_max_size, 1024);
  665.     ngx_conf_init_uint_value(cmcf->variables_hash_bucket_size, 64);

  667.     cmcf->variables_hash_bucket_size =
  668.                ngx_align(cmcf->variables_hash_bucket_size, ngx_cacheline_size);

  670.     if (cmcf->ncaptures) {
  671.         cmcf->ncaptures = (cmcf->ncaptures + 1) * 3;
  672.     }

  674.     return NGX_CONF_OK;
  675. }


  678. static void *
  679. ‌ngx_stream_core_create_srv_conf(ngx_conf_t *cf)
  680. {
  681.     ngx_stream_core_srv_conf_t  *cscf;

  683.     cscf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_core_srv_conf_t));
  684.     if (cscf == NULL) {
  685.         return NULL;
  686.     }

  688.     /*
  689.      * set by ngx_pcalloc():
  690.      *
  691.      *     cscf->handler = NULL;
  692.      *     cscf->error_log = NULL;
  693.      */

  695.     if (ngx_array_init(&cscf->server_names, cf->temp_pool, 4,
  696.                        sizeof(ngx_stream_server_name_t))
  697.         != NGX_OK)
  698.     {
  699.         return NULL;
  700.     }

  702.     cscf->file_name = cf->conf_file->file.name.data;
  703.     cscf->line = cf->conf_file->line;
  704.     cscf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  705.     cscf->proxy_protocol_timeout = NGX_CONF_UNSET_MSEC;
  706.     cscf->tcp_nodelay = NGX_CONF_UNSET;
  707.     cscf->preread_buffer_size = NGX_CONF_UNSET_SIZE;
  708.     cscf->preread_timeout = NGX_CONF_UNSET_MSEC;

  710.     return cscf;
  711. }


  714. static char *
  715. ‌ngx_stream_core_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  716. {
  717.     ngx_stream_core_srv_conf_t *prev = parent;
  718.     ngx_stream_core_srv_conf_t *conf = child;

  720.     ngx_str_t                  name;
  721.     ngx_stream_server_name_t  *sn;

  723.     ngx_conf_merge_msec_value(conf->resolver_timeout,
  724.                               prev->resolver_timeout, 30000);

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

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

  730.             /*
  731.              * create dummy resolver in stream {} context
  732.              * to inherit it in all servers
  733.              */

  735.             prev->resolver = ngx_resolver_create(cf, NULL, 0);
  736.             if (prev->resolver == NULL) {
  737.                 return NGX_CONF_ERROR;
  738.             }
  739.         }

  741.         conf->resolver = prev->resolver;
  742.     }

  744.     if (conf->error_log == NULL) {
  745.         if (prev->error_log) {
  746.             conf->error_log = prev->error_log;
  747.         } else {
  748.             conf->error_log = &cf->cycle->new_log;
  749.         }
  750.     }

  752.     ngx_conf_merge_msec_value(conf->proxy_protocol_timeout,
  753.                               prev->proxy_protocol_timeout, 30000);

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

  757.     ngx_conf_merge_size_value(conf->preread_buffer_size,
  758.                               prev->preread_buffer_size, 16384);

  760.     ngx_conf_merge_msec_value(conf->preread_timeout,
  761.                               prev->preread_timeout, 30000);

  763.     if (conf->server_names.nelts == 0) {
  764.         /* the array has 4 empty preallocated elements, so push cannot fail */
  765.         sn = ngx_array_push(&conf->server_names);
  766. #if (NGX_PCRE)
  767.         sn->regex = NULL;
  768. #endif
  769.         sn->server = conf;
  770.         ngx_str_set(&sn->name, "");
  771.     }

  773.     sn = conf->server_names.elts;
  774.     name = sn[0].name;

  776. #if (NGX_PCRE)
  777.     if (sn->regex) {
  778.         name.len++;
  779.         name.data--;
  780.     } else
  781. #endif

  783.     if (name.data[0] == '.') {
  784.         name.len--;
  785.         name.data++;
  786.     }

  788.     conf->server_name.len = name.len;
  789.     conf->server_name.data = ngx_pstrdup(cf->pool, &name);
  790.     if (conf->server_name.data == NULL) {
  791.         return NGX_CONF_ERROR;
  792.     }

  794.     return NGX_CONF_OK;
  795. }


  798. static char *
  799. ‌ngx_stream_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  800. {
  801.     ngx_stream_core_srv_conf_t  *cscf = conf;

  803.     return ngx_log_set_log(cf, &cscf->error_log);
  804. }


  807. static char *
  808. ‌ngx_stream_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  809. {
  810.     char                         *rv;
  811.     void                         *mconf;
  812.     ngx_uint_t                    m;
  813.     ngx_conf_t                    pcf;
  814.     ngx_stream_module_t          *module;
  815.     ngx_stream_conf_ctx_t        *ctx, *stream_ctx;
  816.     ngx_stream_core_srv_conf_t   *cscf, **cscfp;
  817.     ngx_stream_core_main_conf_t  *cmcf;

  819.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_stream_conf_ctx_t));
  820.     if (ctx == NULL) {
  821.         return NGX_CONF_ERROR;
  822.     }

  824.     stream_ctx = cf->ctx;
  825.     ctx->main_conf = stream_ctx->main_conf;

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

  829.     ctx->srv_conf = ngx_pcalloc(cf->pool,
  830.                                 sizeof(void *) * ngx_stream_max_module);
  831.     if (ctx->srv_conf == NULL) {
  832.         return NGX_CONF_ERROR;
  833.     }

  835.     for (m = 0; cf->cycle->modules[m]; m++) {
  836.         if (cf->cycle->modules[m]->type != NGX_STREAM_MODULE) {
  837.             continue;
  838.         }

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

  842.         if (module->create_srv_conf) {
  843.             mconf = module->create_srv_conf(cf);
  844.             if (mconf == NULL) {
  845.                 return NGX_CONF_ERROR;
  846.             }

  848.             ctx->srv_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  849.         }
  850.     }

  852.     /* the server configuration context */

  854.     cscf = ctx->srv_conf[ngx_stream_core_module.ctx_index];
  855.     cscf->ctx = ctx;

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

  859.     cscfp = ngx_array_push(&cmcf->servers);
  860.     if (cscfp == NULL) {
  861.         return NGX_CONF_ERROR;
  862.     }

  864.     *cscfp = cscf;


  867.     /* parse inside server{} */

  869.     pcf = *cf;
  870.     cf->ctx = ctx;
  871.     cf->cmd_type = NGX_STREAM_SRV_CONF;

  873.     rv = ngx_conf_parse(cf, NULL);

  875.     *cf = pcf;

  877.     if (rv == NGX_CONF_OK && !cscf->listen) {
  878.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  879.                       "no \"listen\" is defined for server in %s:%ui",
  880.                       cscf->file_name, cscf->line);
  881.         return NGX_CONF_ERROR;
  882.     }

  884.     return rv;
  885. }


  888. static char *
  889. ‌ngx_stream_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  890. {
  891.     ngx_stream_core_srv_conf_t  *cscf = conf;

  893.     ngx_str_t                *value, size;
  894.     ngx_url_t                 u;
  895.     ngx_uint_t                n, i, backlog;
  896.     ngx_stream_listen_opt_t   lsopt;

  898.     cscf->listen = 1;

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

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

  904.     u.url = value[1];
  905.     u.listen = 1;

  907.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  908.         if (u.err) {
  909.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  910.                                "%s in \"%V\" of the \"listen\" directive",
  911.                                u.err, &u.url);
  912.         }

  914.         return NGX_CONF_ERROR;
  915.     }

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

  919.     lsopt.backlog = NGX_LISTEN_BACKLOG;
  920.     lsopt.type = SOCK_STREAM;
  921.     lsopt.rcvbuf = -1;
  922.     lsopt.sndbuf = -1;
  923. #if (NGX_HAVE_SETFIB)
  924.     lsopt.setfib = -1;
  925. #endif
  926. #if (NGX_HAVE_TCP_FASTOPEN)
  927.     lsopt.fastopen = -1;
  928. #endif
  929. #if (NGX_HAVE_INET6)
  930.     lsopt.ipv6only = 1;
  931. #endif

  933.     backlog = 0;

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

  937.         if (ngx_strcmp(value[i].data, "default_server") == 0) {
  938.             lsopt.default_server = 1;
  939.             continue;
  940.         }

  942. #if !(NGX_WIN32)
  943.         if (ngx_strcmp(value[i].data, "udp") == 0) {
  944.             lsopt.type = SOCK_DGRAM;
  945.             continue;
  946.         }
  947. #endif

  949.         if (ngx_strcmp(value[i].data, "bind") == 0) {
  950.             lsopt.set = 1;
  951.             lsopt.bind = 1;
  952.             continue;
  953.         }

  955. #if (NGX_HAVE_SETFIB)
  956.         if (ngx_strncmp(value[i].data, "setfib=", 7) == 0) {
  957.             lsopt.setfib = ngx_atoi(value[i].data + 7, value[i].len - 7);
  958.             lsopt.set = 1;
  959.             lsopt.bind = 1;

  961.             if (lsopt.setfib == NGX_ERROR) {
  962.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  963.                                    "invalid setfib \"%V\"", &value[i]);
  964.                 return NGX_CONF_ERROR;
  965.             }

  967.             continue;
  968.         }
  969. #endif

  971. #if (NGX_HAVE_TCP_FASTOPEN)
  972.         if (ngx_strncmp(value[i].data, "fastopen=", 9) == 0) {
  973.             lsopt.fastopen = ngx_atoi(value[i].data + 9, value[i].len - 9);
  974.             lsopt.set = 1;
  975.             lsopt.bind = 1;

  977.             if (lsopt.fastopen == NGX_ERROR) {
  978.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  979.                                    "invalid fastopen \"%V\"", &value[i]);
  980.                 return NGX_CONF_ERROR;
  981.             }

  983.             continue;
  984.         }
  985. #endif

  987.         if (ngx_strncmp(value[i].data, "backlog=", 8) == 0) {
  988.             lsopt.backlog = ngx_atoi(value[i].data + 8, value[i].len - 8);
  989.             lsopt.set = 1;
  990.             lsopt.bind = 1;

  992.             if (lsopt.backlog == NGX_ERROR || lsopt.backlog == 0) {
  993.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  994.                                    "invalid backlog \"%V\"", &value[i]);
  995.                 return NGX_CONF_ERROR;
  996.             }

  998.             backlog = 1;

  1000.             continue;
  1001.         }

  1003.         if (ngx_strncmp(value[i].data, "rcvbuf=", 7) == 0) {
  1004.             size.len = value[i].len - 7;
  1005.             size.data = value[i].data + 7;

  1007.             lsopt.rcvbuf = ngx_parse_size(&size);
  1008.             lsopt.set = 1;
  1009.             lsopt.bind = 1;

  1011.             if (lsopt.rcvbuf == NGX_ERROR) {
  1012.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1013.                                    "invalid rcvbuf \"%V\"", &value[i]);
  1014.                 return NGX_CONF_ERROR;
  1015.             }

  1017.             continue;
  1018.         }

  1020.         if (ngx_strncmp(value[i].data, "sndbuf=", 7) == 0) {
  1021.             size.len = value[i].len - 7;
  1022.             size.data = value[i].data + 7;

  1024.             lsopt.sndbuf = ngx_parse_size(&size);
  1025.             lsopt.set = 1;
  1026.             lsopt.bind = 1;

  1028.             if (lsopt.sndbuf == NGX_ERROR) {
  1029.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1030.                                    "invalid sndbuf \"%V\"", &value[i]);
  1031.                 return NGX_CONF_ERROR;
  1032.             }

  1034.             continue;
  1035.         }

  1037.         if (ngx_strncmp(value[i].data, "accept_filter=", 14) == 0) {
  1038. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  1039.             lsopt.accept_filter = (char *) &value[i].data[14];
  1040.             lsopt.set = 1;
  1041.             lsopt.bind = 1;
  1042. #else
  1043.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1044.                                "accept filters \"%V\" are not supported "
  1045.                                "on this platform, ignored",
  1046.                                &value[i]);
  1047. #endif
  1048.             continue;
  1049.         }

  1051.         if (ngx_strcmp(value[i].data, "deferred") == 0) {
  1052. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  1053.             lsopt.deferred_accept = 1;
  1054.             lsopt.set = 1;
  1055.             lsopt.bind = 1;
  1056. #else
  1057.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1058.                                "the deferred accept is not supported "
  1059.                                "on this platform, ignored");
  1060. #endif
  1061.             continue;
  1062.         }

  1064.         if (ngx_strncmp(value[i].data, "ipv6only=o", 10) == 0) {
  1065. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  1066.             if (ngx_strcmp(&value[i].data[10], "n") == 0) {
  1067.                 lsopt.ipv6only = 1;

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

  1072.             } else {
  1073.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1074.                                    "invalid ipv6only flags \"%s\"",
  1075.                                    &value[i].data[9]);
  1076.                 return NGX_CONF_ERROR;
  1077.             }

  1079.             lsopt.set = 1;
  1080.             lsopt.bind = 1;

  1082.             continue;
  1083. #else
  1084.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1085.                                "ipv6only is not supported "
  1086.                                "on this platform");
  1087.             return NGX_CONF_ERROR;
  1088. #endif
  1089.         }

  1091.         if (ngx_strcmp(value[i].data, "reuseport") == 0) {
  1092. #if (NGX_HAVE_REUSEPORT)
  1093.             lsopt.reuseport = 1;
  1094.             lsopt.set = 1;
  1095.             lsopt.bind = 1;
  1096. #else
  1097.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1098.                                "reuseport is not supported "
  1099.                                "on this platform, ignored");
  1100. #endif
  1101.             continue;
  1102.         }

  1104.         if (ngx_strcmp(value[i].data, "ssl") == 0) {
  1105. #if (NGX_STREAM_SSL)
  1106.             lsopt.ssl = 1;
  1107.             continue;
  1108. #else
  1109.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1110.                                "the \"ssl\" parameter requires "
  1111.                                "ngx_stream_ssl_module");
  1112.             return NGX_CONF_ERROR;
  1113. #endif
  1114.         }

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

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

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

  1124.             } else {

  1126. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  1127.                 u_char     *p, *end;
  1128.                 ngx_str_t   s;

  1130.                 end = value[i].data + value[i].len;
  1131.                 s.data = value[i].data + 13;

  1133.                 p = ngx_strlchr(s.data, end, ':');
  1134.                 if (p == NULL) {
  1135.                     p = end;
  1136.                 }

  1138.                 if (p > s.data) {
  1139.                     s.len = p - s.data;

  1141.                     lsopt.tcp_keepidle = ngx_parse_time(&s, 1);
  1142.                     if (lsopt.tcp_keepidle == (time_t) NGX_ERROR) {
  1143.                         goto invalid_so_keepalive;
  1144.                     }
  1145.                 }

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

  1149.                 p = ngx_strlchr(s.data, end, ':');
  1150.                 if (p == NULL) {
  1151.                     p = end;
  1152.                 }

  1154.                 if (p > s.data) {
  1155.                     s.len = p - s.data;

  1157.                     lsopt.tcp_keepintvl = ngx_parse_time(&s, 1);
  1158.                     if (lsopt.tcp_keepintvl == (time_t) NGX_ERROR) {
  1159.                         goto invalid_so_keepalive;
  1160.                     }
  1161.                 }

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

  1165.                 if (s.data < end) {
  1166.                     s.len = end - s.data;

  1168.                     lsopt.tcp_keepcnt = ngx_atoi(s.data, s.len);
  1169.                     if (lsopt.tcp_keepcnt == NGX_ERROR) {
  1170.                         goto invalid_so_keepalive;
  1171.                     }
  1172.                 }

  1174.                 if (lsopt.tcp_keepidle == 0 && lsopt.tcp_keepintvl == 0
  1175.                     && lsopt.tcp_keepcnt == 0)
  1176.                 {
  1177.                     goto invalid_so_keepalive;
  1178.                 }

  1180.                 lsopt.so_keepalive = 1;

  1182. #else

  1184.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1185.                                    "the \"so_keepalive\" parameter accepts "
  1186.                                    "only \"on\" or \"off\" on this platform");
  1187.                 return NGX_CONF_ERROR;

  1189. #endif
  1190.             }

  1192.             lsopt.set = 1;
  1193.             lsopt.bind = 1;

  1195.             continue;

  1197. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  1198.         invalid_so_keepalive:

  1200.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1201.                                "invalid so_keepalive value: \"%s\"",
  1202.                                &value[i].data[13]);
  1203.             return NGX_CONF_ERROR;
  1204. #endif
  1205.         }

  1207.         if (ngx_strcmp(value[i].data, "proxy_protocol") == 0) {
  1208.             lsopt.proxy_protocol = 1;
  1209.             continue;
  1210.         }

  1212.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1213.                            "invalid parameter \"%V\"", &value[i]);
  1214.         return NGX_CONF_ERROR;
  1215.     }

  1217.     if (lsopt.type == SOCK_DGRAM) {
  1218. #if (NGX_HAVE_TCP_FASTOPEN)
  1219.         if (lsopt.fastopen != -1) {
  1220.             return "\"fastopen\" parameter is incompatible with \"udp\"";
  1221.         }
  1222. #endif

  1224.         if (backlog) {
  1225.             return "\"backlog\" parameter is incompatible with \"udp\"";
  1226.         }

  1228. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  1229.         if (lsopt.accept_filter) {
  1230.             return "\"accept_filter\" parameter is incompatible with \"udp\"";
  1231.         }
  1232. #endif

  1234. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  1235.         if (lsopt.deferred_accept) {
  1236.             return "\"deferred\" parameter is incompatible with \"udp\"";
  1237.         }
  1238. #endif

  1240. #if (NGX_STREAM_SSL)
  1241.         if (lsopt.ssl) {
  1242.             return "\"ssl\" parameter is incompatible with \"udp\"";
  1243.         }
  1244. #endif

  1246.         if (lsopt.so_keepalive) {
  1247.             return "\"so_keepalive\" parameter is incompatible with \"udp\"";
  1248.         }

  1250.         if (lsopt.proxy_protocol) {
  1251.             return "\"proxy_protocol\" parameter is incompatible with \"udp\"";
  1252.         }
  1253.     }

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

  1257.         for (i = 0; i < n; i++) {
  1258.             if (ngx_cmp_sockaddr(u.addrs[n].sockaddr, u.addrs[n].socklen,
  1259.                                  u.addrs[i].sockaddr, u.addrs[i].socklen, 1)
  1260.                 == NGX_OK)
  1261.             {
  1262.                 goto next;
  1263.             }
  1264.         }

  1266.         lsopt.sockaddr = u.addrs[n].sockaddr;
  1267.         lsopt.socklen = u.addrs[n].socklen;
  1268.         lsopt.addr_text = u.addrs[n].name;
  1269.         lsopt.wildcard = ngx_inet_wildcard(lsopt.sockaddr);

  1271.         if (ngx_stream_add_listen(cf, cscf, &lsopt) != NGX_OK) {
  1272.             return NGX_CONF_ERROR;
  1273.         }

  1275.     next:
  1276.         continue;
  1277.     }

  1279.     return NGX_CONF_OK;
  1280. }


  1283. static char *
  1284. ‌ngx_stream_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1285. {
  1286.     ngx_stream_core_srv_conf_t *cscf = conf;

  1288.     u_char                     ch;
  1289.     ngx_str_t                 *value;
  1290.     ngx_uint_t                 i;
  1291.     ngx_stream_server_name_t  *sn;

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

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

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

  1299.         if ((ch == '*' && (value[i].len < 3 || value[i].data[1] != '.'))
  1300.             || (ch == '.' && value[i].len < 2))
  1301.         {
  1302.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1303.                                "server name \"%V\" is invalid", &value[i]);
  1304.             return NGX_CONF_ERROR;
  1305.         }

  1307.         if (ngx_strchr(value[i].data, '/')) {
  1308.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1309.                                "server name \"%V\" has suspicious symbols",
  1310.                                &value[i]);
  1311.         }

  1313.         sn = ngx_array_push(&cscf->server_names);
  1314.         if (sn == NULL) {
  1315.             return NGX_CONF_ERROR;
  1316.         }

  1318. #if (NGX_PCRE)
  1319.         sn->regex = NULL;
  1320. #endif
  1321.         sn->server = cscf;

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

  1326.         } else {
  1327.             sn->name = value[i];
  1328.         }

  1330.         if (value[i].data[0] != '~') {
  1331.             ngx_strlow(sn->name.data, sn->name.data, sn->name.len);
  1332.             continue;
  1333.         }

  1335. #if (NGX_PCRE)
  1336.         {
  1337.         u_char               *p;
  1338.         ngx_regex_compile_t   rc;
  1339.         u_char                errstr[NGX_MAX_CONF_ERRSTR];

  1341.         if (value[i].len == 1) {
  1342.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1343.                                "empty regex in server name \"%V\"", &value[i]);
  1344.             return NGX_CONF_ERROR;
  1345.         }

  1347.         value[i].len--;
  1348.         value[i].data++;

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

  1352.         rc.pattern = value[i];
  1353.         rc.err.len = NGX_MAX_CONF_ERRSTR;
  1354.         rc.err.data = errstr;

  1356.         for (p = value[i].data; p < value[i].data + value[i].len; p++) {
  1357.             if (*p >= 'A' && *p <= 'Z') {
  1358.                 rc.options = NGX_REGEX_CASELESS;
  1359.                 break;
  1360.             }
  1361.         }

  1363.         sn->regex = ngx_stream_regex_compile(cf, &rc);
  1364.         if (sn->regex == NULL) {
  1365.             return NGX_CONF_ERROR;
  1366.         }

  1368.         sn->name = value[i];
  1369.         cscf->captures = (rc.captures > 0);
  1370.         }
  1371. #else
  1372.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1373.                            "using regex \"%V\" "
  1374.                            "requires PCRE library", &value[i]);

  1376.         return NGX_CONF_ERROR;
  1377. #endif
  1378.     }

  1380.     return NGX_CONF_OK;
  1381. }


  1384. static char *
  1385. ‌ngx_stream_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1386. {
  1387.     ngx_stream_core_srv_conf_t  *cscf = conf;

  1389.     ngx_str_t  *value;

  1391.     if (cscf->resolver) {
  1392.         return "is duplicate";
  1393.     }

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

  1397.     cscf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  1398.     if (cscf->resolver == NULL) {
  1399.         return NGX_CONF_ERROR;
  1400.     }

  1402.     return NGX_CONF_OK;
  1403. }

One Level Up Top Level