One Level Up Top Level

src/mail/ngx_mail.c - nginx-1.7.10

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 char *ngx_mail_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  15. static ngx_int_t ngx_mail_add_ports(ngx_conf_t *cf, ngx_array_t *ports,
  16.     ngx_mail_listen_t *listen);
  17. static char *ngx_mail_optimize_servers(ngx_conf_t *cf, ngx_array_t *ports);
  18. static ngx_int_t ngx_mail_add_addrs(ngx_conf_t *cf, ngx_mail_port_t *mport,
  19.     ngx_mail_conf_addr_t *addr);
  20. #if (NGX_HAVE_INET6)
  21. static ngx_int_t ngx_mail_add_addrs6(ngx_conf_t *cf, ngx_mail_port_t *mport,
  22.     ngx_mail_conf_addr_t *addr);
  23. #endif
  24. static ngx_int_t ngx_mail_cmp_conf_addrs(const void *one, const void *two);


  27. ‌ngx_uint_t  ngx_mail_max_module;


  30. ‌static ngx_command_t  ngx_mail_commands[] = {

  32.     { ngx_string("mail"),
  33.       NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  34.       ngx_mail_block,
  35.       0,
  36.       0,
  37.       NULL },

  39.     { ngx_string("imap"),
  40.       NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  41.       ngx_mail_block,
  42.       0,
  43.       0,
  44.       NULL },

  46.       ngx_null_command
  47. };


  50. ‌static ngx_core_module_t  ngx_mail_module_ctx = {
  51.     ngx_string("mail"),
  52.     NULL,
  53.     NULL
  54. };


  57. ‌ngx_module_t  ngx_mail_module = {
  58.     NGX_MODULE_V1,
  59.     &ngx_mail_module_ctx,                  /* module context */
  60.     ngx_mail_commands,                     /* module directives */
  61.     NGX_CORE_MODULE,                       /* module type */
  62.     NULL,                                  /* init master */
  63.     NULL,                                  /* init module */
  64.     NULL,                                  /* init process */
  65.     NULL,                                  /* init thread */
  66.     NULL,                                  /* exit thread */
  67.     NULL,                                  /* exit process */
  68.     NULL,                                  /* exit master */
  69.     NGX_MODULE_V1_PADDING
  70. };


  73. static char *
  74. ‌ngx_mail_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  75. {
  76.     char                        *rv;
  77.     ngx_uint_t                   i, m, mi, s;
  78.     ngx_conf_t                   pcf;
  79.     ngx_array_t                  ports;
  80.     ngx_mail_listen_t           *listen;
  81.     ngx_mail_module_t           *module;
  82.     ngx_mail_conf_ctx_t         *ctx;
  83.     ngx_mail_core_srv_conf_t   **cscfp;
  84.     ngx_mail_core_main_conf_t   *cmcf;

  86.     if (cmd->name.data[0] == 'i') {
  87.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  88.                            "the \"imap\" directive is deprecated, "
  89.                            "use the \"mail\" directive instead");
  90.     }

  92.     /* the main mail context */

  94.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_mail_conf_ctx_t));
  95.     if (ctx == NULL) {
  96.         return NGX_CONF_ERROR;
  97.     }

  99.     *(ngx_mail_conf_ctx_t **) conf = ctx;

  101.     /* count the number of the http modules and set up their indices */

  103.     ngx_mail_max_module = 0;
  104.     for (m = 0; ngx_modules[m]; m++) {
  105.         if (ngx_modules[m]->type != NGX_MAIL_MODULE) {
  106.             continue;
  107.         }

  109.         ngx_modules[m]->ctx_index = ngx_mail_max_module++;
  110.     }


  113.     /* the mail main_conf context, it is the same in the all mail contexts */

  115.     ctx->main_conf = ngx_pcalloc(cf->pool,
  116.                                  sizeof(void *) * ngx_mail_max_module);
  117.     if (ctx->main_conf == NULL) {
  118.         return NGX_CONF_ERROR;
  119.     }


  122.     /*
  123.      * the mail null srv_conf context, it is used to merge
  124.      * the server{}s' srv_conf's
  125.      */

  127.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_mail_max_module);
  128.     if (ctx->srv_conf == NULL) {
  129.         return NGX_CONF_ERROR;
  130.     }


  133.     /*
  134.      * create the main_conf's and the null srv_conf's of the all mail modules
  135.      */

  137.     for (m = 0; ngx_modules[m]; m++) {
  138.         if (ngx_modules[m]->type != NGX_MAIL_MODULE) {
  139.             continue;
  140.         }

  142.         module = ngx_modules[m]->ctx;
  143.         mi = ngx_modules[m]->ctx_index;

  145.         if (module->create_main_conf) {
  146.             ctx->main_conf[mi] = module->create_main_conf(cf);
  147.             if (ctx->main_conf[mi] == NULL) {
  148.                 return NGX_CONF_ERROR;
  149.             }
  150.         }

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


  161.     /* parse inside the mail{} block */

  163.     pcf = *cf;
  164.     cf->ctx = ctx;

  166.     cf->module_type = NGX_MAIL_MODULE;
  167.     cf->cmd_type = NGX_MAIL_MAIN_CONF;
  168.     rv = ngx_conf_parse(cf, NULL);

  170.     if (rv != NGX_CONF_OK) {
  171.         *cf = pcf;
  172.         return rv;
  173.     }


  176.     /* init mail{} main_conf's, merge the server{}s' srv_conf's */

  178.     cmcf = ctx->main_conf[ngx_mail_core_module.ctx_index];
  179.     cscfp = cmcf->servers.elts;

  181.     for (m = 0; ngx_modules[m]; m++) {
  182.         if (ngx_modules[m]->type != NGX_MAIL_MODULE) {
  183.             continue;
  184.         }

  186.         module = ngx_modules[m]->ctx;
  187.         mi = ngx_modules[m]->ctx_index;

  189.         /* init mail{} main_conf's */

  191.         cf->ctx = ctx;

  193.         if (module->init_main_conf) {
  194.             rv = module->init_main_conf(cf, ctx->main_conf[mi]);
  195.             if (rv != NGX_CONF_OK) {
  196.                 *cf = pcf;
  197.                 return rv;
  198.             }
  199.         }

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

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

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

  207.             if (module->merge_srv_conf) {
  208.                 rv = module->merge_srv_conf(cf,
  209.                                             ctx->srv_conf[mi],
  210.                                             cscfp[s]->ctx->srv_conf[mi]);
  211.                 if (rv != NGX_CONF_OK) {
  212.                     *cf = pcf;
  213.                     return rv;
  214.                 }
  215.             }
  216.         }
  217.     }

  219.     *cf = pcf;


  222.     if (ngx_array_init(&ports, cf->temp_pool, 4, sizeof(ngx_mail_conf_port_t))
  223.         != NGX_OK)
  224.     {
  225.         return NGX_CONF_ERROR;
  226.     }

  228.     listen = cmcf->listen.elts;

  230.     for (i = 0; i < cmcf->listen.nelts; i++) {
  231.         if (ngx_mail_add_ports(cf, &ports, &listen[i]) != NGX_OK) {
  232.             return NGX_CONF_ERROR;
  233.         }
  234.     }

  236.     return ngx_mail_optimize_servers(cf, &ports);
  237. }


  240. static ngx_int_t
  241. ‌ngx_mail_add_ports(ngx_conf_t *cf, ngx_array_t *ports,
  242.     ngx_mail_listen_t *listen)
  243. {
  244.     in_port_t              p;
  245.     ngx_uint_t             i;
  246.     struct sockaddr       *sa;
  247.     struct sockaddr_in    *sin;
  248.     ngx_mail_conf_port_t  *port;
  249.     ngx_mail_conf_addr_t  *addr;
  250. #if (NGX_HAVE_INET6)
  251.     struct sockaddr_in6   *sin6;
  252. #endif

  254.     sa = (struct sockaddr *) &listen->sockaddr;

  256.     switch (sa->sa_family) {

  258. #if (NGX_HAVE_INET6)
  259.     case AF_INET6:
  260.         sin6 = (struct sockaddr_in6 *) sa;
  261.         p = sin6->sin6_port;
  262.         break;
  263. #endif

  265. #if (NGX_HAVE_UNIX_DOMAIN)
  266.     case AF_UNIX:
  267.         p = 0;
  268.         break;
  269. #endif

  271.     default: /* AF_INET */
  272.         sin = (struct sockaddr_in *) sa;
  273.         p = sin->sin_port;
  274.         break;
  275.     }

  277.     port = ports->elts;
  278.     for (i = 0; i < ports->nelts; i++) {
  279.         if (p == port[i].port && sa->sa_family == port[i].family) {

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

  283.             port = &port[i];
  284.             goto found;
  285.         }
  286.     }

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

  290.     port = ngx_array_push(ports);
  291.     if (port == NULL) {
  292.         return NGX_ERROR;
  293.     }

  295.     port->family = sa->sa_family;
  296.     port->port = p;

  298.     if (ngx_array_init(&port->addrs, cf->temp_pool, 2,
  299.                        sizeof(ngx_mail_conf_addr_t))
  300.         != NGX_OK)
  301.     {
  302.         return NGX_ERROR;
  303.     }

  305. found:

  307.     addr = ngx_array_push(&port->addrs);
  308.     if (addr == NULL) {
  309.         return NGX_ERROR;
  310.     }

  312.     addr->sockaddr = (struct sockaddr *) &listen->sockaddr;
  313.     addr->socklen = listen->socklen;
  314.     addr->ctx = listen->ctx;
  315.     addr->bind = listen->bind;
  316.     addr->wildcard = listen->wildcard;
  317.     addr->so_keepalive = listen->so_keepalive;
  318. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  319.     addr->tcp_keepidle = listen->tcp_keepidle;
  320.     addr->tcp_keepintvl = listen->tcp_keepintvl;
  321.     addr->tcp_keepcnt = listen->tcp_keepcnt;
  322. #endif
  323. #if (NGX_MAIL_SSL)
  324.     addr->ssl = listen->ssl;
  325. #endif
  326. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  327.     addr->ipv6only = listen->ipv6only;
  328. #endif

  330.     return NGX_OK;
  331. }


  334. static char *
  335. ‌ngx_mail_optimize_servers(ngx_conf_t *cf, ngx_array_t *ports)
  336. {
  337.     ngx_uint_t             i, p, last, bind_wildcard;
  338.     ngx_listening_t       *ls;
  339.     ngx_mail_port_t       *mport;
  340.     ngx_mail_conf_port_t  *port;
  341.     ngx_mail_conf_addr_t  *addr;

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

  346.         ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts,
  347.                  sizeof(ngx_mail_conf_addr_t), ngx_mail_cmp_conf_addrs);

  349.         addr = port[p].addrs.elts;
  350.         last = port[p].addrs.nelts;

  352.         /*
  353.          * if there is the binding to the "*:port" then we need to bind()
  354.          * to the "*:port" only and ignore the other bindings
  355.          */

  357.         if (addr[last - 1].wildcard) {
  358.             addr[last - 1].bind = 1;
  359.             bind_wildcard = 1;

  361.         } else {
  362.             bind_wildcard = 0;
  363.         }

  365.         i = 0;

  367.         while (i < last) {

  369.             if (bind_wildcard && !addr[i].bind) {
  370.                 i++;
  371.                 continue;
  372.             }

  374.             ls = ngx_create_listening(cf, addr[i].sockaddr, addr[i].socklen);
  375.             if (ls == NULL) {
  376.                 return NGX_CONF_ERROR;
  377.             }

  379.             ls->addr_ntop = 1;
  380.             ls->handler = ngx_mail_init_connection;
  381.             ls->pool_size = 256;

  383.             /* TODO: error_log directive */
  384.             ls->logp = &cf->cycle->new_log;
  385.             ls->log.data = &ls->addr_text;
  386.             ls->log.handler = ngx_accept_log_error;

  388.             ls->keepalive = addr[i].so_keepalive;
  389. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  390.             ls->keepidle = addr[i].tcp_keepidle;
  391.             ls->keepintvl = addr[i].tcp_keepintvl;
  392.             ls->keepcnt = addr[i].tcp_keepcnt;
  393. #endif

  395. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
  396.             ls->ipv6only = addr[i].ipv6only;
  397. #endif

  399.             mport = ngx_palloc(cf->pool, sizeof(ngx_mail_port_t));
  400.             if (mport == NULL) {
  401.                 return NGX_CONF_ERROR;
  402.             }

  404.             ls->servers = mport;

  406.             if (i == last - 1) {
  407.                 mport->naddrs = last;

  409.             } else {
  410.                 mport->naddrs = 1;
  411.                 i = 0;
  412.             }

  414.             switch (ls->sockaddr->sa_family) {
  415. #if (NGX_HAVE_INET6)
  416.             case AF_INET6:
  417.                 if (ngx_mail_add_addrs6(cf, mport, addr) != NGX_OK) {
  418.                     return NGX_CONF_ERROR;
  419.                 }
  420.                 break;
  421. #endif
  422.             default: /* AF_INET */
  423.                 if (ngx_mail_add_addrs(cf, mport, addr) != NGX_OK) {
  424.                     return NGX_CONF_ERROR;
  425.                 }
  426.                 break;
  427.             }

  429.             addr++;
  430.             last--;
  431.         }
  432.     }

  434.     return NGX_CONF_OK;
  435. }


  438. static ngx_int_t
  439. ‌ngx_mail_add_addrs(ngx_conf_t *cf, ngx_mail_port_t *mport,
  440.     ngx_mail_conf_addr_t *addr)
  441. {
  442.     u_char              *p;
  443.     size_t               len;
  444.     ngx_uint_t           i;
  445.     ngx_mail_in_addr_t  *addrs;
  446.     struct sockaddr_in  *sin;
  447.     u_char               buf[NGX_SOCKADDR_STRLEN];

  449.     mport->addrs = ngx_pcalloc(cf->pool,
  450.                                mport->naddrs * sizeof(ngx_mail_in_addr_t));
  451.     if (mport->addrs == NULL) {
  452.         return NGX_ERROR;
  453.     }

  455.     addrs = mport->addrs;

  457.     for (i = 0; i < mport->naddrs; i++) {

  459.         sin = (struct sockaddr_in *) addr[i].sockaddr;
  460.         addrs[i].addr = sin->sin_addr.s_addr;

  462.         addrs[i].conf.ctx = addr[i].ctx;
  463. #if (NGX_MAIL_SSL)
  464.         addrs[i].conf.ssl = addr[i].ssl;
  465. #endif

  467.         len = ngx_sock_ntop(addr[i].sockaddr, addr[i].socklen, buf,
  468.                             NGX_SOCKADDR_STRLEN, 1);

  470.         p = ngx_pnalloc(cf->pool, len);
  471.         if (p == NULL) {
  472.             return NGX_ERROR;
  473.         }

  475.         ngx_memcpy(p, buf, len);

  477.         addrs[i].conf.addr_text.len = len;
  478.         addrs[i].conf.addr_text.data = p;
  479.     }

  481.     return NGX_OK;
  482. }


  485. #if (NGX_HAVE_INET6)

  487. static ngx_int_t
  488. ‌ngx_mail_add_addrs6(ngx_conf_t *cf, ngx_mail_port_t *mport,
  489.     ngx_mail_conf_addr_t *addr)
  490. {
  491.     u_char               *p;
  492.     size_t                len;
  493.     ngx_uint_t            i;
  494.     ngx_mail_in6_addr_t  *addrs6;
  495.     struct sockaddr_in6  *sin6;
  496.     u_char                buf[NGX_SOCKADDR_STRLEN];

  498.     mport->addrs = ngx_pcalloc(cf->pool,
  499.                                mport->naddrs * sizeof(ngx_mail_in6_addr_t));
  500.     if (mport->addrs == NULL) {
  501.         return NGX_ERROR;
  502.     }

  504.     addrs6 = mport->addrs;

  506.     for (i = 0; i < mport->naddrs; i++) {

  508.         sin6 = (struct sockaddr_in6 *) addr[i].sockaddr;
  509.         addrs6[i].addr6 = sin6->sin6_addr;

  511.         addrs6[i].conf.ctx = addr[i].ctx;
  512. #if (NGX_MAIL_SSL)
  513.         addrs6[i].conf.ssl = addr[i].ssl;
  514. #endif

  516.         len = ngx_sock_ntop(addr[i].sockaddr, addr[i].socklen, buf,
  517.                             NGX_SOCKADDR_STRLEN, 1);

  519.         p = ngx_pnalloc(cf->pool, len);
  520.         if (p == NULL) {
  521.             return NGX_ERROR;
  522.         }

  524.         ngx_memcpy(p, buf, len);

  526.         addrs6[i].conf.addr_text.len = len;
  527.         addrs6[i].conf.addr_text.data = p;
  528.     }

  530.     return NGX_OK;
  531. }

  533. #endif


  536. static ngx_int_t
  537. ‌ngx_mail_cmp_conf_addrs(const void *one, const void *two)
  538. {
  539.     ngx_mail_conf_addr_t  *first, *second;

  541.     first = (ngx_mail_conf_addr_t *) one;
  542.     second = (ngx_mail_conf_addr_t *) two;

  544.     if (first->wildcard) {
  545.         /* a wildcard must be the last resort, shift it to the end */
  546.         return 1;
  547.     }

  549.     if (second->wildcard) {
  550.         /* a wildcard must be the last resort, shift it to the end */
  551.         return -1;
  552.     }

  554.     if (first->bind && !second->bind) {
  555.         /* shift explicit bind()ed addresses to the start */
  556.         return -1;
  557.     }

  559.     if (!first->bind && second->bind) {
  560.         /* shift explicit bind()ed addresses to the start */
  561.         return 1;
  562.     }

  564.     /* do not sort by default */

  566.     return 0;
  567. }

One Level Up Top Level