One Level Up Top Level

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


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

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

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


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


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


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

  61.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

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

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

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

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

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

  91.     if (ngx_resolve_addr(ctx) != NGX_OK) {
  92.         ngx_mail_close_connection(c);
  93.     }
  94. }


  97. static void
  98. ‌ngx_mail_smtp_resolve_addr_handler(ngx_resolver_ctx_t *ctx)
  99. {
  100.     ngx_connection_t    *c;
  101.     ngx_mail_session_t  *s;

  103.     s = ctx->data;
  104.     c = s->connection;

  106.     if (ctx->state) {
  107.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  108.                       "%V could not be resolved (%i: %s)",
  109.                       &c->addr_text, ctx->state,
  110.                       ngx_resolver_strerror(ctx->state));

  112.         if (ctx->state == NGX_RESOLVE_NXDOMAIN) {
  113.             s->host = smtp_unavailable;

  115.         } else {
  116.             s->host = smtp_tempunavail;
  117.         }

  119.         ngx_resolve_addr_done(ctx);

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

  123.         return;
  124.     }

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

  128.     s->host.data = ngx_pstrdup(c->pool, &ctx->name);
  129.     if (s->host.data == NULL) {
  130.         ngx_resolve_addr_done(ctx);
  131.         ngx_mail_close_connection(c);
  132.         return;
  133.     }

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

  137.     ngx_resolve_addr_done(ctx);

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

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

  144.     ngx_post_event(c->read, &ngx_posted_events);
  145. }


  148. static void
  149. ‌ngx_mail_smtp_resolve_name(ngx_event_t *rev)
  150. {
  151.     ngx_connection_t          *c;
  152.     ngx_mail_session_t        *s;
  153.     ngx_resolver_ctx_t        *ctx;
  154.     ngx_mail_core_srv_conf_t  *cscf;

  156.     c = rev->data;
  157.     s = c->data;

  159.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  161.     ctx = ngx_resolve_start(cscf->resolver, NULL);
  162.     if (ctx == NULL) {
  163.         ngx_mail_close_connection(c);
  164.         return;
  165.     }

  167.     ctx->name = s->host;
  168.     ctx->handler = ngx_mail_smtp_resolve_name_handler;
  169.     ctx->data = s;
  170.     ctx->timeout = cscf->resolver_timeout;

  172.     if (ngx_resolve_name(ctx) != NGX_OK) {
  173.         ngx_mail_close_connection(c);
  174.     }
  175. }


  178. static void
  179. ‌ngx_mail_smtp_resolve_name_handler(ngx_resolver_ctx_t *ctx)
  180. {
  181.     ngx_uint_t           i;
  182.     ngx_connection_t    *c;
  183.     ngx_mail_session_t  *s;

  185.     s = ctx->data;
  186.     c = s->connection;

  188.     if (ctx->state) {
  189.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  190.                       "\"%V\" could not be resolved (%i: %s)",
  191.                       &ctx->name, ctx->state,
  192.                       ngx_resolver_strerror(ctx->state));

  194.         if (ctx->state == NGX_RESOLVE_NXDOMAIN) {
  195.             s->host = smtp_unavailable;

  197.         } else {
  198.             s->host = smtp_tempunavail;
  199.         }

  201.     } else {

  203. #if (NGX_DEBUG)
  204.         {
  205.         u_char     text[NGX_SOCKADDR_STRLEN];
  206.         ngx_str_t  addr;

  208.         addr.data = text;

  210.         for (i = 0; i < ctx->naddrs; i++) {
  211.             addr.len = ngx_sock_ntop(ctx->addrs[i].sockaddr,
  212.                                      ctx->addrs[i].socklen,
  213.                                      text, NGX_SOCKADDR_STRLEN, 0);

  215.             ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  216.                            "name was resolved to %V", &addr);
  217.         }
  218.         }
  219. #endif

  221.         for (i = 0; i < ctx->naddrs; i++) {
  222.             if (ngx_cmp_sockaddr(ctx->addrs[i].sockaddr, ctx->addrs[i].socklen,
  223.                                  c->sockaddr, c->socklen, 0)
  224.                 == NGX_OK)
  225.             {
  226.                 goto found;
  227.             }
  228.         }

  230.         s->host = smtp_unavailable;
  231.     }

  233. found:

  235.     ngx_resolve_name_done(ctx);

  237.     ngx_mail_smtp_greeting(s, c);
  238. }


  241. static void
  242. ‌ngx_mail_smtp_greeting(ngx_mail_session_t *s, ngx_connection_t *c)
  243. {
  244.     ngx_msec_t                 timeout;
  245.     ngx_mail_core_srv_conf_t  *cscf;
  246.     ngx_mail_smtp_srv_conf_t  *sscf;

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

  251.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
  252.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

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

  257.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  258.         ngx_mail_close_connection(c);
  259.     }

  261.     if (sscf->greeting_delay) {
  262.          c->read->handler = ngx_mail_smtp_invalid_pipelining;
  263.          return;
  264.     }

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

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

  270.     ngx_mail_send(c->write);
  271. }


  274. static void
  275. ‌ngx_mail_smtp_invalid_pipelining(ngx_event_t *rev)
  276. {
  277.     ngx_connection_t          *c;
  278.     ngx_mail_session_t        *s;
  279.     ngx_mail_core_srv_conf_t  *cscf;
  280.     ngx_mail_smtp_srv_conf_t  *sscf;

  282.     c = rev->data;
  283.     s = c->data;

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

  287.     if (rev->timedout) {

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

  291.         rev->timedout = 0;

  293.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

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

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

  299.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  300.             ngx_mail_close_connection(c);
  301.             return;
  302.         }

  304.         sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

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

  308.     } else {

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

  312.         if (s->buffer == NULL) {
  313.             if (ngx_mail_smtp_create_buffer(s, c) != NGX_OK) {
  314.                 return;
  315.             }
  316.         }

  318.         if (ngx_mail_smtp_discard_command(s, c,
  319.                                 "client was rejected before greeting: \"%V\"")
  320.             != NGX_OK)
  321.         {
  322.             return;
  323.         }

  325.         ngx_str_set(&s->out, smtp_invalid_pipelining);
  326.         s->quit = 1;
  327.     }

  329.     ngx_mail_send(c->write);
  330. }


  333. void
  334. ‌ngx_mail_smtp_init_protocol(ngx_event_t *rev)
  335. {
  336.     ngx_connection_t    *c;
  337.     ngx_mail_session_t  *s;

  339.     c = rev->data;

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

  343.     if (rev->timedout) {
  344.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  345.         c->timedout = 1;
  346.         ngx_mail_close_connection(c);
  347.         return;
  348.     }

  350.     s = c->data;

  352.     if (s->buffer == NULL) {
  353.         if (ngx_mail_smtp_create_buffer(s, c) != NGX_OK) {
  354.             return;
  355.         }
  356.     }

  358.     s->mail_state = ngx_smtp_start;
  359.     c->read->handler = ngx_mail_smtp_auth_state;

  361.     ngx_mail_smtp_auth_state(rev);
  362. }


  365. static ngx_int_t
  366. ‌ngx_mail_smtp_create_buffer(ngx_mail_session_t *s, ngx_connection_t *c)
  367. {
  368.     ngx_mail_smtp_srv_conf_t  *sscf;

  370.     if (ngx_array_init(&s->args, c->pool, 2, sizeof(ngx_str_t)) == NGX_ERROR) {
  371.         ngx_mail_session_internal_server_error(s);
  372.         return NGX_ERROR;
  373.     }

  375.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  377.     s->buffer = ngx_create_temp_buf(c->pool, sscf->client_buffer_size);
  378.     if (s->buffer == NULL) {
  379.         ngx_mail_session_internal_server_error(s);
  380.         return NGX_ERROR;
  381.     }

  383.     return NGX_OK;
  384. }


  387. void
  388. ‌ngx_mail_smtp_auth_state(ngx_event_t *rev)
  389. {
  390.     ngx_int_t            rc;
  391.     ngx_connection_t    *c;
  392.     ngx_mail_session_t  *s;

  394.     c = rev->data;
  395.     s = c->data;

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

  399.     if (rev->timedout) {
  400.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  401.         c->timedout = 1;
  402.         ngx_mail_close_connection(c);
  403.         return;
  404.     }

  406.     if (s->out.len) {
  407.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "smtp send handler busy");
  408.         s->blocked = 1;
  409.         return;
  410.     }

  412.     s->blocked = 0;

  414.     rc = ngx_mail_read_command(s, c);

  416.     if (rc == NGX_AGAIN || rc == NGX_ERROR) {
  417.         return;
  418.     }

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

  422.     if (rc == NGX_OK) {
  423.         switch (s->mail_state) {

  425.         case ngx_smtp_start:

  427.             switch (s->command) {

  429.             case NGX_SMTP_HELO:
  430.             case NGX_SMTP_EHLO:
  431.                 rc = ngx_mail_smtp_helo(s, c);
  432.                 break;

  434.             case NGX_SMTP_AUTH:
  435.                 rc = ngx_mail_smtp_auth(s, c);
  436.                 break;

  438.             case NGX_SMTP_QUIT:
  439.                 s->quit = 1;
  440.                 ngx_str_set(&s->out, smtp_bye);
  441.                 break;

  443.             case NGX_SMTP_MAIL:
  444.                 rc = ngx_mail_smtp_mail(s, c);
  445.                 break;

  447.             case NGX_SMTP_RCPT:
  448.                 rc = ngx_mail_smtp_rcpt(s, c);
  449.                 break;

  451.             case NGX_SMTP_RSET:
  452.                 rc = ngx_mail_smtp_rset(s, c);
  453.                 break;

  455.             case NGX_SMTP_NOOP:
  456.                 break;

  458.             case NGX_SMTP_STARTTLS:
  459.                 rc = ngx_mail_smtp_starttls(s, c);
  460.                 ngx_str_set(&s->out, smtp_starttls);
  461.                 break;

  463.             default:
  464.                 rc = NGX_MAIL_PARSE_INVALID_COMMAND;
  465.                 break;
  466.             }

  468.             break;

  470.         case ngx_smtp_auth_login_username:
  471.             rc = ngx_mail_auth_login_username(s, c, 0);

  473.             ngx_str_set(&s->out, smtp_password);
  474.             s->mail_state = ngx_smtp_auth_login_password;
  475.             break;

  477.         case ngx_smtp_auth_login_password:
  478.             rc = ngx_mail_auth_login_password(s, c);
  479.             break;

  481.         case ngx_smtp_auth_plain:
  482.             rc = ngx_mail_auth_plain(s, c, 0);
  483.             break;

  485.         case ngx_smtp_auth_cram_md5:
  486.             rc = ngx_mail_auth_cram_md5(s, c);
  487.             break;
  488.         }
  489.     }

  491.     if (s->buffer->pos < s->buffer->last) {
  492.         s->blocked = 1;
  493.     }

  495.     switch (rc) {

  497.     case NGX_DONE:
  498.         ngx_mail_auth(s, c);
  499.         return;

  501.     case NGX_ERROR:
  502.         ngx_mail_session_internal_server_error(s);
  503.         return;

  505.     case NGX_MAIL_PARSE_INVALID_COMMAND:
  506.         s->mail_state = ngx_smtp_start;
  507.         s->state = 0;
  508.         ngx_str_set(&s->out, smtp_invalid_command);

  510.         /* fall through */

  512.     case NGX_OK:
  513.         s->args.nelts = 0;

  515.         if (s->buffer->pos == s->buffer->last) {
  516.             s->buffer->pos = s->buffer->start;
  517.             s->buffer->last = s->buffer->start;
  518.         }

  520.         if (s->state) {
  521.             s->arg_start = s->buffer->pos;
  522.         }

  524.         ngx_mail_send(c->write);
  525.     }
  526. }


  529. static ngx_int_t
  530. ‌ngx_mail_smtp_helo(ngx_mail_session_t *s, ngx_connection_t *c)
  531. {
  532.     ngx_str_t                 *arg;
  533.     ngx_mail_smtp_srv_conf_t  *sscf;

  535.     if (s->args.nelts != 1) {
  536.         ngx_str_set(&s->out, smtp_invalid_argument);
  537.         s->state = 0;
  538.         return NGX_OK;
  539.     }

  541.     arg = s->args.elts;

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

  545.     s->smtp_helo.data = ngx_pnalloc(c->pool, arg[0].len);
  546.     if (s->smtp_helo.data == NULL) {
  547.         return NGX_ERROR;
  548.     }

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

  552.     ngx_str_null(&s->smtp_from);
  553.     ngx_str_null(&s->smtp_to);

  555.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  557.     if (s->command == NGX_SMTP_HELO) {
  558.         s->out = sscf->server_name;

  560.     } else {
  561.         s->esmtp = 1;

  563. #if (NGX_MAIL_SSL)

  565.         if (c->ssl == NULL) {
  566.             ngx_mail_ssl_conf_t  *sslcf;

  568.             sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  570.             if (sslcf->starttls == NGX_MAIL_STARTTLS_ON) {
  571.                 s->out = sscf->starttls_capability;
  572.                 return NGX_OK;
  573.             }

  575.             if (sslcf->starttls == NGX_MAIL_STARTTLS_ONLY) {
  576.                 s->out = sscf->starttls_only_capability;
  577.                 return NGX_OK;
  578.             }
  579.         }
  580. #endif

  582.         s->out = sscf->capability;
  583.     }

  585.     return NGX_OK;
  586. }


  589. static ngx_int_t
  590. ‌ngx_mail_smtp_auth(ngx_mail_session_t *s, ngx_connection_t *c)
  591. {
  592.     ngx_int_t                  rc;
  593.     ngx_mail_core_srv_conf_t  *cscf;
  594.     ngx_mail_smtp_srv_conf_t  *sscf;

  596. #if (NGX_MAIL_SSL)
  597.     if (ngx_mail_starttls_only(s, c)) {
  598.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  599.     }
  600. #endif

  602.     if (s->args.nelts == 0) {
  603.         ngx_str_set(&s->out, smtp_invalid_argument);
  604.         s->state = 0;
  605.         return NGX_OK;
  606.     }

  608.     rc = ngx_mail_auth_parse(s, c);

  610.     switch (rc) {

  612.     case NGX_MAIL_AUTH_LOGIN:

  614.         ngx_str_set(&s->out, smtp_username);
  615.         s->mail_state = ngx_smtp_auth_login_username;

  617.         return NGX_OK;

  619.     case NGX_MAIL_AUTH_LOGIN_USERNAME:

  621.         ngx_str_set(&s->out, smtp_password);
  622.         s->mail_state = ngx_smtp_auth_login_password;

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

  626.     case NGX_MAIL_AUTH_PLAIN:

  628.         ngx_str_set(&s->out, smtp_next);
  629.         s->mail_state = ngx_smtp_auth_plain;

  631.         return NGX_OK;

  633.     case NGX_MAIL_AUTH_CRAM_MD5:

  635.         sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  637.         if (!(sscf->auth_methods & NGX_MAIL_AUTH_CRAM_MD5_ENABLED)) {
  638.             return NGX_MAIL_PARSE_INVALID_COMMAND;
  639.         }

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

  644.             if (ngx_mail_salt(s, c, cscf) != NGX_OK) {
  645.                 return NGX_ERROR;
  646.             }
  647.         }

  649.         if (ngx_mail_auth_cram_md5_salt(s, c, "334 ", 4) == NGX_OK) {
  650.             s->mail_state = ngx_smtp_auth_cram_md5;
  651.             return NGX_OK;
  652.         }

  654.         return NGX_ERROR;
  655.     }

  657.     return rc;
  658. }


  661. static ngx_int_t
  662. ‌ngx_mail_smtp_mail(ngx_mail_session_t *s, ngx_connection_t *c)
  663. {
  664.     ngx_str_t                 *arg, cmd;
  665.     ngx_mail_smtp_srv_conf_t  *sscf;

  667.     sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);

  669.     if (!(sscf->auth_methods & NGX_MAIL_AUTH_NONE_ENABLED)) {
  670.         ngx_mail_smtp_log_rejected_command(s, c, "client was rejected: \"%V\"");
  671.         ngx_str_set(&s->out, smtp_auth_required);
  672.         return NGX_OK;
  673.     }

  675.     /* auth none */

  677.     if (s->smtp_from.len) {
  678.         ngx_str_set(&s->out, smtp_bad_sequence);
  679.         return NGX_OK;
  680.     }

  682.     if (s->args.nelts == 0) {
  683.         ngx_str_set(&s->out, smtp_invalid_argument);
  684.         return NGX_OK;
  685.     }

  687.     arg = s->args.elts;
  688.     arg += s->args.nelts - 1;

  690.     cmd.len = arg->data + arg->len - s->cmd.data;
  691.     cmd.data = s->cmd.data;

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

  695.     s->smtp_from.data = ngx_pnalloc(c->pool, cmd.len);
  696.     if (s->smtp_from.data == NULL) {
  697.         return NGX_ERROR;
  698.     }

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

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

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

  707.     return NGX_OK;
  708. }


  711. static ngx_int_t
  712. ‌ngx_mail_smtp_rcpt(ngx_mail_session_t *s, ngx_connection_t *c)
  713. {
  714.     ngx_str_t  *arg, cmd;

  716.     if (s->smtp_from.len == 0) {
  717.         ngx_str_set(&s->out, smtp_bad_sequence);
  718.         return NGX_OK;
  719.     }

  721.     if (s->args.nelts == 0) {
  722.         ngx_str_set(&s->out, smtp_invalid_argument);
  723.         return NGX_OK;
  724.     }

  726.     arg = s->args.elts;
  727.     arg += s->args.nelts - 1;

  729.     cmd.len = arg->data + arg->len - s->cmd.data;
  730.     cmd.data = s->cmd.data;

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

  734.     s->smtp_to.data = ngx_pnalloc(c->pool, cmd.len);
  735.     if (s->smtp_to.data == NULL) {
  736.         return NGX_ERROR;
  737.     }

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

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

  744.     s->auth_method = NGX_MAIL_AUTH_NONE;

  746.     return NGX_DONE;
  747. }


  750. static ngx_int_t
  751. ‌ngx_mail_smtp_rset(ngx_mail_session_t *s, ngx_connection_t *c)
  752. {
  753.     ngx_str_null(&s->smtp_from);
  754.     ngx_str_null(&s->smtp_to);
  755.     ngx_str_set(&s->out, smtp_ok);

  757.     return NGX_OK;
  758. }


  761. static ngx_int_t
  762. ‌ngx_mail_smtp_starttls(ngx_mail_session_t *s, ngx_connection_t *c)
  763. {
  764. #if (NGX_MAIL_SSL)
  765.     ngx_mail_ssl_conf_t  *sslcf;

  767.     if (c->ssl == NULL) {
  768.         sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);
  769.         if (sslcf->starttls) {

  771.             /*
  772.              * RFC3207 requires us to discard any knowledge
  773.              * obtained from client before STARTTLS.
  774.              */

  776.             ngx_str_null(&s->smtp_helo);
  777.             ngx_str_null(&s->smtp_from);
  778.             ngx_str_null(&s->smtp_to);

  780.             s->buffer->pos = s->buffer->start;
  781.             s->buffer->last = s->buffer->start;

  783.             c->read->handler = ngx_mail_starttls_handler;
  784.             return NGX_OK;
  785.         }
  786.     }

  788. #endif

  790.     return NGX_MAIL_PARSE_INVALID_COMMAND;
  791. }


  794. static ngx_int_t
  795. ‌ngx_mail_smtp_discard_command(ngx_mail_session_t *s, ngx_connection_t *c,
  796.     char *err)
  797. {
  798.     ssize_t    n;

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

  802.     if (n == NGX_ERROR || n == 0) {
  803.         ngx_mail_close_connection(c);
  804.         return NGX_ERROR;
  805.     }

  807.     if (n > 0) {
  808.         s->buffer->last += n;
  809.     }

  811.     if (n == NGX_AGAIN) {
  812.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  813.             ngx_mail_session_internal_server_error(s);
  814.             return NGX_ERROR;
  815.         }

  817.         return NGX_AGAIN;
  818.     }

  820.     ngx_mail_smtp_log_rejected_command(s, c, err);

  822.     s->buffer->pos = s->buffer->start;
  823.     s->buffer->last = s->buffer->start;

  825.     return NGX_OK;
  826. }


  829. static void
  830. ‌ngx_mail_smtp_log_rejected_command(ngx_mail_session_t *s, ngx_connection_t *c,
  831.     char *err)
  832. {
  833.     u_char      ch;
  834.     ngx_str_t   cmd;
  835.     ngx_uint_t  i;

  837.     if (c->log->log_level < NGX_LOG_INFO) {
  838.         return;
  839.     }

  841.     cmd.len = s->buffer->last - s->buffer->start;
  842.     cmd.data = s->buffer->start;

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

  847.         if (ch != CR && ch != LF) {
  848.             continue;
  849.         }

  851.         cmd.data[i] = '_';
  852.     }

  854.     cmd.len = i;

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

One Level Up Top Level