![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_mail_smtp_handler.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / mail|
Return to ngx_mail_smtp_handler.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / mail |
1.1 misho 1:
2: /*
3: * Copyright (C) Igor Sysoev
4: * Copyright (C) Nginx, Inc.
5: */
6:
7:
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>
13:
14:
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);
22:
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);
30:
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);
35:
36:
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;
49:
50:
51: static ngx_str_t smtp_unavailable = ngx_string("[UNAVAILABLE]");
52: static ngx_str_t smtp_tempunavail = ngx_string("[TEMPUNAVAIL]");
53:
54:
55: void
56: ngx_mail_smtp_init_session(ngx_mail_session_t *s, ngx_connection_t *c)
57: {
58: struct sockaddr_in *sin;
59: ngx_resolver_ctx_t *ctx;
60: ngx_mail_core_srv_conf_t *cscf;
61:
62: cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
63:
64: if (cscf->resolver == NULL) {
65: s->host = smtp_unavailable;
66: ngx_mail_smtp_greeting(s, c);
67: return;
68: }
69:
70: if (c->sockaddr->sa_family != AF_INET) {
71: s->host = smtp_tempunavail;
72: ngx_mail_smtp_greeting(s, c);
73: return;
74: }
75:
76: c->log->action = "in resolving client address";
77:
78: ctx = ngx_resolve_start(cscf->resolver, NULL);
79: if (ctx == NULL) {
80: ngx_mail_close_connection(c);
81: return;
82: }
83:
84: /* AF_INET only */
85:
86: sin = (struct sockaddr_in *) c->sockaddr;
87:
88: ctx->addr = sin->sin_addr.s_addr;
89: ctx->handler = ngx_mail_smtp_resolve_addr_handler;
90: ctx->data = s;
91: ctx->timeout = cscf->resolver_timeout;
92:
93: if (ngx_resolve_addr(ctx) != NGX_OK) {
94: ngx_mail_close_connection(c);
95: }
96: }
97:
98:
99: static void
100: ngx_mail_smtp_resolve_addr_handler(ngx_resolver_ctx_t *ctx)
101: {
102: ngx_connection_t *c;
103: ngx_mail_session_t *s;
104:
105: s = ctx->data;
106: c = s->connection;
107:
108: if (ctx->state) {
109: ngx_log_error(NGX_LOG_ERR, c->log, 0,
110: "%V could not be resolved (%i: %s)",
111: &c->addr_text, ctx->state,
112: ngx_resolver_strerror(ctx->state));
113:
114: if (ctx->state == NGX_RESOLVE_NXDOMAIN) {
115: s->host = smtp_unavailable;
116:
117: } else {
118: s->host = smtp_tempunavail;
119: }
120:
121: ngx_resolve_addr_done(ctx);
122:
123: ngx_mail_smtp_greeting(s, s->connection);
124:
125: return;
126: }
127:
128: c->log->action = "in resolving client hostname";
129:
130: s->host.data = ngx_pstrdup(c->pool, &ctx->name);
131: if (s->host.data == NULL) {
132: ngx_resolve_addr_done(ctx);
133: ngx_mail_close_connection(c);
134: return;
135: }
136:
137: s->host.len = ctx->name.len;
138:
139: ngx_resolve_addr_done(ctx);
140:
141: ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
142: "address resolved: %V", &s->host);
143:
144: c->read->handler = ngx_mail_smtp_resolve_name;
145:
146: ngx_post_event(c->read, &ngx_posted_events);
147: }
148:
149:
150: static void
151: ngx_mail_smtp_resolve_name(ngx_event_t *rev)
152: {
153: ngx_connection_t *c;
154: ngx_mail_session_t *s;
155: ngx_resolver_ctx_t *ctx;
156: ngx_mail_core_srv_conf_t *cscf;
157:
158: c = rev->data;
159: s = c->data;
160:
161: cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
162:
163: ctx = ngx_resolve_start(cscf->resolver, NULL);
164: if (ctx == NULL) {
165: ngx_mail_close_connection(c);
166: return;
167: }
168:
169: ctx->name = s->host;
170: ctx->type = NGX_RESOLVE_A;
171: ctx->handler = ngx_mail_smtp_resolve_name_handler;
172: ctx->data = s;
173: ctx->timeout = cscf->resolver_timeout;
174:
175: if (ngx_resolve_name(ctx) != NGX_OK) {
176: ngx_mail_close_connection(c);
177: }
178: }
179:
180:
181: static void
182: ngx_mail_smtp_resolve_name_handler(ngx_resolver_ctx_t *ctx)
183: {
184: in_addr_t addr;
185: ngx_uint_t i;
186: ngx_connection_t *c;
187: struct sockaddr_in *sin;
188: ngx_mail_session_t *s;
189:
190: s = ctx->data;
191: c = s->connection;
192:
193: if (ctx->state) {
194: ngx_log_error(NGX_LOG_ERR, c->log, 0,
195: "\"%V\" could not be resolved (%i: %s)",
196: &ctx->name, ctx->state,
197: ngx_resolver_strerror(ctx->state));
198:
199: if (ctx->state == NGX_RESOLVE_NXDOMAIN) {
200: s->host = smtp_unavailable;
201:
202: } else {
203: s->host = smtp_tempunavail;
204: }
205:
206: } else {
207:
208: /* AF_INET only */
209:
210: sin = (struct sockaddr_in *) c->sockaddr;
211:
212: for (i = 0; i < ctx->naddrs; i++) {
213:
214: addr = ctx->addrs[i];
215:
216: ngx_log_debug4(NGX_LOG_DEBUG_MAIL, c->log, 0,
217: "name was resolved to %ud.%ud.%ud.%ud",
218: (ntohl(addr) >> 24) & 0xff,
219: (ntohl(addr) >> 16) & 0xff,
220: (ntohl(addr) >> 8) & 0xff,
221: ntohl(addr) & 0xff);
222:
223: if (addr == sin->sin_addr.s_addr) {
224: goto found;
225: }
226: }
227:
228: s->host = smtp_unavailable;
229: }
230:
231: found:
232:
233: ngx_resolve_name_done(ctx);
234:
235: ngx_mail_smtp_greeting(s, c);
236: }
237:
238:
239: static void
240: ngx_mail_smtp_greeting(ngx_mail_session_t *s, ngx_connection_t *c)
241: {
242: ngx_msec_t timeout;
243: ngx_mail_core_srv_conf_t *cscf;
244: ngx_mail_smtp_srv_conf_t *sscf;
245:
246: ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
247: "smtp greeting for \"%V\"", &s->host);
248:
249: cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
250: sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
251:
252: timeout = sscf->greeting_delay ? sscf->greeting_delay : cscf->timeout;
253: ngx_add_timer(c->read, timeout);
254:
255: if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
256: ngx_mail_close_connection(c);
257: }
258:
259: if (sscf->greeting_delay) {
260: c->read->handler = ngx_mail_smtp_invalid_pipelining;
261: return;
262: }
263:
264: c->read->handler = ngx_mail_smtp_init_protocol;
265:
266: s->out = sscf->greeting;
267:
268: ngx_mail_send(c->write);
269: }
270:
271:
272: static void
273: ngx_mail_smtp_invalid_pipelining(ngx_event_t *rev)
274: {
275: ngx_connection_t *c;
276: ngx_mail_session_t *s;
277: ngx_mail_core_srv_conf_t *cscf;
278: ngx_mail_smtp_srv_conf_t *sscf;
279:
280: c = rev->data;
281: s = c->data;
282:
283: c->log->action = "in delay pipelining state";
284:
285: if (rev->timedout) {
286:
287: ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "delay greeting");
288:
289: rev->timedout = 0;
290:
291: cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
292:
293: c->read->handler = ngx_mail_smtp_init_protocol;
294:
295: ngx_add_timer(c->read, cscf->timeout);
296:
297: if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
298: ngx_mail_close_connection(c);
299: return;
300: }
301:
302: sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
303:
304: s->out = sscf->greeting;
305:
306: } else {
307:
308: ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "invalid pipelining");
309:
310: if (s->buffer == NULL) {
311: if (ngx_mail_smtp_create_buffer(s, c) != NGX_OK) {
312: return;
313: }
314: }
315:
316: if (ngx_mail_smtp_discard_command(s, c,
317: "client was rejected before greeting: \"%V\"")
318: != NGX_OK)
319: {
320: return;
321: }
322:
323: ngx_str_set(&s->out, smtp_invalid_pipelining);
324: }
325:
326: ngx_mail_send(c->write);
327: }
328:
329:
330: void
331: ngx_mail_smtp_init_protocol(ngx_event_t *rev)
332: {
333: ngx_connection_t *c;
334: ngx_mail_session_t *s;
335:
336: c = rev->data;
337:
338: c->log->action = "in auth state";
339:
340: if (rev->timedout) {
341: ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
342: c->timedout = 1;
343: ngx_mail_close_connection(c);
344: return;
345: }
346:
347: s = c->data;
348:
349: if (s->buffer == NULL) {
350: if (ngx_mail_smtp_create_buffer(s, c) != NGX_OK) {
351: return;
352: }
353: }
354:
355: s->mail_state = ngx_smtp_start;
356: c->read->handler = ngx_mail_smtp_auth_state;
357:
358: ngx_mail_smtp_auth_state(rev);
359: }
360:
361:
362: static ngx_int_t
363: ngx_mail_smtp_create_buffer(ngx_mail_session_t *s, ngx_connection_t *c)
364: {
365: ngx_mail_smtp_srv_conf_t *sscf;
366:
367: if (ngx_array_init(&s->args, c->pool, 2, sizeof(ngx_str_t)) == NGX_ERROR) {
368: ngx_mail_session_internal_server_error(s);
369: return NGX_ERROR;
370: }
371:
372: sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
373:
374: s->buffer = ngx_create_temp_buf(c->pool, sscf->client_buffer_size);
375: if (s->buffer == NULL) {
376: ngx_mail_session_internal_server_error(s);
377: return NGX_ERROR;
378: }
379:
380: return NGX_OK;
381: }
382:
383:
384: void
385: ngx_mail_smtp_auth_state(ngx_event_t *rev)
386: {
387: ngx_int_t rc;
388: ngx_connection_t *c;
389: ngx_mail_session_t *s;
390:
391: c = rev->data;
392: s = c->data;
393:
394: ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "smtp auth state");
395:
396: if (rev->timedout) {
397: ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
398: c->timedout = 1;
399: ngx_mail_close_connection(c);
400: return;
401: }
402:
403: if (s->out.len) {
404: ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "smtp send handler busy");
405: s->blocked = 1;
406: return;
407: }
408:
409: s->blocked = 0;
410:
411: rc = ngx_mail_read_command(s, c);
412:
413: if (rc == NGX_AGAIN || rc == NGX_ERROR) {
414: return;
415: }
416:
417: ngx_str_set(&s->out, smtp_ok);
418:
419: if (rc == NGX_OK) {
420: switch (s->mail_state) {
421:
422: case ngx_smtp_start:
423:
424: switch (s->command) {
425:
426: case NGX_SMTP_HELO:
427: case NGX_SMTP_EHLO:
428: rc = ngx_mail_smtp_helo(s, c);
429: break;
430:
431: case NGX_SMTP_AUTH:
432: rc = ngx_mail_smtp_auth(s, c);
433: break;
434:
435: case NGX_SMTP_QUIT:
436: s->quit = 1;
437: ngx_str_set(&s->out, smtp_bye);
438: break;
439:
440: case NGX_SMTP_MAIL:
441: rc = ngx_mail_smtp_mail(s, c);
442: break;
443:
444: case NGX_SMTP_RCPT:
445: rc = ngx_mail_smtp_rcpt(s, c);
446: break;
447:
448: case NGX_SMTP_RSET:
449: rc = ngx_mail_smtp_rset(s, c);
450: break;
451:
452: case NGX_SMTP_NOOP:
453: break;
454:
455: case NGX_SMTP_STARTTLS:
456: rc = ngx_mail_smtp_starttls(s, c);
457: ngx_str_set(&s->out, smtp_starttls);
458: break;
459:
460: default:
461: rc = NGX_MAIL_PARSE_INVALID_COMMAND;
462: break;
463: }
464:
465: break;
466:
467: case ngx_smtp_auth_login_username:
468: rc = ngx_mail_auth_login_username(s, c, 0);
469:
470: ngx_str_set(&s->out, smtp_password);
471: s->mail_state = ngx_smtp_auth_login_password;
472: break;
473:
474: case ngx_smtp_auth_login_password:
475: rc = ngx_mail_auth_login_password(s, c);
476: break;
477:
478: case ngx_smtp_auth_plain:
479: rc = ngx_mail_auth_plain(s, c, 0);
480: break;
481:
482: case ngx_smtp_auth_cram_md5:
483: rc = ngx_mail_auth_cram_md5(s, c);
484: break;
485: }
486: }
487:
488: switch (rc) {
489:
490: case NGX_DONE:
491: ngx_mail_auth(s, c);
492: return;
493:
494: case NGX_ERROR:
495: ngx_mail_session_internal_server_error(s);
496: return;
497:
498: case NGX_MAIL_PARSE_INVALID_COMMAND:
499: s->mail_state = ngx_smtp_start;
500: s->state = 0;
501: ngx_str_set(&s->out, smtp_invalid_command);
502:
503: /* fall through */
504:
505: case NGX_OK:
506: s->args.nelts = 0;
507: s->buffer->pos = s->buffer->start;
508: s->buffer->last = s->buffer->start;
509:
510: if (s->state) {
511: s->arg_start = s->buffer->start;
512: }
513:
514: ngx_mail_send(c->write);
515: }
516: }
517:
518:
519: static ngx_int_t
520: ngx_mail_smtp_helo(ngx_mail_session_t *s, ngx_connection_t *c)
521: {
522: ngx_str_t *arg;
523: ngx_mail_smtp_srv_conf_t *sscf;
524:
525: if (s->args.nelts != 1) {
526: ngx_str_set(&s->out, smtp_invalid_argument);
527: s->state = 0;
528: return NGX_OK;
529: }
530:
531: arg = s->args.elts;
532:
533: s->smtp_helo.len = arg[0].len;
534:
535: s->smtp_helo.data = ngx_pnalloc(c->pool, arg[0].len);
536: if (s->smtp_helo.data == NULL) {
537: return NGX_ERROR;
538: }
539:
540: ngx_memcpy(s->smtp_helo.data, arg[0].data, arg[0].len);
541:
542: ngx_str_null(&s->smtp_from);
543: ngx_str_null(&s->smtp_to);
544:
545: sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
546:
547: if (s->command == NGX_SMTP_HELO) {
548: s->out = sscf->server_name;
549:
550: } else {
551: s->esmtp = 1;
552:
553: #if (NGX_MAIL_SSL)
554:
555: if (c->ssl == NULL) {
556: ngx_mail_ssl_conf_t *sslcf;
557:
558: sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);
559:
560: if (sslcf->starttls == NGX_MAIL_STARTTLS_ON) {
561: s->out = sscf->starttls_capability;
562: return NGX_OK;
563: }
564:
565: if (sslcf->starttls == NGX_MAIL_STARTTLS_ONLY) {
566: s->out = sscf->starttls_only_capability;
567: return NGX_OK;
568: }
569: }
570: #endif
571:
572: s->out = sscf->capability;
573: }
574:
575: return NGX_OK;
576: }
577:
578:
579: static ngx_int_t
580: ngx_mail_smtp_auth(ngx_mail_session_t *s, ngx_connection_t *c)
581: {
582: ngx_int_t rc;
583: ngx_mail_core_srv_conf_t *cscf;
584: ngx_mail_smtp_srv_conf_t *sscf;
585:
586: #if (NGX_MAIL_SSL)
587: if (ngx_mail_starttls_only(s, c)) {
588: return NGX_MAIL_PARSE_INVALID_COMMAND;
589: }
590: #endif
591:
592: if (s->args.nelts == 0) {
593: ngx_str_set(&s->out, smtp_invalid_argument);
594: s->state = 0;
595: return NGX_OK;
596: }
597:
598: rc = ngx_mail_auth_parse(s, c);
599:
600: switch (rc) {
601:
602: case NGX_MAIL_AUTH_LOGIN:
603:
604: ngx_str_set(&s->out, smtp_username);
605: s->mail_state = ngx_smtp_auth_login_username;
606:
607: return NGX_OK;
608:
609: case NGX_MAIL_AUTH_LOGIN_USERNAME:
610:
611: ngx_str_set(&s->out, smtp_password);
612: s->mail_state = ngx_smtp_auth_login_password;
613:
614: return ngx_mail_auth_login_username(s, c, 1);
615:
616: case NGX_MAIL_AUTH_PLAIN:
617:
618: ngx_str_set(&s->out, smtp_next);
619: s->mail_state = ngx_smtp_auth_plain;
620:
621: return NGX_OK;
622:
623: case NGX_MAIL_AUTH_CRAM_MD5:
624:
625: sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
626:
627: if (!(sscf->auth_methods & NGX_MAIL_AUTH_CRAM_MD5_ENABLED)) {
628: return NGX_MAIL_PARSE_INVALID_COMMAND;
629: }
630:
631: if (s->salt.data == NULL) {
632: cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
633:
634: if (ngx_mail_salt(s, c, cscf) != NGX_OK) {
635: return NGX_ERROR;
636: }
637: }
638:
639: if (ngx_mail_auth_cram_md5_salt(s, c, "334 ", 4) == NGX_OK) {
640: s->mail_state = ngx_smtp_auth_cram_md5;
641: return NGX_OK;
642: }
643:
644: return NGX_ERROR;
645: }
646:
647: return rc;
648: }
649:
650:
651: static ngx_int_t
652: ngx_mail_smtp_mail(ngx_mail_session_t *s, ngx_connection_t *c)
653: {
654: u_char ch;
655: ngx_str_t l;
656: ngx_uint_t i;
657: ngx_mail_smtp_srv_conf_t *sscf;
658:
659: sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
660:
661: if (!(sscf->auth_methods & NGX_MAIL_AUTH_NONE_ENABLED)) {
662: ngx_mail_smtp_log_rejected_command(s, c, "client was rejected: \"%V\"");
663: ngx_str_set(&s->out, smtp_auth_required);
664: return NGX_OK;
665: }
666:
667: /* auth none */
668:
669: if (s->smtp_from.len) {
670: ngx_str_set(&s->out, smtp_bad_sequence);
671: return NGX_OK;
672: }
673:
674: l.len = s->buffer->last - s->buffer->start;
675: l.data = s->buffer->start;
676:
677: for (i = 0; i < l.len; i++) {
678: ch = l.data[i];
679:
680: if (ch != CR && ch != LF) {
681: continue;
682: }
683:
684: l.data[i] = ' ';
685: }
686:
687: while (i) {
688: if (l.data[i - 1] != ' ') {
689: break;
690: }
691:
692: i--;
693: }
694:
695: l.len = i;
696:
697: s->smtp_from.len = l.len;
698:
699: s->smtp_from.data = ngx_pnalloc(c->pool, l.len);
700: if (s->smtp_from.data == NULL) {
701: return NGX_ERROR;
702: }
703:
704: ngx_memcpy(s->smtp_from.data, l.data, l.len);
705:
706: ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
707: "smtp mail from:\"%V\"", &s->smtp_from);
708:
709: ngx_str_set(&s->out, smtp_ok);
710:
711: return NGX_OK;
712: }
713:
714:
715: static ngx_int_t
716: ngx_mail_smtp_rcpt(ngx_mail_session_t *s, ngx_connection_t *c)
717: {
718: u_char ch;
719: ngx_str_t l;
720: ngx_uint_t i;
721:
722: if (s->smtp_from.len == 0) {
723: ngx_str_set(&s->out, smtp_bad_sequence);
724: return NGX_OK;
725: }
726:
727: l.len = s->buffer->last - s->buffer->start;
728: l.data = s->buffer->start;
729:
730: for (i = 0; i < l.len; i++) {
731: ch = l.data[i];
732:
733: if (ch != CR && ch != LF) {
734: continue;
735: }
736:
737: l.data[i] = ' ';
738: }
739:
740: while (i) {
741: if (l.data[i - 1] != ' ') {
742: break;
743: }
744:
745: i--;
746: }
747:
748: l.len = i;
749:
750: s->smtp_to.len = l.len;
751:
752: s->smtp_to.data = ngx_pnalloc(c->pool, l.len);
753: if (s->smtp_to.data == NULL) {
754: return NGX_ERROR;
755: }
756:
757: ngx_memcpy(s->smtp_to.data, l.data, l.len);
758:
759: ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
760: "smtp rcpt to:\"%V\"", &s->smtp_to);
761:
762: s->auth_method = NGX_MAIL_AUTH_NONE;
763:
764: return NGX_DONE;
765: }
766:
767:
768: static ngx_int_t
769: ngx_mail_smtp_rset(ngx_mail_session_t *s, ngx_connection_t *c)
770: {
771: ngx_str_null(&s->smtp_from);
772: ngx_str_null(&s->smtp_to);
773: ngx_str_set(&s->out, smtp_ok);
774:
775: return NGX_OK;
776: }
777:
778:
779: static ngx_int_t
780: ngx_mail_smtp_starttls(ngx_mail_session_t *s, ngx_connection_t *c)
781: {
782: #if (NGX_MAIL_SSL)
783: ngx_mail_ssl_conf_t *sslcf;
784:
785: if (c->ssl == NULL) {
786: sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);
787: if (sslcf->starttls) {
788:
789: /*
790: * RFC3207 requires us to discard any knowledge
791: * obtained from client before STARTTLS.
792: */
793:
794: ngx_str_null(&s->smtp_helo);
795: ngx_str_null(&s->smtp_from);
796: ngx_str_null(&s->smtp_to);
797:
798: c->read->handler = ngx_mail_starttls_handler;
799: return NGX_OK;
800: }
801: }
802:
803: #endif
804:
805: return NGX_MAIL_PARSE_INVALID_COMMAND;
806: }
807:
808:
809: static ngx_int_t
810: ngx_mail_smtp_discard_command(ngx_mail_session_t *s, ngx_connection_t *c,
811: char *err)
812: {
813: ssize_t n;
814:
815: n = c->recv(c, s->buffer->last, s->buffer->end - s->buffer->last);
816:
817: if (n == NGX_ERROR || n == 0) {
818: ngx_mail_close_connection(c);
819: return NGX_ERROR;
820: }
821:
822: if (n > 0) {
823: s->buffer->last += n;
824: }
825:
826: if (n == NGX_AGAIN) {
827: if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
828: ngx_mail_session_internal_server_error(s);
829: return NGX_ERROR;
830: }
831:
832: return NGX_AGAIN;
833: }
834:
835: ngx_mail_smtp_log_rejected_command(s, c, err);
836:
837: s->buffer->pos = s->buffer->start;
838: s->buffer->last = s->buffer->start;
839:
840: return NGX_OK;
841: }
842:
843:
844: static void
845: ngx_mail_smtp_log_rejected_command(ngx_mail_session_t *s, ngx_connection_t *c,
846: char *err)
847: {
848: u_char ch;
849: ngx_str_t cmd;
850: ngx_uint_t i;
851:
852: if (c->log->log_level < NGX_LOG_INFO) {
853: return;
854: }
855:
856: cmd.len = s->buffer->last - s->buffer->start;
857: cmd.data = s->buffer->start;
858:
859: for (i = 0; i < cmd.len; i++) {
860: ch = cmd.data[i];
861:
862: if (ch != CR && ch != LF) {
863: continue;
864: }
865:
866: cmd.data[i] = '_';
867: }
868:
869: cmd.len = i;
870:
871: ngx_log_error(NGX_LOG_INFO, c->log, 0, err, &cmd);
872: }