One Level Up Top Level

src/mail/ngx_mail_handler.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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.          */

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

  64.         sa = c->local_sockaddr;

  66.         switch (sa->sa_family) {

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

  72.             addr6 = port->addrs;

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

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

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

  84.             break;
  85. #endif

  87.         default: /* AF_INET */
  88.             sin = (struct sockaddr_in *) sa;

  90.             addr = port->addrs;

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

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

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

  102.             break;
  103.         }

  105.     } else {
  106.         switch (c->local_sockaddr->sa_family) {

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

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

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

  128.     s->signature = NGX_MAIL_MODULE;

  130.     s->main_conf = addr_conf->ctx->main_conf;
  131.     s->srv_conf = addr_conf->ctx->srv_conf;

  133. #if (NGX_MAIL_SSL)
  134.     s->ssl = addr_conf->ssl;
  135. #endif

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

  139.     c->data = s;
  140.     s->connection = c;

  142.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

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

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

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

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

  157.     ctx->client = &c->addr_text;
  158.     ctx->session = s;

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

  165.     c->log_error = NGX_ERROR_INFO;

  167.     rev = c->read;
  168.     rev->handler = ngx_mail_init_session_handler;

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

  173.         rev->handler = ngx_mail_proxy_protocol_handler;

  175.         if (!rev->ready) {
  176.             ngx_add_timer(rev, cscf->timeout);

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

  182.             return;
  183.         }
  184.     }

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

  191.     rev->handler(rev);
  192. }


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

  206.     c = rev->data;
  207.     s = c->data;

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

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

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

  221.     err = ngx_socket_errno;

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

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

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

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

  238.             return;
  239.         }

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

  243.         ngx_mail_close_connection(c);
  244.         return;
  245.     }

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

  249.     if (p == NULL) {
  250.         ngx_mail_close_connection(c);
  251.         return;
  252.     }

  254.     size = p - buf;

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

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

  266.     ngx_mail_init_session_handler(rev);
  267. }


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

  275.     c = rev->data;

  277. #if (NGX_MAIL_SSL)
  278.     {
  279.     ngx_mail_session_t   *s;
  280.     ngx_mail_ssl_conf_t  *sslcf;

  282.     s = c->data;

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

  287.         sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  289.         ngx_mail_ssl_init_connection(&sslcf->ssl, c);
  290.         return;
  291.     }

  293.     }
  294. #endif

  296.     ngx_mail_init_session(c);
  297. }


  300. #if (NGX_MAIL_SSL)

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

  309.     c = rev->data;
  310.     s = c->data;
  311.     s->starttls = 1;

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

  315.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  317.     ngx_mail_ssl_init_connection(&sslcf->ssl, c);
  318. }


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

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

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

  334.         s = c->data;

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

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

  343.         return;
  344.     }

  346.     ngx_mail_ssl_handshake_handler(c);
  347. }


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

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

  358.         s = c->data;

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

  364.         if (s->starttls) {
  365.             cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  367.             c->read->handler = cscf->protocol->init_protocol;
  368.             c->write->handler = ngx_mail_send;

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

  372.             return;
  373.         }

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

  377.         ngx_mail_init_session(c);
  378.         return;
  379.     }

  381.     ngx_mail_close_connection(c);
  382. }


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

  393.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  395.     if (!sslcf->verify) {
  396.         return NGX_OK;
  397.     }

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

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

  408.         ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  409.                                       (SSL_get0_session(c->ssl->connection)));

  411.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  413.         s->out = cscf->protocol->cert_error;
  414.         s->quit = 1;

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

  418.         ngx_mail_send(s->connection->write);
  419.         return NGX_ERROR;
  420.     }

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

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

  429.             ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  430.                                        (SSL_get0_session(c->ssl->connection)));

  432.             cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  434.             s->out = cscf->protocol->no_cert;
  435.             s->quit = 1;

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

  439.             ngx_mail_send(s->connection->write);
  440.             return NGX_ERROR;
  441.         }

  443.         X509_free(cert);
  444.     }

  446.     return NGX_OK;
  447. }

  449. #endif


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

  458.     s = c->data;

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

  462.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

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

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

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

  474.     cscf->protocol->init_session(s, c);
  475. }


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

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

  494.     return NGX_OK;
  495. }


  498. #if (NGX_MAIL_SSL)

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

  505.     if (c->ssl) {
  506.         return 0;
  507.     }

  509.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

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

  515.     return 0;
  516. }

  518. #endif


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

  527.     arg = s->args.elts;

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

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

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

  545.     p = plain.data;
  546.     last = p + plain.len;

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

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

  556.     pos = p;

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

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

  566.     s->login.len = p++ - pos;
  567.     s->login.data = pos;

  569.     s->passwd.len = last - p;
  570.     s->passwd.data = p;

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

  577.     return NGX_DONE;
  578. }


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

  587.     arg = s->args.elts;

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

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

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

  603.     s->login = login;

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

  608.     return NGX_OK;
  609. }


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

  617.     arg = s->args.elts;

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

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

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

  635.     s->passwd = passwd;

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

  642.     return NGX_DONE;
  643. }


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

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

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

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

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

  668.     s->out.len = n;
  669.     s->out.data = p;

  671.     return NGX_OK;
  672. }


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

  681.     arg = s->args.elts;

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

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

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

  697.     s->login = login;

  699.     p = s->login.data;
  700.     last = p + s->login.len;

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

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

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

  720.     s->auth_method = NGX_MAIL_AUTH_CRAM_MD5;

  722.     return NGX_DONE;
  723. }


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

  732.     arg = s->args.elts;

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

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

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

  748.     s->login.len = external.len;
  749.     s->login.data = external.data;

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

  754.     s->auth_method = NGX_MAIL_AUTH_EXTERNAL;

  756.     return NGX_DONE;
  757. }


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

  768.     c = wev->data;
  769.     s = c->data;

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

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

  783.         return;
  784.     }

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

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

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

  796.         if (wev->timer_set) {
  797.             ngx_del_timer(wev);
  798.         }

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

  805.         if (s->blocked) {
  806.             c->read->handler(c->read);
  807.         }

  809.         return;
  810.     }

  812.     if (n == NGX_ERROR) {
  813.         ngx_mail_close_connection(c);
  814.         return;
  815.     }

  817.     /* n == NGX_AGAIN */

  819. again:

  821.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

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

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


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

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

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

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

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

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

  860.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

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

  864.     if (rc == NGX_AGAIN) {

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

  870.         l.len = s->buffer->last - s->buffer->start;
  871.         l.data = s->buffer->start;

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

  876.         s->quit = 1;

  878.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  879.     }

  881.     if (rc == NGX_MAIL_PARSE_INVALID_COMMAND) {

  883.         s->errors++;

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

  891.         return rc;
  892.     }

  894.     if (rc == NGX_IMAP_NEXT) {
  895.         return rc;
  896.     }

  898.     if (rc == NGX_ERROR) {
  899.         ngx_mail_close_connection(c);
  900.         return NGX_ERROR;
  901.     }

  903.     return NGX_OK;
  904. }


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

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

  917.     s->state = 0;

  919.     if (c->read->timer_set) {
  920.         ngx_del_timer(c->read);
  921.     }

  923.     s->login_attempt++;

  925.     ngx_mail_auth_http_init(s);
  926. }


  929. void
  930. ‌ngx_mail_session_internal_server_error(ngx_mail_session_t *s)
  931. {
  932.     ngx_mail_core_srv_conf_t  *cscf;

  934.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  936.     s->out = cscf->protocol->internal_server_error;
  937.     s->quit = 1;

  939.     ngx_mail_send(s->connection->write);
  940. }


  943. void
  944. ‌ngx_mail_close_connection(ngx_connection_t *c)
  945. {
  946.     ngx_pool_t  *pool;

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

  951. #if (NGX_MAIL_SSL)

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

  960. #endif

  962. #if (NGX_STAT_STUB)
  963.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  964. #endif

  966.     c->destroyed = 1;

  968.     pool = c->pool;

  970.     ngx_close_connection(c);

  972.     ngx_destroy_pool(pool);
  973. }


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

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

  989.     ctx = log->data;

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

  995.     s = ctx->session;

  997.     if (s == NULL) {
  998.         return p;
  999.     }

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

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

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

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

  1019.     return p;
  1020. }

One Level Up Top Level