One Level Up Top Level

src/mail/ngx_mail_handler.c - nginx-1.31.3 nginx/ @ 42f8df65b

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_proxy_protocol_handler(ngx_event_t *rev);
  15. static void ngx_mail_init_session_handler(ngx_event_t *rev);
  16. static void ngx_mail_init_session(ngx_connection_t *c);

  18. #if (NGX_MAIL_SSL)
  19. static void ngx_mail_ssl_init_connection(ngx_ssl_t *ssl, ngx_connection_t *c);
  20. static void ngx_mail_ssl_handshake_handler(ngx_connection_t *c);
  21. static ngx_int_t ngx_mail_verify_cert(ngx_mail_session_t *s,
  22.     ngx_connection_t *c);
  23. #endif


  26. void
  27. ‌ngx_mail_init_connection(ngx_connection_t *c)
  28. {
  29.     size_t                     len;
  30.     ngx_uint_t                 i;
  31.     ngx_event_t               *rev;
  32.     ngx_mail_port_t           *port;
  33.     struct sockaddr           *sa;
  34.     struct sockaddr_in        *sin;
  35.     ngx_mail_log_ctx_t        *ctx;
  36.     ngx_mail_in_addr_t        *addr;
  37.     ngx_mail_session_t        *s;
  38.     ngx_mail_addr_conf_t      *addr_conf;
  39.     ngx_mail_core_srv_conf_t  *cscf;
  40.     u_char                     text[NGX_SOCKADDR_STRLEN];
  41. #if (NGX_HAVE_INET6)
  42.     struct sockaddr_in6       *sin6;
  43.     ngx_mail_in6_addr_t       *addr6;
  44. #endif


  47.     /* find the server configuration for the address:port */

  49.     port = c->listening->servers;

  51.     if (port->naddrs > 1) {

  53.         /*
  54.          * There are several addresses on this port and one of them
  55.          * is the "*:port" wildcard so getsockname() is needed to determine
  56.          * the server address.
  57.          *
  58.          * AcceptEx() already gave this address.
  59.          */

  61.         if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
  62.             ngx_mail_close_connection(c);
  63.             return;
  64.         }

  66.         sa = c->local_sockaddr;

  68.         switch (sa->sa_family) {

  70. #if (NGX_HAVE_INET6)
  71.         case AF_INET6:
  72.             sin6 = (struct sockaddr_in6 *) sa;

  74.             addr6 = port->addrs;

  76.             /* the last address is "*" */

  78.             for (i = 0; i < port->naddrs - 1; i++) {
  79.                 if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16) == 0) {
  80.                     break;
  81.                 }
  82.             }

  84.             addr_conf = &addr6[i].conf;

  86.             break;
  87. #endif

  89.         default: /* AF_INET */
  90.             sin = (struct sockaddr_in *) sa;

  92.             addr = port->addrs;

  94.             /* the last address is "*" */

  96.             for (i = 0; i < port->naddrs - 1; i++) {
  97.                 if (addr[i].addr == sin->sin_addr.s_addr) {
  98.                     break;
  99.                 }
  100.             }

  102.             addr_conf = &addr[i].conf;

  104.             break;
  105.         }

  107.     } else {
  108.         switch (c->local_sockaddr->sa_family) {

  110. #if (NGX_HAVE_INET6)
  111.         case AF_INET6:
  112.             addr6 = port->addrs;
  113.             addr_conf = &addr6[0].conf;
  114.             break;
  115. #endif

  117.         default: /* AF_INET */
  118.             addr = port->addrs;
  119.             addr_conf = &addr[0].conf;
  120.             break;
  121.         }
  122.     }

  124.     s = ngx_pcalloc(c->pool, sizeof(ngx_mail_session_t));
  125.     if (s == NULL) {
  126.         ngx_mail_close_connection(c);
  127.         return;
  128.     }

  130.     s->signature = NGX_MAIL_MODULE;

  132.     s->main_conf = addr_conf->ctx->main_conf;
  133.     s->srv_conf = addr_conf->ctx->srv_conf;

  135. #if (NGX_MAIL_SSL)
  136.     s->ssl = addr_conf->ssl;
  137. #endif

  139.     s->addr_text = &addr_conf->addr_text;

  141.     c->data = s;
  142.     s->connection = c;

  144.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  146.     ngx_set_connection_log(c, cscf->error_log);

  148.     len = ngx_sock_ntop(c->sockaddr, c->socklen, text, NGX_SOCKADDR_STRLEN, 1);

  150.     ngx_log_error(NGX_LOG_INFO, c->log, 0, "*%uA client %*s connected to %V",
  151.                   c->number, len, text, s->addr_text);

  153.     ctx = ngx_palloc(c->pool, sizeof(ngx_mail_log_ctx_t));
  154.     if (ctx == NULL) {
  155.         ngx_mail_close_connection(c);
  156.         return;
  157.     }

  159.     ctx->client = &c->addr_text;
  160.     ctx->session = s;

  162.     c->log->connection = c->number;
  163.     c->log->handler = ngx_mail_log_error;
  164.     c->log->data = ctx;
  165.     c->log->action = "sending client greeting line";

  167.     c->log_error = NGX_ERROR_INFO;

  169.     rev = c->read;
  170.     rev->handler = ngx_mail_init_session_handler;

  172.     if (addr_conf->proxy_protocol) {
  173.         c->log->action = "reading PROXY protocol";

  175.         rev->handler = ngx_mail_proxy_protocol_handler;

  177.         if (!rev->ready) {
  178.             ngx_add_timer(rev, cscf->timeout);

  180.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  181.                 ngx_mail_close_connection(c);
  182.             }

  184.             return;
  185.         }
  186.     }

  188.     if (ngx_use_accept_mutex) {
  189.         ngx_post_event(rev, &ngx_posted_events);
  190.         return;
  191.     }

  193.     rev->handler(rev);
  194. }


  197. static void
  198. ‌ngx_mail_proxy_protocol_handler(ngx_event_t *rev)
  199. {
  200.     u_char                    *p, buf[NGX_PROXY_PROTOCOL_MAX_HEADER];
  201.     size_t                     size;
  202.     ssize_t                    n;
  203.     ngx_err_t                  err;
  204.     ngx_connection_t          *c;
  205.     ngx_mail_session_t        *s;
  206.     ngx_mail_core_srv_conf_t  *cscf;

  208.     c = rev->data;
  209.     s = c->data;

  211.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0,
  212.                    "mail PROXY protocol handler");

  214.     if (rev->timedout) {
  215.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  216.         c->timedout = 1;
  217.         ngx_mail_close_connection(c);
  218.         return;
  219.     }

  221.     n = recv(c->fd, (char *) buf, sizeof(buf), MSG_PEEK);

  223.     err = ngx_socket_errno;

  225.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0, "recv(): %z", n);

  227.     if (n == -1) {
  228.         if (err == NGX_EAGAIN) {
  229.             rev->ready = 0;

  231.             if (!rev->timer_set) {
  232.                 cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
  233.                 ngx_add_timer(rev, cscf->timeout);
  234.             }

  236.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  237.                 ngx_mail_close_connection(c);
  238.             }

  240.             return;
  241.         }

  243.         ngx_connection_error(c, err, "recv() failed");

  245.         ngx_mail_close_connection(c);
  246.         return;
  247.     }

  249.     p = ngx_proxy_protocol_read(c, buf, buf + n);

  251.     if (p == NULL) {
  252.         ngx_mail_close_connection(c);
  253.         return;
  254.     }

  256.     size = p - buf;

  258.     if (c->recv(c, buf, size) != (ssize_t) size) {
  259.         ngx_mail_close_connection(c);
  260.         return;
  261.     }

  263.     if (ngx_mail_realip_handler(s) != NGX_OK) {
  264.         ngx_mail_close_connection(c);
  265.         return;
  266.     }

  268.     ngx_mail_init_session_handler(rev);
  269. }


  272. static void
  273. ‌ngx_mail_init_session_handler(ngx_event_t *rev)
  274. {
  275.     ngx_connection_t  *c;

  277.     c = rev->data;

  279. #if (NGX_MAIL_SSL)
  280.     {
  281.     ngx_mail_session_t   *s;
  282.     ngx_mail_ssl_conf_t  *sslcf;

  284.     s = c->data;

  286.     if (s->ssl) {
  287.         c->log->action = "SSL handshaking";

  289.         sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  291.         ngx_mail_ssl_init_connection(&sslcf->ssl, c);
  292.         return;
  293.     }

  295.     }
  296. #endif

  298.     ngx_mail_init_session(c);
  299. }


  302. #if (NGX_MAIL_SSL)

  304. void
  305. ‌ngx_mail_starttls_handler(ngx_event_t *rev)
  306. {
  307.     ngx_connection_t     *c;
  308.     ngx_mail_session_t   *s;
  309.     ngx_mail_ssl_conf_t  *sslcf;

  311.     c = rev->data;
  312.     s = c->data;
  313.     s->starttls = 1;

  315.     c->log->action = "in starttls state";

  317.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  319.     ngx_mail_ssl_init_connection(&sslcf->ssl, c);
  320. }


  323. static void
  324. ‌ngx_mail_ssl_init_connection(ngx_ssl_t *ssl, ngx_connection_t *c)
  325. {
  326.     ngx_mail_session_t        *s;
  327.     ngx_mail_core_srv_conf_t  *cscf;

  329.     if (ngx_ssl_create_connection(ssl, c, 0) != NGX_OK) {
  330.         ngx_mail_close_connection(c);
  331.         return;
  332.     }

  334.     if (ngx_ssl_handshake(c) == NGX_AGAIN) {

  336.         s = c->data;

  338.         if (!c->read->timer_set) {
  339.             cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
  340.             ngx_add_timer(c->read, cscf->timeout);
  341.         }

  343.         c->ssl->handler = ngx_mail_ssl_handshake_handler;

  345.         return;
  346.     }

  348.     ngx_mail_ssl_handshake_handler(c);
  349. }


  352. static void
  353. ‌ngx_mail_ssl_handshake_handler(ngx_connection_t *c)
  354. {
  355.     ngx_mail_session_t        *s;
  356.     ngx_mail_core_srv_conf_t  *cscf;

  358.     if (c->ssl->handshaked) {

  360.         s = c->data;

  362.         if (ngx_mail_verify_cert(s, c) != NGX_OK) {
  363.             return;
  364.         }

  366.         if (s->starttls) {
  367.             cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  369.             c->read->handler = cscf->protocol->init_protocol;
  370.             c->write->handler = ngx_mail_send;

  372.             cscf->protocol->init_protocol(c->read);

  374.             return;
  375.         }

  377.         c->read->ready = 0;

  379.         ngx_mail_init_session(c);
  380.         return;
  381.     }

  383.     ngx_mail_close_connection(c);
  384. }


  387. static ngx_int_t
  388. ‌ngx_mail_verify_cert(ngx_mail_session_t *s, ngx_connection_t *c)
  389. {
  390.     long                       rc;
  391.     X509                      *cert;
  392.     ngx_mail_ssl_conf_t       *sslcf;
  393.     ngx_mail_core_srv_conf_t  *cscf;

  395.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  397.     if (!sslcf->verify) {
  398.         return NGX_OK;
  399.     }

  401.     rc = SSL_get_verify_result(c->ssl->connection);

  403.     if (rc != X509_V_OK
  404.         && (sslcf->verify != 3 || !ngx_ssl_verify_error_optional(rc)))
  405.     {
  406.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  407.                       "client SSL certificate verify error: (%l:%s)",
  408.                       rc, X509_verify_cert_error_string(rc));

  410.         ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  411.                                       (SSL_get0_session(c->ssl->connection)));

  413.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  415.         s->out = cscf->protocol->cert_error;
  416.         s->quit = 1;

  418.         c->write->handler = ngx_mail_send;

  420.         ngx_mail_send(s->connection->write);
  421.         return NGX_ERROR;
  422.     }

  424.     if (sslcf->verify == 1) {
  425.         cert = SSL_get_peer_certificate(c->ssl->connection);

  427.         if (cert == NULL) {
  428.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  429.                           "client sent no required SSL certificate");

  431.             ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  432.                                        (SSL_get0_session(c->ssl->connection)));

  434.             cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  436.             s->out = cscf->protocol->no_cert;
  437.             s->quit = 1;

  439.             c->write->handler = ngx_mail_send;

  441.             ngx_mail_send(s->connection->write);
  442.             return NGX_ERROR;
  443.         }

  445.         X509_free(cert);
  446.     }

  448.     return NGX_OK;
  449. }

  451. #endif


  454. static void
  455. ‌ngx_mail_init_session(ngx_connection_t *c)
  456. {
  457.     ngx_mail_session_t        *s;
  458.     ngx_mail_core_srv_conf_t  *cscf;

  460.     s = c->data;

  462.     c->log->action = "sending client greeting line";

  464.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  466.     s->protocol = cscf->protocol->type;

  468.     s->ctx = ngx_pcalloc(c->pool, sizeof(void *) * ngx_mail_max_module);
  469.     if (s->ctx == NULL) {
  470.         ngx_mail_session_internal_server_error(s);
  471.         return;
  472.     }

  474.     c->write->handler = ngx_mail_send;

  476.     cscf->protocol->init_session(s, c);
  477. }


  480. ngx_int_t
  481. ‌ngx_mail_salt(ngx_mail_session_t *s, ngx_connection_t *c,
  482.     ngx_mail_core_srv_conf_t *cscf)
  483. {
  484.     s->salt.data = ngx_pnalloc(c->pool,
  485.                                sizeof(" <18446744073709551616.@>" CRLF) - 1
  486.                                + NGX_TIME_T_LEN
  487.                                + cscf->server_name.len);
  488.     if (s->salt.data == NULL) {
  489.         return NGX_ERROR;
  490.     }

  492.     s->salt.len = ngx_sprintf(s->salt.data, "<%ul.%T@%V>" CRLF,
  493.                               ngx_random(), ngx_time(), &cscf->server_name)
  494.                   - s->salt.data;

  496.     return NGX_OK;
  497. }


  500. #if (NGX_MAIL_SSL)

  502. ngx_int_t
  503. ‌ngx_mail_starttls_only(ngx_mail_session_t *s, ngx_connection_t *c)
  504. {
  505.     ngx_mail_ssl_conf_t  *sslcf;

  507.     if (c->ssl) {
  508.         return 0;
  509.     }

  511.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  513.     if (sslcf->starttls == NGX_MAIL_STARTTLS_ONLY) {
  514.         return 1;
  515.     }

  517.     return 0;
  518. }

  520. #endif


  523. ngx_int_t
  524. ‌ngx_mail_auth_plain(ngx_mail_session_t *s, ngx_connection_t *c, ngx_uint_t n)
  525. {
  526.     u_char     *p, *pos, *last;
  527.     ngx_str_t  *arg, plain;

  529.     arg = s->args.elts;

  531. #if (NGX_DEBUG_MAIL_PASSWD)
  532.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  533.                    "mail auth plain: \"%V\"", &arg[n]);
  534. #endif

  536.     plain.data = ngx_pnalloc(c->pool, ngx_base64_decoded_length(arg[n].len));
  537.     if (plain.data == NULL) {
  538.         return NGX_ERROR;
  539.     }

  541.     if (ngx_decode_base64(&plain, &arg[n]) != NGX_OK) {
  542.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  543.             "client sent invalid base64 encoding in AUTH PLAIN command");
  544.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  545.     }

  547.     p = plain.data;
  548.     last = p + plain.len;

  550.     while (p < last && *p++) { /* void */ }

  552.     if (p == last) {
  553.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  554.                       "client sent invalid login in AUTH PLAIN command");
  555.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  556.     }

  558.     pos = p;

  560.     while (p < last && *p) { p++; }

  562.     if (p == last) {
  563.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  564.                       "client sent invalid password in AUTH PLAIN command");
  565.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  566.     }

  568.     s->login.len = p++ - pos;
  569.     s->login.data = pos;

  571.     s->passwd.len = last - p;
  572.     s->passwd.data = p;

  574. #if (NGX_DEBUG_MAIL_PASSWD)
  575.     ngx_log_debug2(NGX_LOG_DEBUG_MAIL, c->log, 0,
  576.                    "mail auth plain: \"%V\" \"%V\"", &s->login, &s->passwd);
  577. #endif

  579.     return NGX_DONE;
  580. }


  583. ngx_int_t
  584. ‌ngx_mail_auth_login_username(ngx_mail_session_t *s, ngx_connection_t *c,
  585.     ngx_uint_t n)
  586. {
  587.     ngx_str_t  *arg, login;

  589.     arg = s->args.elts;

  591.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  592.                    "mail auth login username: \"%V\"", &arg[n]);

  594.     login.data = ngx_pnalloc(c->pool, ngx_base64_decoded_length(arg[n].len));
  595.     if (login.data == NULL) {
  596.         return NGX_ERROR;
  597.     }

  599.     if (ngx_decode_base64(&login, &arg[n]) != NGX_OK) {
  600.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  601.             "client sent invalid base64 encoding in AUTH LOGIN command");
  602.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  603.     }

  605.     s->login = login;

  607.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  608.                    "mail auth login username: \"%V\"", &s->login);

  610.     return NGX_OK;
  611. }


  614. ngx_int_t
  615. ‌ngx_mail_auth_login_password(ngx_mail_session_t *s, ngx_connection_t *c)
  616. {
  617.     ngx_str_t  *arg, passwd;

  619.     arg = s->args.elts;

  621. #if (NGX_DEBUG_MAIL_PASSWD)
  622.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  623.                    "mail auth login password: \"%V\"", &arg[0]);
  624. #endif

  626.     passwd.data = ngx_pnalloc(c->pool, ngx_base64_decoded_length(arg[0].len));
  627.     if (passwd.data == NULL) {
  628.         return NGX_ERROR;
  629.     }

  631.     if (ngx_decode_base64(&passwd, &arg[0]) != NGX_OK) {
  632.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  633.             "client sent invalid base64 encoding in AUTH LOGIN command");
  634.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  635.     }

  637.     s->passwd = passwd;

  639. #if (NGX_DEBUG_MAIL_PASSWD)
  640.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  641.                    "mail auth login password: \"%V\"", &s->passwd);
  642. #endif

  644.     return NGX_DONE;
  645. }


  648. ngx_int_t
  649. ‌ngx_mail_auth_cram_md5_salt(ngx_mail_session_t *s, ngx_connection_t *c,
  650.     char *prefix, size_t len)
  651. {
  652.     u_char      *p;
  653.     ngx_str_t    salt;
  654.     ngx_uint_t   n;

  656.     p = ngx_pnalloc(c->pool, len + ngx_base64_encoded_length(s->salt.len) + 2);
  657.     if (p == NULL) {
  658.         return NGX_ERROR;
  659.     }

  661.     salt.data = ngx_cpymem(p, prefix, len);
  662.     s->salt.len -= 2;

  664.     ngx_encode_base64(&salt, &s->salt);

  666.     s->salt.len += 2;
  667.     n = len + salt.len;
  668.     p[n++] = CR; p[n++] = LF;

  670.     s->out.len = n;
  671.     s->out.data = p;

  673.     return NGX_OK;
  674. }


  677. ngx_int_t
  678. ‌ngx_mail_auth_cram_md5(ngx_mail_session_t *s, ngx_connection_t *c)
  679. {
  680.     u_char     *p, *last;
  681.     ngx_str_t  *arg, login;

  683.     arg = s->args.elts;

  685.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  686.                    "mail auth cram-md5: \"%V\"", &arg[0]);

  688.     login.data = ngx_pnalloc(c->pool, ngx_base64_decoded_length(arg[0].len));
  689.     if (login.data == NULL) {
  690.         return NGX_ERROR;
  691.     }

  693.     if (ngx_decode_base64(&login, &arg[0]) != NGX_OK) {
  694.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  695.             "client sent invalid base64 encoding in AUTH CRAM-MD5 command");
  696.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  697.     }

  699.     s->login = login;

  701.     p = s->login.data;
  702.     last = p + s->login.len;

  704.     while (p < last) {
  705.         if (*p++ == ' ') {
  706.             s->login.len = p - s->login.data - 1;
  707.             s->passwd.len = last - p;
  708.             s->passwd.data = p;
  709.             break;
  710.         }
  711.     }

  713.     if (s->passwd.len != 32) {
  714.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  715.             "client sent invalid CRAM-MD5 hash in AUTH CRAM-MD5 command");
  716.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  717.     }

  719.     ngx_log_debug2(NGX_LOG_DEBUG_MAIL, c->log, 0,
  720.                    "mail auth cram-md5: \"%V\" \"%V\"", &s->login, &s->passwd);

  722.     s->auth_method = NGX_MAIL_AUTH_CRAM_MD5;

  724.     return NGX_DONE;
  725. }


  728. ngx_int_t
  729. ‌ngx_mail_auth_external(ngx_mail_session_t *s, ngx_connection_t *c,
  730.     ngx_uint_t n)
  731. {
  732.     ngx_str_t  *arg, external;

  734.     arg = s->args.elts;

  736.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  737.                    "mail auth external: \"%V\"", &arg[n]);

  739.     external.data = ngx_pnalloc(c->pool, ngx_base64_decoded_length(arg[n].len));
  740.     if (external.data == NULL) {
  741.         return NGX_ERROR;
  742.     }

  744.     if (ngx_decode_base64(&external, &arg[n]) != NGX_OK) {
  745.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  746.             "client sent invalid base64 encoding in AUTH EXTERNAL command");
  747.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  748.     }

  750.     s->login.len = external.len;
  751.     s->login.data = external.data;

  753.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  754.                    "mail auth external: \"%V\"", &s->login);

  756.     s->auth_method = NGX_MAIL_AUTH_EXTERNAL;

  758.     return NGX_DONE;
  759. }


  762. void
  763. ‌ngx_mail_send(ngx_event_t *wev)
  764. {
  765.     ngx_int_t                  n;
  766.     ngx_connection_t          *c;
  767.     ngx_mail_session_t        *s;
  768.     ngx_mail_core_srv_conf_t  *cscf;

  770.     c = wev->data;
  771.     s = c->data;

  773.     if (wev->timedout) {
  774.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  775.         c->timedout = 1;
  776.         ngx_mail_close_connection(c);
  777.         return;
  778.     }

  780.     if (s->out.len == 0) {
  781.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  782.             ngx_mail_close_connection(c);
  783.         }

  785.         return;
  786.     }

  788.     n = c->send(c, s->out.data, s->out.len);

  790.     if (n > 0) {
  791.         s->out.data += n;
  792.         s->out.len -= n;

  794.         if (s->out.len != 0) {
  795.             goto again;
  796.         }

  798.         if (wev->timer_set) {
  799.             ngx_del_timer(wev);
  800.         }

  802.         if (s->quit) {
  803.             ngx_mail_close_connection(c);
  804.             return;
  805.         }

  807.         if (s->blocked) {
  808.             c->read->handler(c->read);
  809.         }

  811.         return;
  812.     }

  814.     if (n == NGX_ERROR) {
  815.         ngx_mail_close_connection(c);
  816.         return;
  817.     }

  819.     /* n == NGX_AGAIN */

  821. again:

  823.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  825.     ngx_add_timer(c->write, cscf->timeout);

  827.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  828.         ngx_mail_close_connection(c);
  829.         return;
  830.     }
  831. }


  834. ngx_int_t
  835. ‌ngx_mail_read_command(ngx_mail_session_t *s, ngx_connection_t *c)
  836. {
  837.     ssize_t                    n;
  838.     ngx_int_t                  rc;
  839.     ngx_str_t                  l;
  840.     ngx_mail_core_srv_conf_t  *cscf;

  842.     if (s->buffer->last < s->buffer->end) {

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

  846.         if (n == NGX_ERROR || n == 0) {
  847.             ngx_mail_close_connection(c);
  848.             return NGX_ERROR;
  849.         }

  851.         if (n > 0) {
  852.             s->buffer->last += n;
  853.         }

  855.         if (n == NGX_AGAIN) {
  856.             if (s->buffer->pos == s->buffer->last) {
  857.                 return NGX_AGAIN;
  858.             }
  859.         }
  860.     }

  862.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  864.     rc = cscf->protocol->parse_command(s);

  866.     if (rc == NGX_AGAIN) {

  868.         if (s->buffer->last < s->buffer->end) {
  869.             return rc;
  870.         }

  872.         l.len = s->buffer->last - s->buffer->start;
  873.         l.data = s->buffer->start;

  875.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  876.                       "client sent too long command \"%V\"", &l);

  878.         s->quit = 1;

  880.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  881.     }

  883.     if (rc == NGX_MAIL_PARSE_INVALID_COMMAND) {

  885.         s->errors++;

  887.         if (s->errors >= cscf->max_errors) {
  888.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  889.                           "client sent too many invalid commands");
  890.             s->quit = 1;
  891.         }

  893.         return rc;
  894.     }

  896.     if (rc == NGX_IMAP_NEXT) {
  897.         return rc;
  898.     }

  900.     if (rc == NGX_ERROR) {
  901.         ngx_mail_close_connection(c);
  902.         return NGX_ERROR;
  903.     }

  905.     return NGX_OK;
  906. }


  909. void
  910. ‌ngx_mail_auth(ngx_mail_session_t *s, ngx_connection_t *c)
  911. {
  912.     s->args.nelts = 0;

  914.     if (s->buffer->pos == s->buffer->last) {
  915.         s->buffer->pos = s->buffer->start;
  916.         s->buffer->last = s->buffer->start;
  917.     }

  919.     s->state = 0;

  921.     if (c->read->timer_set) {
  922.         ngx_del_timer(c->read);
  923.     }

  925.     s->login_attempt++;

  927.     ngx_mail_auth_http_init(s);
  928. }


  931. void
  932. ‌ngx_mail_session_internal_server_error(ngx_mail_session_t *s)
  933. {
  934.     ngx_mail_core_srv_conf_t  *cscf;

  936.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  938.     s->out = cscf->protocol->internal_server_error;
  939.     s->quit = 1;

  941.     ngx_mail_send(s->connection->write);
  942. }


  945. void
  946. ‌ngx_mail_close_connection(ngx_connection_t *c)
  947. {
  948.     ngx_pool_t  *pool;

  950.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  951.                    "close mail connection: %d", c->fd);

  953. #if (NGX_MAIL_SSL)

  955.     if (c->ssl) {
  956.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  957.             c->ssl->handler = ngx_mail_close_connection;
  958.             return;
  959.         }
  960.     }

  962. #endif

  964. #if (NGX_STAT_STUB)
  965.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  966. #endif

  968.     c->destroyed = 1;

  970.     pool = c->pool;

  972.     ngx_close_connection(c);

  974.     ngx_destroy_pool(pool);
  975. }


  978. u_char *
  979. ‌ngx_mail_log_error(ngx_log_t *log, u_char *buf, size_t len)
  980. {
  981.     u_char              *p;
  982.     ngx_mail_session_t  *s;
  983.     ngx_mail_log_ctx_t  *ctx;

  985.     if (log->action) {
  986.         p = ngx_snprintf(buf, len, " while %s", log->action);
  987.         len -= p - buf;
  988.         buf = p;
  989.     }

  991.     ctx = log->data;

  993.     p = ngx_snprintf(buf, len, ", client: %V", ctx->client);
  994.     len -= p - buf;
  995.     buf = p;

  997.     s = ctx->session;

  999.     if (s == NULL) {
  1000.         return p;
  1001.     }

  1003.     p = ngx_snprintf(buf, len, "%s, server: %V",
  1004.                      s->starttls ? " using starttls" : "",
  1005.                      s->addr_text);
  1006.     len -= p - buf;
  1007.     buf = p;

  1009.     if (s->login.len) {
  1010.         p = ngx_snprintf(buf, len, ", login: \"%V\"", &s->login);
  1011.         len -= p - buf;
  1012.         buf = p;
  1013.     }

  1015.     if (s->proxy == NULL) {
  1016.         return p;
  1017.     }

  1019.     p = ngx_snprintf(buf, len, ", upstream: %V", s->proxy->upstream.name);

  1021.     return p;
  1022. }

One Level Up Top Level