One Level Up Top Level

src/mail/ngx_mail_smtp_handler.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>
  12. #include <ngx_mail_smtp_module.h>


  15. static void ngx_mail_smtp_resolve_addr_handler(ngx_resolver_ctx_t *ctx);
  16. static ngx_int_t ngx_mail_smtp_validate_host(ngx_str_t *name);
  17. static void ngx_mail_smtp_resolve_name(ngx_event_t *rev);
  18. static void ngx_mail_smtp_resolve_name_handler(ngx_resolver_ctx_t *ctx);
  19. static void ngx_mail_smtp_block_reading(ngx_event_t *rev);
  20. static void ngx_mail_smtp_greeting(ngx_mail_session_t *s, ngx_connection_t *c);
  21. static void ngx_mail_smtp_invalid_pipelining(ngx_event_t *rev);
  22. static ngx_int_t ngx_mail_smtp_create_buffer(ngx_mail_session_t *s,
  23.     ngx_connection_t *c);

  25. static ngx_int_t ngx_mail_smtp_helo(ngx_mail_session_t *s, ngx_connection_t *c);
  26. static ngx_int_t ngx_mail_smtp_auth(ngx_mail_session_t *s, ngx_connection_t *c);
  27. static ngx_int_t ngx_mail_smtp_mail(ngx_mail_session_t *s, ngx_connection_t *c);
  28. static ngx_int_t ngx_mail_smtp_starttls(ngx_mail_session_t *s,
  29.     ngx_connection_t *c);
  30. static ngx_int_t ngx_mail_smtp_rset(ngx_mail_session_t *s, ngx_connection_t *c);
  31. static ngx_int_t ngx_mail_smtp_rcpt(ngx_mail_session_t *s, ngx_connection_t *c);

  33. static ngx_int_t ngx_mail_smtp_discard_command(ngx_mail_session_t *s,
  34.     ngx_connection_t *c, char *err);
  35. static void ngx_mail_smtp_log_rejected_command(ngx_mail_session_t *s,
  36.     ngx_connection_t *c, char *err);


  39. ‌static u_char  smtp_ok[] = "250 2.0.0 OK" CRLF;
  40. ‌static u_char  smtp_bye[] = "221 2.0.0 Bye" CRLF;
  41. ‌static u_char  smtp_starttls[] = "220 2.0.0 Start TLS" CRLF;
  42. ‌static u_char  smtp_next[] = "334 " CRLF;
  43. ‌static u_char  smtp_username[] = "334 VXNlcm5hbWU6" CRLF;
  44. ‌static u_char  smtp_password[] = "334 UGFzc3dvcmQ6" CRLF;
  45. ‌static u_char  smtp_invalid_command[] = "500 5.5.1 Invalid command" CRLF;
  46. ‌static u_char  smtp_invalid_pipelining[] =
  47.     "503 5.5.0 Improper use of SMTP command pipelining" CRLF;
  48. ‌static u_char  smtp_invalid_argument[] = "501 5.5.4 Invalid argument" CRLF;
  49. ‌static u_char  smtp_auth_required[] = "530 5.7.1 Authentication required" CRLF;
  50. ‌static u_char  smtp_bad_sequence[] = "503 5.5.1 Bad sequence of commands" CRLF;


  53. ‌static ngx_str_t  smtp_unavailable = ngx_string("[UNAVAILABLE]");
  54. ‌static ngx_str_t  smtp_tempunavail = ngx_string("[TEMPUNAVAIL]");


  57. void
  58. ‌ngx_mail_smtp_init_session(ngx_mail_session_t *s, ngx_connection_t *c)
  59. {
  60.     ngx_resolver_ctx_t        *ctx;
  61.     ngx_mail_core_srv_conf_t  *cscf;

  63.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  65.     if (cscf->resolver == NULL) {
  66.         s->host = smtp_unavailable;
  67.         ngx_mail_smtp_greeting(s, c);
  68.         return;
  69.     }

  71. #if (NGX_HAVE_UNIX_DOMAIN)
  72.     if (c->sockaddr->sa_family == AF_UNIX) {
  73.         s->host = smtp_tempunavail;
  74.         ngx_mail_smtp_greeting(s, c);
  75.         return;
  76.     }
  77. #endif

  79.     c->log->action = "in resolving client address";

  81.     ctx = ngx_resolve_start(cscf->resolver, NULL);
  82.     if (ctx == NULL) {
  83.         ngx_mail_close_connection(c);
  84.         return;
  85.     }

  87.     ctx->addr.sockaddr = c->sockaddr;
  88.     ctx->addr.socklen = c->socklen;
  89.     ctx->handler = ngx_mail_smtp_resolve_addr_handler;
  90.     ctx->data = s;
  91.     ctx->timeout = cscf->resolver_timeout;

  93.     s->resolver_ctx = ctx;
  94.     c->read->handler = ngx_mail_smtp_block_reading;

  96.     if (ngx_resolve_addr(ctx) != NGX_OK) {
  97.         ngx_mail_close_connection(c);
  98.     }
  99. }


  102. static void
  103. ‌ngx_mail_smtp_resolve_addr_handler(ngx_resolver_ctx_t *ctx)
  104. {
  105.     ngx_connection_t    *c;
  106.     ngx_mail_session_t  *s;

  108.     s = ctx->data;
  109.     c = s->connection;

  111.     if (ctx->state) {
  112.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  113.                       "%V could not be resolved (%i: %s)",
  114.                       &c->addr_text, ctx->state,
  115.                       ngx_resolver_strerror(ctx->state));

  117.         if (ctx->state == NGX_RESOLVE_NXDOMAIN) {
  118.             s->host = smtp_unavailable;

  120.         } else {
  121.             s->host = smtp_tempunavail;
  122.         }

  124.         ngx_resolve_addr_done(ctx);

  126.         ngx_mail_smtp_greeting(s, s->connection);

  128.         return;
  129.     }

  131.     if (ngx_mail_smtp_validate_host(&ctx->name) != NGX_OK) {
  132.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  133.                       "%V resolved to invalid host name \"%V\"",
  134.                       &c->addr_text, &ctx->name);

  136.         s->host = smtp_tempunavail;

  138.         ngx_resolve_addr_done(ctx);

  140.         ngx_mail_smtp_greeting(s, s->connection);

  142.         return;
  143.     }

  145.     c->log->action = "in resolving client hostname";

  147.     s->host.data = ngx_pstrdup(c->pool, &ctx->name);
  148.     if (s->host.data == NULL) {
  149.         ngx_resolve_addr_done(ctx);
  150.         ngx_mail_close_connection(c);
  151.         return;
  152.     }

  154.     s->host.len = ctx->name.len;

  156.     ngx_resolve_addr_done(ctx);

  158.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  159.                    "address resolved: %V", &s->host);

  161.     c->read->handler = ngx_mail_smtp_resolve_name;

  163.     ngx_post_event(c->read, &ngx_posted_events);
  164. }


  167. static ngx_int_t
  168. ‌ngx_mail_smtp_validate_host(ngx_str_t *name)
  169. {
  170.     u_char      ch;
  171.     ngx_uint_t  i;

  173.     if (name->len == 0) {
  174.         return NGX_DECLINED;
  175.     }

  177.     for (i = 0; i < name->len; i++) {
  178.         ch = name->data[i];

  180.         /* allow only characters from RFC 1034, Section 3.5 */

  182.         if ((ch >= 'a' && ch <= 'z')
  183.             || (ch >= 'A' && ch <= 'Z')
  184.             || (ch >= '0' && ch <= '9')
  185.             || ch == '-' || ch == '.')
  186.         {
  187.             continue;
  188.         }

  190.         return NGX_DECLINED;
  191.     }

  193.     return NGX_OK;
  194. }


  197. static void
  198. ‌ngx_mail_smtp_resolve_name(ngx_event_t *rev)
  199. {
  200.     ngx_connection_t          *c;
  201.     ngx_mail_session_t        *s;
  202.     ngx_resolver_ctx_t        *ctx;
  203.     ngx_mail_core_srv_conf_t  *cscf;

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

  208.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  210.     ctx = ngx_resolve_start(cscf->resolver, NULL);
  211.     if (ctx == NULL) {
  212.         ngx_mail_close_connection(c);
  213.         return;
  214.     }

  216.     ctx->name = s->host;
  217.     ctx->handler = ngx_mail_smtp_resolve_name_handler;
  218.     ctx->data = s;
  219.     ctx->timeout = cscf->resolver_timeout;

  221.     s->resolver_ctx = ctx;
  222.     c->read->handler = ngx_mail_smtp_block_reading;

  224.     if (ngx_resolve_name(ctx) != NGX_OK) {
  225.         ngx_mail_close_connection(c);
  226.     }
  227. }


  230. static void
  231. ‌ngx_mail_smtp_resolve_name_handler(ngx_resolver_ctx_t *ctx)
  232. {
  233.     ngx_uint_t           i;
  234.     ngx_connection_t    *c;
  235.     ngx_mail_session_t  *s;

  237.     s = ctx->data;
  238.     c = s->connection;

  240.     if (ctx->state) {
  241.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  242.                       "\"%V\" could not be resolved (%i: %s)",
  243.                       &ctx->name, ctx->state,
  244.                       ngx_resolver_strerror(ctx->state));

  246.         if (ctx->state == NGX_RESOLVE_NXDOMAIN) {
  247.             s->host = smtp_unavailable;

  249.         } else {
  250.             s->host = smtp_tempunavail;
  251.         }

  253.     } else {

  255. #if (NGX_DEBUG)
  256.         {
  257.         u_char     text[NGX_SOCKADDR_STRLEN];
  258.         ngx_str_t  addr;

  260.         addr.data = text;

  262.         for (i = 0; i < ctx->naddrs; i++) {
  263.             addr.len = ngx_sock_ntop(ctx->addrs[i].sockaddr,
  264.                                      ctx->addrs[i].socklen,
  265.                                      text, NGX_SOCKADDR_STRLEN, 0);

  267.             ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  268.                            "name was resolved to %V", &addr);
  269.         }
  270.         }
  271. #endif

  273.         for (i = 0; i < ctx->naddrs; i++) {
  274.             if (ngx_cmp_sockaddr(ctx->addrs[i].sockaddr, ctx->addrs[i].socklen,
  275.                                  c->sockaddr, c->socklen, 0)
  276.                 == NGX_OK)
  277.             {
  278.                 goto found;
  279.             }
  280.         }

  282.         s->host = smtp_unavailable;
  283.     }

  285. found:

  287.     ngx_resolve_name_done(ctx);

  289.     ngx_mail_smtp_greeting(s, c);
  290. }


  293. static void
  294. ‌ngx_mail_smtp_block_reading(ngx_event_t *rev)
  295. {
  296.     ngx_connection_t    *c;
  297.     ngx_mail_session_t  *s;
  298.     ngx_resolver_ctx_t  *ctx;

  300.     c = rev->data;
  301.     s = c->data;

  303.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "smtp reading blocked");

  305.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {

  307.         if (s->resolver_ctx) {
  308.             ctx = s->resolver_ctx;

  310.             if (ctx->handler == ngx_mail_smtp_resolve_addr_handler) {
  311.                 ngx_resolve_addr_done(ctx);

  313.             } else if (ctx->handler == ngx_mail_smtp_resolve_name_handler) {
  314.                 ngx_resolve_name_done(ctx);
  315.             }

  317.             s->resolver_ctx = NULL;
  318.         }

  320.         ngx_mail_close_connection(c);
  321.     }
  322. }


  325. static void
  326. ‌ngx_mail_smtp_greeting(ngx_mail_session_t *s, ngx_connection_t *c)
  327. {
  328.     ngx_msec_t                 timeout;
  329.     ngx_mail_core_srv_conf_t  *cscf;
  330.     ngx_mail_smtp_srv_conf_t  *sscf;

  332.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  333.                    "smtp greeting for \"%V\"", &s->host);

  335.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
  336.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  338.     timeout = sscf->greeting_delay ? sscf->greeting_delay : cscf->timeout;
  339.     ngx_add_timer(c->read, timeout);

  341.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  342.         ngx_mail_close_connection(c);
  343.     }

  345.     if (c->read->ready) {
  346.         ngx_post_event(c->read, &ngx_posted_events);
  347.     }

  349.     if (sscf->greeting_delay) {
  350.          c->read->handler = ngx_mail_smtp_invalid_pipelining;
  351.          return;
  352.     }

  354.     c->read->handler = ngx_mail_smtp_init_protocol;

  356.     s->out = sscf->greeting;

  358.     ngx_mail_send(c->write);
  359. }


  362. static void
  363. ‌ngx_mail_smtp_invalid_pipelining(ngx_event_t *rev)
  364. {
  365.     ngx_connection_t          *c;
  366.     ngx_mail_session_t        *s;
  367.     ngx_mail_core_srv_conf_t  *cscf;
  368.     ngx_mail_smtp_srv_conf_t  *sscf;

  370.     c = rev->data;
  371.     s = c->data;

  373.     c->log->action = "in delay pipelining state";

  375.     if (rev->timedout) {

  377.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "delay greeting");

  379.         rev->timedout = 0;

  381.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  383.         c->read->handler = ngx_mail_smtp_init_protocol;

  385.         ngx_add_timer(c->read, cscf->timeout);

  387.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  388.             ngx_mail_close_connection(c);
  389.             return;
  390.         }

  392.         sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  394.         s->out = sscf->greeting;

  396.     } else {

  398.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "invalid pipelining");

  400.         if (s->buffer == NULL) {
  401.             if (ngx_mail_smtp_create_buffer(s, c) != NGX_OK) {
  402.                 return;
  403.             }
  404.         }

  406.         if (ngx_mail_smtp_discard_command(s, c,
  407.                                 "client was rejected before greeting: \"%V\"")
  408.             != NGX_OK)
  409.         {
  410.             return;
  411.         }

  413.         ngx_str_set(&s->out, smtp_invalid_pipelining);
  414.         s->quit = 1;
  415.     }

  417.     ngx_mail_send(c->write);
  418. }


  421. void
  422. ‌ngx_mail_smtp_init_protocol(ngx_event_t *rev)
  423. {
  424.     ngx_connection_t    *c;
  425.     ngx_mail_session_t  *s;

  427.     c = rev->data;

  429.     c->log->action = "in auth state";

  431.     if (rev->timedout) {
  432.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  433.         c->timedout = 1;
  434.         ngx_mail_close_connection(c);
  435.         return;
  436.     }

  438.     s = c->data;

  440.     if (s->buffer == NULL) {
  441.         if (ngx_mail_smtp_create_buffer(s, c) != NGX_OK) {
  442.             return;
  443.         }
  444.     }

  446.     s->mail_state = ngx_smtp_start;
  447.     c->read->handler = ngx_mail_smtp_auth_state;

  449.     ngx_mail_smtp_auth_state(rev);
  450. }


  453. static ngx_int_t
  454. ‌ngx_mail_smtp_create_buffer(ngx_mail_session_t *s, ngx_connection_t *c)
  455. {
  456.     ngx_mail_smtp_srv_conf_t  *sscf;

  458.     if (ngx_array_init(&s->args, c->pool, 2, sizeof(ngx_str_t)) == NGX_ERROR) {
  459.         ngx_mail_session_internal_server_error(s);
  460.         return NGX_ERROR;
  461.     }

  463.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  465.     s->buffer = ngx_create_temp_buf(c->pool, sscf->client_buffer_size);
  466.     if (s->buffer == NULL) {
  467.         ngx_mail_session_internal_server_error(s);
  468.         return NGX_ERROR;
  469.     }

  471.     return NGX_OK;
  472. }


  475. void
  476. ‌ngx_mail_smtp_auth_state(ngx_event_t *rev)
  477. {
  478.     ngx_int_t            rc;
  479.     ngx_connection_t    *c;
  480.     ngx_mail_session_t  *s;

  482.     c = rev->data;
  483.     s = c->data;

  485.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "smtp auth state");

  487.     if (rev->timedout) {
  488.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  489.         c->timedout = 1;
  490.         ngx_mail_close_connection(c);
  491.         return;
  492.     }

  494.     if (s->out.len) {
  495.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "smtp send handler busy");
  496.         s->blocked = 1;

  498.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  499.             ngx_mail_close_connection(c);
  500.             return;
  501.         }

  503.         return;
  504.     }

  506.     s->blocked = 0;

  508.     rc = ngx_mail_read_command(s, c);

  510.     if (rc == NGX_AGAIN) {
  511.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  512.             ngx_mail_session_internal_server_error(s);
  513.             return;
  514.         }

  516.         return;
  517.     }

  519.     if (rc == NGX_ERROR) {
  520.         return;
  521.     }

  523.     ngx_str_set(&s->out, smtp_ok);

  525.     if (rc == NGX_OK) {
  526.         switch (s->mail_state) {

  528.         case ngx_smtp_start:

  530.             switch (s->command) {

  532.             case NGX_SMTP_HELO:
  533.             case NGX_SMTP_EHLO:
  534.                 rc = ngx_mail_smtp_helo(s, c);
  535.                 break;

  537.             case NGX_SMTP_AUTH:
  538.                 rc = ngx_mail_smtp_auth(s, c);
  539.                 break;

  541.             case NGX_SMTP_QUIT:
  542.                 s->quit = 1;
  543.                 ngx_str_set(&s->out, smtp_bye);
  544.                 break;

  546.             case NGX_SMTP_MAIL:
  547.                 rc = ngx_mail_smtp_mail(s, c);
  548.                 break;

  550.             case NGX_SMTP_RCPT:
  551.                 rc = ngx_mail_smtp_rcpt(s, c);
  552.                 break;

  554.             case NGX_SMTP_RSET:
  555.                 rc = ngx_mail_smtp_rset(s, c);
  556.                 break;

  558.             case NGX_SMTP_NOOP:
  559.                 break;

  561.             case NGX_SMTP_STARTTLS:
  562.                 rc = ngx_mail_smtp_starttls(s, c);
  563.                 ngx_str_set(&s->out, smtp_starttls);
  564.                 break;

  566.             default:
  567.                 rc = NGX_MAIL_PARSE_INVALID_COMMAND;
  568.                 break;
  569.             }

  571.             break;

  573.         case ngx_smtp_auth_login_username:
  574.             rc = ngx_mail_auth_login_username(s, c, 0);

  576.             ngx_str_set(&s->out, smtp_password);
  577.             s->mail_state = ngx_smtp_auth_login_password;
  578.             break;

  580.         case ngx_smtp_auth_login_password:
  581.             rc = ngx_mail_auth_login_password(s, c);
  582.             break;

  584.         case ngx_smtp_auth_plain:
  585.             rc = ngx_mail_auth_plain(s, c, 0);
  586.             break;

  588.         case ngx_smtp_auth_cram_md5:
  589.             rc = ngx_mail_auth_cram_md5(s, c);
  590.             break;

  592.         case ngx_smtp_auth_external:
  593.             rc = ngx_mail_auth_external(s, c, 0);
  594.             break;
  595.         }
  596.     }

  598.     if (s->buffer->pos < s->buffer->last) {
  599.         s->blocked = 1;
  600.     }

  602.     switch (rc) {

  604.     case NGX_DONE:
  605.         ngx_mail_auth(s, c);
  606.         return;

  608.     case NGX_ERROR:
  609.         ngx_mail_session_internal_server_error(s);
  610.         return;

  612.     case NGX_MAIL_PARSE_INVALID_COMMAND:
  613.         s->mail_state = ngx_smtp_start;
  614.         s->state = 0;
  615.         ngx_str_set(&s->out, smtp_invalid_command);

  617.         /* fall through */

  619.     case NGX_OK:
  620.         s->args.nelts = 0;

  622.         if (s->buffer->pos == s->buffer->last) {
  623.             s->buffer->pos = s->buffer->start;
  624.             s->buffer->last = s->buffer->start;
  625.         }

  627.         if (s->state) {
  628.             s->arg_start = s->buffer->pos;
  629.         }

  631.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  632.             ngx_mail_session_internal_server_error(s);
  633.             return;
  634.         }

  636.         ngx_mail_send(c->write);
  637.     }
  638. }


  641. static ngx_int_t
  642. ‌ngx_mail_smtp_helo(ngx_mail_session_t *s, ngx_connection_t *c)
  643. {
  644.     ngx_str_t                 *arg;
  645.     ngx_mail_smtp_srv_conf_t  *sscf;

  647.     if (s->args.nelts != 1) {
  648.         ngx_str_set(&s->out, smtp_invalid_argument);
  649.         s->state = 0;
  650.         return NGX_OK;
  651.     }

  653.     arg = s->args.elts;

  655.     s->smtp_helo.len = arg[0].len;

  657.     s->smtp_helo.data = ngx_pnalloc(c->pool, arg[0].len);
  658.     if (s->smtp_helo.data == NULL) {
  659.         return NGX_ERROR;
  660.     }

  662.     ngx_memcpy(s->smtp_helo.data, arg[0].data, arg[0].len);

  664.     ngx_str_null(&s->smtp_from);
  665.     ngx_str_null(&s->smtp_to);

  667.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  669.     if (s->command == NGX_SMTP_HELO) {
  670.         s->out = sscf->server_name;

  672.     } else {
  673.         s->esmtp = 1;

  675. #if (NGX_MAIL_SSL)

  677.         if (c->ssl == NULL) {
  678.             ngx_mail_ssl_conf_t  *sslcf;

  680.             sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  682.             if (sslcf->starttls == NGX_MAIL_STARTTLS_ON) {
  683.                 s->out = sscf->starttls_capability;
  684.                 return NGX_OK;
  685.             }

  687.             if (sslcf->starttls == NGX_MAIL_STARTTLS_ONLY) {
  688.                 s->out = sscf->starttls_only_capability;
  689.                 return NGX_OK;
  690.             }
  691.         }
  692. #endif

  694.         s->out = sscf->capability;
  695.     }

  697.     return NGX_OK;
  698. }


  701. static ngx_int_t
  702. ‌ngx_mail_smtp_auth(ngx_mail_session_t *s, ngx_connection_t *c)
  703. {
  704.     ngx_int_t                  rc;
  705.     ngx_mail_core_srv_conf_t  *cscf;
  706.     ngx_mail_smtp_srv_conf_t  *sscf;

  708. #if (NGX_MAIL_SSL)
  709.     if (ngx_mail_starttls_only(s, c)) {
  710.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  711.     }
  712. #endif

  714.     if (s->args.nelts == 0) {
  715.         ngx_str_set(&s->out, smtp_invalid_argument);
  716.         s->state = 0;
  717.         return NGX_OK;
  718.     }

  720.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  722.     rc = ngx_mail_auth_parse(s, c);

  724.     switch (rc) {

  726.     case NGX_MAIL_AUTH_LOGIN:

  728.         ngx_str_set(&s->out, smtp_username);
  729.         s->mail_state = ngx_smtp_auth_login_username;

  731.         return NGX_OK;

  733.     case NGX_MAIL_AUTH_LOGIN_USERNAME:

  735.         ngx_str_set(&s->out, smtp_password);
  736.         s->mail_state = ngx_smtp_auth_login_password;

  738.         return ngx_mail_auth_login_username(s, c, 1);

  740.     case NGX_MAIL_AUTH_PLAIN:

  742.         ngx_str_set(&s->out, smtp_next);
  743.         s->mail_state = ngx_smtp_auth_plain;

  745.         return NGX_OK;

  747.     case NGX_MAIL_AUTH_CRAM_MD5:

  749.         if (!(sscf->auth_methods & NGX_MAIL_AUTH_CRAM_MD5_ENABLED)) {
  750.             return NGX_MAIL_PARSE_INVALID_COMMAND;
  751.         }

  753.         if (s->salt.data == NULL) {
  754.             cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  756.             if (ngx_mail_salt(s, c, cscf) != NGX_OK) {
  757.                 return NGX_ERROR;
  758.             }
  759.         }

  761.         if (ngx_mail_auth_cram_md5_salt(s, c, "334 ", 4) == NGX_OK) {
  762.             s->mail_state = ngx_smtp_auth_cram_md5;
  763.             return NGX_OK;
  764.         }

  766.         return NGX_ERROR;

  768.     case NGX_MAIL_AUTH_EXTERNAL:

  770.         if (!(sscf->auth_methods & NGX_MAIL_AUTH_EXTERNAL_ENABLED)) {
  771.             return NGX_MAIL_PARSE_INVALID_COMMAND;
  772.         }

  774.         ngx_str_set(&s->out, smtp_username);
  775.         s->mail_state = ngx_smtp_auth_external;

  777.         return NGX_OK;
  778.     }

  780.     return rc;
  781. }


  784. static ngx_int_t
  785. ‌ngx_mail_smtp_mail(ngx_mail_session_t *s, ngx_connection_t *c)
  786. {
  787.     ngx_str_t                 *arg, cmd;
  788.     ngx_mail_smtp_srv_conf_t  *sscf;

  790.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  792.     if (!(sscf->auth_methods & NGX_MAIL_AUTH_NONE_ENABLED)) {
  793.         ngx_mail_smtp_log_rejected_command(s, c, "client was rejected: \"%V\"");
  794.         ngx_str_set(&s->out, smtp_auth_required);
  795.         return NGX_OK;
  796.     }

  798.     /* auth none */

  800.     if (s->smtp_from.len) {
  801.         ngx_str_set(&s->out, smtp_bad_sequence);
  802.         return NGX_OK;
  803.     }

  805.     if (s->args.nelts == 0) {
  806.         ngx_str_set(&s->out, smtp_invalid_argument);
  807.         return NGX_OK;
  808.     }

  810.     arg = s->args.elts;
  811.     arg += s->args.nelts - 1;

  813.     cmd.len = arg->data + arg->len - s->cmd.data;
  814.     cmd.data = s->cmd.data;

  816.     s->smtp_from.len = cmd.len;

  818.     s->smtp_from.data = ngx_pnalloc(c->pool, cmd.len);
  819.     if (s->smtp_from.data == NULL) {
  820.         return NGX_ERROR;
  821.     }

  823.     ngx_memcpy(s->smtp_from.data, cmd.data, cmd.len);

  825.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  826.                    "smtp mail from:\"%V\"", &s->smtp_from);

  828.     ngx_str_set(&s->out, smtp_ok);

  830.     ngx_str_null(&s->login);
  831.     ngx_str_null(&s->passwd);

  833.     return NGX_OK;
  834. }


  837. static ngx_int_t
  838. ‌ngx_mail_smtp_rcpt(ngx_mail_session_t *s, ngx_connection_t *c)
  839. {
  840.     ngx_str_t  *arg, cmd;

  842.     if (s->smtp_from.len == 0) {
  843.         ngx_str_set(&s->out, smtp_bad_sequence);
  844.         return NGX_OK;
  845.     }

  847.     if (s->args.nelts == 0) {
  848.         ngx_str_set(&s->out, smtp_invalid_argument);
  849.         return NGX_OK;
  850.     }

  852.     arg = s->args.elts;
  853.     arg += s->args.nelts - 1;

  855.     cmd.len = arg->data + arg->len - s->cmd.data;
  856.     cmd.data = s->cmd.data;

  858.     s->smtp_to.len = cmd.len;

  860.     s->smtp_to.data = ngx_pnalloc(c->pool, cmd.len);
  861.     if (s->smtp_to.data == NULL) {
  862.         return NGX_ERROR;
  863.     }

  865.     ngx_memcpy(s->smtp_to.data, cmd.data, cmd.len);

  867.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  868.                    "smtp rcpt to:\"%V\"", &s->smtp_to);

  870.     s->auth_method = NGX_MAIL_AUTH_NONE;

  872.     return NGX_DONE;
  873. }


  876. static ngx_int_t
  877. ‌ngx_mail_smtp_rset(ngx_mail_session_t *s, ngx_connection_t *c)
  878. {
  879.     ngx_str_null(&s->smtp_from);
  880.     ngx_str_null(&s->smtp_to);
  881.     ngx_str_set(&s->out, smtp_ok);

  883.     return NGX_OK;
  884. }


  887. static ngx_int_t
  888. ‌ngx_mail_smtp_starttls(ngx_mail_session_t *s, ngx_connection_t *c)
  889. {
  890. #if (NGX_MAIL_SSL)
  891.     ngx_mail_ssl_conf_t  *sslcf;

  893.     if (c->ssl == NULL) {
  894.         sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);
  895.         if (sslcf->starttls) {

  897.             /*
  898.              * RFC3207 requires us to discard any knowledge
  899.              * obtained from client before STARTTLS.
  900.              */

  902.             ngx_str_null(&s->smtp_helo);
  903.             ngx_str_null(&s->smtp_from);
  904.             ngx_str_null(&s->smtp_to);

  906.             s->buffer->pos = s->buffer->start;
  907.             s->buffer->last = s->buffer->start;

  909.             c->read->handler = ngx_mail_starttls_handler;
  910.             return NGX_OK;
  911.         }
  912.     }

  914. #endif

  916.     return NGX_MAIL_PARSE_INVALID_COMMAND;
  917. }


  920. static ngx_int_t
  921. ‌ngx_mail_smtp_discard_command(ngx_mail_session_t *s, ngx_connection_t *c,
  922.     char *err)
  923. {
  924.     ssize_t    n;

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

  928.     if (n == NGX_ERROR || n == 0) {
  929.         ngx_mail_close_connection(c);
  930.         return NGX_ERROR;
  931.     }

  933.     if (n > 0) {
  934.         s->buffer->last += n;
  935.     }

  937.     if (n == NGX_AGAIN) {
  938.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  939.             ngx_mail_session_internal_server_error(s);
  940.             return NGX_ERROR;
  941.         }

  943.         return NGX_AGAIN;
  944.     }

  946.     ngx_mail_smtp_log_rejected_command(s, c, err);

  948.     s->buffer->pos = s->buffer->start;
  949.     s->buffer->last = s->buffer->start;

  951.     return NGX_OK;
  952. }


  955. static void
  956. ‌ngx_mail_smtp_log_rejected_command(ngx_mail_session_t *s, ngx_connection_t *c,
  957.     char *err)
  958. {
  959.     u_char      ch;
  960.     ngx_str_t   cmd;
  961.     ngx_uint_t  i;

  963.     if (c->log->log_level < NGX_LOG_INFO) {
  964.         return;
  965.     }

  967.     cmd.len = s->buffer->last - s->buffer->start;
  968.     cmd.data = s->buffer->start;

  970.     for (i = 0; i < cmd.len; i++) {
  971.         ch = cmd.data[i];

  973.         if (ch != CR && ch != LF) {
  974.             continue;
  975.         }

  977.         cmd.data[i] = '_';
  978.     }

  980.     cmd.len = i;

  982.     ngx_log_error(NGX_LOG_INFO, c->log, 0, err, &cmd);
  983. }

One Level Up Top Level