One Level Up Top Level

src/mail/ngx_mail_core_module.c - nginx

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>
  11. #include <ngx_mail.h>


  14. static void *ngx_mail_core_create_main_conf(ngx_conf_t *cf);
  15. static void *ngx_mail_core_create_srv_conf(ngx_conf_t *cf);
  16. static char *ngx_mail_core_merge_srv_conf(ngx_conf_t *cf, void *parent,
  17.     void *child);
  18. static char *ngx_mail_core_server(ngx_conf_t *cf, ngx_command_t *cmd,
  19.     void *conf);
  20. static char *ngx_mail_core_listen(ngx_conf_t *cf, ngx_command_t *cmd,
  21.     void *conf);
  22. static char *ngx_mail_core_protocol(ngx_conf_t *cf, ngx_command_t *cmd,
  23.     void *conf);
  24. static char *ngx_mail_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd,
  25.     void *conf);
  26. static char *ngx_mail_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd,
  27.     void *conf);


  30. ‌static ngx_command_t  ngx_mail_core_commands[] = {

  32.     { ngx_string("server"),
  33.       NGX_MAIL_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  34.       ngx_mail_core_server,
  35.       0,
  36.       0,
  37.       NULL },

  39.     { ngx_string("listen"),
  40.       NGX_MAIL_SRV_CONF|NGX_CONF_1MORE,
  41.       ngx_mail_core_listen,
  42.       NGX_MAIL_SRV_CONF_OFFSET,
  43.       0,
  44.       NULL },

  46.     { ngx_string("protocol"),
  47.       NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  48.       ngx_mail_core_protocol,
  49.       NGX_MAIL_SRV_CONF_OFFSET,
  50.       0,
  51.       NULL },

  53.     { ngx_string("timeout"),
  54.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  55.       ngx_conf_set_msec_slot,
  56.       NGX_MAIL_SRV_CONF_OFFSET,
  57.       offsetof(ngx_mail_core_srv_conf_t, timeout),
  58.       NULL },

  60.     { ngx_string("server_name"),
  61.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  62.       ngx_conf_set_str_slot,
  63.       NGX_MAIL_SRV_CONF_OFFSET,
  64.       offsetof(ngx_mail_core_srv_conf_t, server_name),
  65.       NULL },

  67.     { ngx_string("error_log"),
  68.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_1MORE,
  69.       ngx_mail_core_error_log,
  70.       NGX_MAIL_SRV_CONF_OFFSET,
  71.       0,
  72.       NULL },

  74.     { ngx_string("resolver"),
  75.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_1MORE,
  76.       ngx_mail_core_resolver,
  77.       NGX_MAIL_SRV_CONF_OFFSET,
  78.       0,
  79.       NULL },

  81.     { ngx_string("resolver_timeout"),
  82.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  83.       ngx_conf_set_msec_slot,
  84.       NGX_MAIL_SRV_CONF_OFFSET,
  85.       offsetof(ngx_mail_core_srv_conf_t, resolver_timeout),
  86.       NULL },

  88.     { ngx_string("max_errors"),
  89.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  90.       ngx_conf_set_num_slot,
  91.       NGX_MAIL_SRV_CONF_OFFSET,
  92.       offsetof(ngx_mail_core_srv_conf_t, max_errors),
  93.       NULL },

  95.       ngx_null_command
  96. };


  99. ‌static ngx_mail_module_t  ngx_mail_core_module_ctx = {
  100.     NULL,                                  /* protocol */

  102.     ngx_mail_core_create_main_conf,        /* create main configuration */
  103.     NULL,                                  /* init main configuration */

  105.     ngx_mail_core_create_srv_conf,         /* create server configuration */
  106.     ngx_mail_core_merge_srv_conf           /* merge server configuration */
  107. };


  110. ‌ngx_module_t  ngx_mail_core_module = {
  111.     NGX_MODULE_V1,
  112.     &ngx_mail_core_module_ctx,             /* module context */
  113.     ngx_mail_core_commands,                /* module directives */
  114.     NGX_MAIL_MODULE,                       /* module type */
  115.     NULL,                                  /* init master */
  116.     NULL,                                  /* init module */
  117.     NULL,                                  /* init process */
  118.     NULL,                                  /* init thread */
  119.     NULL,                                  /* exit thread */
  120.     NULL,                                  /* exit process */
  121.     NULL,                                  /* exit master */
  122.     NGX_MODULE_V1_PADDING
  123. };


  126. static void *
  127. ‌ngx_mail_core_create_main_conf(ngx_conf_t *cf)
  128. {
  129.     ngx_mail_core_main_conf_t  *cmcf;

  131.     cmcf = ngx_pcalloc(cf->pool, sizeof(ngx_mail_core_main_conf_t));
  132.     if (cmcf == NULL) {
  133.         return NULL;
  134.     }

  136.     if (ngx_array_init(&cmcf->servers, cf->pool, 4,
  137.                        sizeof(ngx_mail_core_srv_conf_t *))
  138.         != NGX_OK)
  139.     {
  140.         return NULL;
  141.     }

  143.     if (ngx_array_init(&cmcf->listen, cf->pool, 4, sizeof(ngx_mail_listen_t))
  144.         != NGX_OK)
  145.     {
  146.         return NULL;
  147.     }

  149.     return cmcf;
  150. }


  153. static void *
  154. ‌ngx_mail_core_create_srv_conf(ngx_conf_t *cf)
  155. {
  156.     ngx_mail_core_srv_conf_t  *cscf;

  158.     cscf = ngx_pcalloc(cf->pool, sizeof(ngx_mail_core_srv_conf_t));
  159.     if (cscf == NULL) {
  160.         return NULL;
  161.     }

  163.     /*
  164.      * set by ngx_pcalloc():
  165.      *
  166.      *     cscf->protocol = NULL;
  167.      *     cscf->error_log = NULL;
  168.      */

  170.     cscf->timeout = NGX_CONF_UNSET_MSEC;
  171.     cscf->resolver_timeout = NGX_CONF_UNSET_MSEC;

  173.     cscf->max_errors = NGX_CONF_UNSET_UINT;

  175.     cscf->resolver = NGX_CONF_UNSET_PTR;

  177.     cscf->file_name = cf->conf_file->file.name.data;
  178.     cscf->line = cf->conf_file->line;

  180.     return cscf;
  181. }


  184. static char *
  185. ‌ngx_mail_core_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  186. {
  187.     ngx_mail_core_srv_conf_t *prev = parent;
  188.     ngx_mail_core_srv_conf_t *conf = child;

  190.     ngx_conf_merge_msec_value(conf->timeout, prev->timeout, 60000);
  191.     ngx_conf_merge_msec_value(conf->resolver_timeout, prev->resolver_timeout,
  192.                               30000);

  194.     ngx_conf_merge_uint_value(conf->max_errors, prev->max_errors, 5);

  196.     ngx_conf_merge_str_value(conf->server_name, prev->server_name, "");

  198.     if (conf->server_name.len == 0) {
  199.         conf->server_name = cf->cycle->hostname;
  200.     }

  202.     if (conf->protocol == NULL) {
  203.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  204.                       "unknown mail protocol for server in %s:%ui",
  205.                       conf->file_name, conf->line);
  206.         return NGX_CONF_ERROR;
  207.     }

  209.     if (conf->error_log == NULL) {
  210.         if (prev->error_log) {
  211.             conf->error_log = prev->error_log;
  212.         } else {
  213.             conf->error_log = &cf->cycle->new_log;
  214.         }
  215.     }

  217.     ngx_conf_merge_ptr_value(conf->resolver, prev->resolver, NULL);

  219.     return NGX_CONF_OK;
  220. }


  223. static char *
  224. ‌ngx_mail_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  225. {
  226.     char                       *rv;
  227.     void                       *mconf;
  228.     ngx_uint_t                  m;
  229.     ngx_conf_t                  pcf;
  230.     ngx_mail_module_t          *module;
  231.     ngx_mail_conf_ctx_t        *ctx, *mail_ctx;
  232.     ngx_mail_core_srv_conf_t   *cscf, **cscfp;
  233.     ngx_mail_core_main_conf_t  *cmcf;

  235.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_mail_conf_ctx_t));
  236.     if (ctx == NULL) {
  237.         return NGX_CONF_ERROR;
  238.     }

  240.     mail_ctx = cf->ctx;
  241.     ctx->main_conf = mail_ctx->main_conf;

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

  245.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_mail_max_module);
  246.     if (ctx->srv_conf == NULL) {
  247.         return NGX_CONF_ERROR;
  248.     }

  250.     for (m = 0; cf->cycle->modules[m]; m++) {
  251.         if (cf->cycle->modules[m]->type != NGX_MAIL_MODULE) {
  252.             continue;
  253.         }

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

  257.         if (module->create_srv_conf) {
  258.             mconf = module->create_srv_conf(cf);
  259.             if (mconf == NULL) {
  260.                 return NGX_CONF_ERROR;
  261.             }

  263.             ctx->srv_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  264.         }
  265.     }

  267.     /* the server configuration context */

  269.     cscf = ctx->srv_conf[ngx_mail_core_module.ctx_index];
  270.     cscf->ctx = ctx;

  272.     cmcf = ctx->main_conf[ngx_mail_core_module.ctx_index];

  274.     cscfp = ngx_array_push(&cmcf->servers);
  275.     if (cscfp == NULL) {
  276.         return NGX_CONF_ERROR;
  277.     }

  279.     *cscfp = cscf;


  282.     /* parse inside server{} */

  284.     pcf = *cf;
  285.     cf->ctx = ctx;
  286.     cf->cmd_type = NGX_MAIL_SRV_CONF;

  288.     rv = ngx_conf_parse(cf, NULL);

  290.     *cf = pcf;

  292.     if (rv == NGX_CONF_OK && !cscf->listen) {
  293.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  294.                       "no \"listen\" is defined for server in %s:%ui",
  295.                       cscf->file_name, cscf->line);
  296.         return NGX_CONF_ERROR;
  297.     }

  299.     return rv;
  300. }


  303. static char *
  304. ‌ngx_mail_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  305. {
  306.     ngx_mail_core_srv_conf_t  *cscf = conf;

  308.     ngx_str_t                  *value, size;
  309.     ngx_url_t                   u;
  310.     ngx_uint_t                  i, n, m;
  311.     ngx_mail_listen_t          *ls, *als, *nls;
  312.     ngx_mail_module_t          *module;
  313.     ngx_mail_core_main_conf_t  *cmcf;

  315.     cscf->listen = 1;

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

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

  321.     u.url = value[1];
  322.     u.listen = 1;

  324.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  325.         if (u.err) {
  326.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  327.                                "%s in \"%V\" of the \"listen\" directive",
  328.                                u.err, &u.url);
  329.         }

  331.         return NGX_CONF_ERROR;
  332.     }

  334.     cmcf = ngx_mail_conf_get_module_main_conf(cf, ngx_mail_core_module);

  336.     ls = ngx_array_push(&cmcf->listen);
  337.     if (ls == NULL) {
  338.         return NGX_CONF_ERROR;
  339.     }

  341.     ngx_memzero(ls, sizeof(ngx_mail_listen_t));

  343.     ls->backlog = NGX_LISTEN_BACKLOG;
  344.     ls->rcvbuf = -1;
  345.     ls->sndbuf = -1;
  346.     ls->ctx = cf->ctx;

  348. #if (NGX_HAVE_INET6)
  349.     ls->ipv6only = 1;
  350. #endif

  352.     if (cscf->protocol == NULL) {
  353.         for (m = 0; cf->cycle->modules[m]; m++) {
  354.             if (cf->cycle->modules[m]->type != NGX_MAIL_MODULE) {
  355.                 continue;
  356.             }

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

  360.             if (module->protocol == NULL) {
  361.                 continue;
  362.             }

  364.             for (i = 0; module->protocol->port[i]; i++) {
  365.                 if (module->protocol->port[i] == u.port) {
  366.                     cscf->protocol = module->protocol;
  367.                     break;
  368.                 }
  369.             }
  370.         }
  371.     }

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

  375.         if (ngx_strcmp(value[i].data, "bind") == 0) {
  376.             ls->bind = 1;
  377.             continue;
  378.         }

  380.         if (ngx_strncmp(value[i].data, "backlog=", 8) == 0) {
  381.             ls->backlog = ngx_atoi(value[i].data + 8, value[i].len - 8);
  382.             ls->bind = 1;

  384.             if (ls->backlog == NGX_ERROR || ls->backlog == 0) {
  385.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  386.                                    "invalid backlog \"%V\"", &value[i]);
  387.                 return NGX_CONF_ERROR;
  388.             }

  390.             continue;
  391.         }

  393.         if (ngx_strncmp(value[i].data, "rcvbuf=", 7) == 0) {
  394.             size.len = value[i].len - 7;
  395.             size.data = value[i].data + 7;

  397.             ls->rcvbuf = ngx_parse_size(&size);
  398.             ls->bind = 1;

  400.             if (ls->rcvbuf == NGX_ERROR) {
  401.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  402.                                    "invalid rcvbuf \"%V\"", &value[i]);
  403.                 return NGX_CONF_ERROR;
  404.             }

  406.             continue;
  407.         }

  409.         if (ngx_strncmp(value[i].data, "sndbuf=", 7) == 0) {
  410.             size.len = value[i].len - 7;
  411.             size.data = value[i].data + 7;

  413.             ls->sndbuf = ngx_parse_size(&size);
  414.             ls->bind = 1;

  416.             if (ls->sndbuf == NGX_ERROR) {
  417.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  418.                                    "invalid sndbuf \"%V\"", &value[i]);
  419.                 return NGX_CONF_ERROR;
  420.             }

  422.             continue;
  423.         }

  425.         if (ngx_strncmp(value[i].data, "ipv6only=o", 10) == 0) {
  426. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  427.             if (ngx_strcmp(&value[i].data[10], "n") == 0) {
  428.                 ls->ipv6only = 1;

  430.             } else if (ngx_strcmp(&value[i].data[10], "ff") == 0) {
  431.                 ls->ipv6only = 0;

  433.             } else {
  434.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  435.                                    "invalid ipv6only flags \"%s\"",
  436.                                    &value[i].data[9]);
  437.                 return NGX_CONF_ERROR;
  438.             }

  440.             ls->bind = 1;
  441.             continue;
  442. #else
  443.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  444.                                "ipv6only is not supported "
  445.                                "on this platform");
  446.             return NGX_CONF_ERROR;
  447. #endif
  448.         }

  450.         if (ngx_strcmp(value[i].data, "multipath") == 0) {
  451. #ifdef IPPROTO_MPTCP
  452.             ls->protocol = IPPROTO_MPTCP;
  453.             ls->bind = 1;
  454. #else
  455.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  456.                                "multipath is not supported "
  457.                                "on this platform, ignored");
  458. #endif
  459.             continue;
  460.         }

  462.         if (ngx_strcmp(value[i].data, "ssl") == 0) {
  463. #if (NGX_MAIL_SSL)
  464.             ngx_mail_ssl_conf_t  *sslcf;

  466.             sslcf = ngx_mail_conf_get_module_srv_conf(cf, ngx_mail_ssl_module);

  468.             sslcf->listen = 1;
  469.             sslcf->file = cf->conf_file->file.name.data;
  470.             sslcf->line = cf->conf_file->line;

  472.             ls->ssl = 1;

  474.             continue;
  475. #else
  476.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  477.                                "the \"ssl\" parameter requires "
  478.                                "ngx_mail_ssl_module");
  479.             return NGX_CONF_ERROR;
  480. #endif
  481.         }

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

  485.             if (ngx_strcmp(&value[i].data[13], "on") == 0) {
  486.                 ls->so_keepalive = 1;

  488.             } else if (ngx_strcmp(&value[i].data[13], "off") == 0) {
  489.                 ls->so_keepalive = 2;

  491.             } else {

  493. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  494.                 u_char     *p, *end;
  495.                 ngx_str_t   s;

  497.                 end = value[i].data + value[i].len;
  498.                 s.data = value[i].data + 13;

  500.                 p = ngx_strlchr(s.data, end, ':');
  501.                 if (p == NULL) {
  502.                     p = end;
  503.                 }

  505.                 if (p > s.data) {
  506.                     s.len = p - s.data;

  508.                     ls->tcp_keepidle = ngx_parse_time(&s, 1);
  509.                     if (ls->tcp_keepidle == (time_t) NGX_ERROR) {
  510.                         goto invalid_so_keepalive;
  511.                     }
  512.                 }

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

  516.                 p = ngx_strlchr(s.data, end, ':');
  517.                 if (p == NULL) {
  518.                     p = end;
  519.                 }

  521.                 if (p > s.data) {
  522.                     s.len = p - s.data;

  524.                     ls->tcp_keepintvl = ngx_parse_time(&s, 1);
  525.                     if (ls->tcp_keepintvl == (time_t) NGX_ERROR) {
  526.                         goto invalid_so_keepalive;
  527.                     }
  528.                 }

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

  532.                 if (s.data < end) {
  533.                     s.len = end - s.data;

  535.                     ls->tcp_keepcnt = ngx_atoi(s.data, s.len);
  536.                     if (ls->tcp_keepcnt == NGX_ERROR) {
  537.                         goto invalid_so_keepalive;
  538.                     }
  539.                 }

  541.                 if (ls->tcp_keepidle == 0 && ls->tcp_keepintvl == 0
  542.                     && ls->tcp_keepcnt == 0)
  543.                 {
  544.                     goto invalid_so_keepalive;
  545.                 }

  547.                 ls->so_keepalive = 1;

  549. #else

  551.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  552.                                    "the \"so_keepalive\" parameter accepts "
  553.                                    "only \"on\" or \"off\" on this platform");
  554.                 return NGX_CONF_ERROR;

  556. #endif
  557.             }

  559.             ls->bind = 1;

  561.             continue;

  563. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  564.         invalid_so_keepalive:

  566.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  567.                                "invalid so_keepalive value: \"%s\"",
  568.                                &value[i].data[13]);
  569.             return NGX_CONF_ERROR;
  570. #endif
  571.         }

  573.         if (ngx_strcmp(value[i].data, "proxy_protocol") == 0) {
  574.             ls->proxy_protocol = 1;
  575.             continue;
  576.         }

  578.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  579.                            "invalid parameter \"%V\"", &value[i]);
  580.         return NGX_CONF_ERROR;
  581.     }

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

  585.         for (i = 0; i < n; i++) {
  586.             if (ngx_cmp_sockaddr(u.addrs[n].sockaddr, u.addrs[n].socklen,
  587.                                  u.addrs[i].sockaddr, u.addrs[i].socklen, 1)
  588.                 == NGX_OK)
  589.             {
  590.                 goto next;
  591.             }
  592.         }

  594.         if (n != 0) {
  595.             nls = ngx_array_push(&cmcf->listen);
  596.             if (nls == NULL) {
  597.                 return NGX_CONF_ERROR;
  598.             }

  600.             *nls = *ls;

  602.         } else {
  603.             nls = ls;
  604.         }

  606.         nls->sockaddr = u.addrs[n].sockaddr;
  607.         nls->socklen = u.addrs[n].socklen;
  608.         nls->addr_text = u.addrs[n].name;
  609.         nls->wildcard = ngx_inet_wildcard(nls->sockaddr);

  611.         als = cmcf->listen.elts;

  613.         for (i = 0; i < cmcf->listen.nelts - 1; i++) {

  615.             if (ngx_cmp_sockaddr(als[i].sockaddr, als[i].socklen,
  616.                                  nls->sockaddr, nls->socklen, 1)
  617.                 != NGX_OK)
  618.             {
  619.                 continue;
  620.             }

  622.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  623.                                "duplicate \"%V\" address and port pair",
  624.                                &nls->addr_text);
  625.             return NGX_CONF_ERROR;
  626.         }

  628.     next:
  629.         continue;
  630.     }

  632.     return NGX_CONF_OK;
  633. }


  636. static char *
  637. ‌ngx_mail_core_protocol(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  638. {
  639.     ngx_mail_core_srv_conf_t  *cscf = conf;

  641.     ngx_str_t          *value;
  642.     ngx_uint_t          m;
  643.     ngx_mail_module_t  *module;

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

  647.     for (m = 0; cf->cycle->modules[m]; m++) {
  648.         if (cf->cycle->modules[m]->type != NGX_MAIL_MODULE) {
  649.             continue;
  650.         }

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

  654.         if (module->protocol
  655.             && ngx_strcmp(module->protocol->name.data, value[1].data) == 0)
  656.         {
  657.             cscf->protocol = module->protocol;

  659.             return NGX_CONF_OK;
  660.         }
  661.     }

  663.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  664.                        "unknown protocol \"%V\"", &value[1]);
  665.     return NGX_CONF_ERROR;
  666. }


  669. static char *
  670. ‌ngx_mail_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  671. {
  672.     ngx_mail_core_srv_conf_t  *cscf = conf;

  674.     return ngx_log_set_log(cf, &cscf->error_log);
  675. }


  678. static char *
  679. ‌ngx_mail_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  680. {
  681.     ngx_mail_core_srv_conf_t  *cscf = conf;

  683.     ngx_str_t  *value;

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

  687.     if (cscf->resolver != NGX_CONF_UNSET_PTR) {
  688.         return "is duplicate";
  689.     }

  691.     if (ngx_strcmp(value[1].data, "off") == 0) {
  692.         cscf->resolver = NULL;
  693.         return NGX_CONF_OK;
  694.     }

  696.     cscf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  697.     if (cscf->resolver == NULL) {
  698.         return NGX_CONF_ERROR;
  699.     }

  701.     return NGX_CONF_OK;
  702. }


  705. char *
  706. ‌ngx_mail_capabilities(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  707. {
  708.     char  *p = conf;

  710.     ngx_str_t    *c, *value;
  711.     ngx_uint_t    i;
  712.     ngx_array_t  *a;

  714.     a = (ngx_array_t *) (p + cmd->offset);

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

  718.     for (i = 1; i < cf->args->nelts; i++) {
  719.         c = ngx_array_push(a);
  720.         if (c == NULL) {
  721.             return NGX_CONF_ERROR;
  722.         }

  724.         *c = value[i];
  725.     }

  727.     return NGX_CONF_OK;
  728. }

One Level Up Top Level