1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
10: * This software is licensed as described in the file COPYING, which
11: * you should have received as part of this distribution. The terms
12: * are also available at https://curl.haxx.se/docs/copyright.html.
13: *
14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: * copies of the Software, and permit persons to whom the Software is
16: * furnished to do so, under the terms of the COPYING file.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: * RFC1870 SMTP Service Extension for Message Size
22: * RFC2195 CRAM-MD5 authentication
23: * RFC2831 DIGEST-MD5 authentication
24: * RFC3207 SMTP over TLS
25: * RFC4422 Simple Authentication and Security Layer (SASL)
26: * RFC4616 PLAIN authentication
27: * RFC4752 The Kerberos V5 ("GSSAPI") SASL Mechanism
28: * RFC4954 SMTP Authentication
29: * RFC5321 SMTP protocol
30: * RFC5890 Internationalized Domain Names for Applications (IDNA)
31: * RFC6531 SMTP Extension for Internationalized Email
32: * RFC6532 Internationalized Email Headers
33: * RFC6749 OAuth 2.0 Authorization Framework
34: * RFC8314 Use of TLS for Email Submission and Access
35: * Draft SMTP URL Interface <draft-earhart-url-smtp-00.txt>
36: * Draft LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
37: *
38: ***************************************************************************/
39:
40: #include "curl_setup.h"
41:
42: #ifndef CURL_DISABLE_SMTP
43:
44: #ifdef HAVE_NETINET_IN_H
45: #include <netinet/in.h>
46: #endif
47: #ifdef HAVE_ARPA_INET_H
48: #include <arpa/inet.h>
49: #endif
50: #ifdef HAVE_UTSNAME_H
51: #include <sys/utsname.h>
52: #endif
53: #ifdef HAVE_NETDB_H
54: #include <netdb.h>
55: #endif
56: #ifdef __VMS
57: #include <in.h>
58: #include <inet.h>
59: #endif
60:
61: #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
62: #undef in_addr_t
63: #define in_addr_t unsigned long
64: #endif
65:
66: #include <curl/curl.h>
67: #include "urldata.h"
68: #include "sendf.h"
69: #include "hostip.h"
70: #include "progress.h"
71: #include "transfer.h"
72: #include "escape.h"
73: #include "http.h" /* for HTTP proxy tunnel stuff */
74: #include "mime.h"
75: #include "socks.h"
76: #include "smtp.h"
77: #include "strtoofft.h"
78: #include "strcase.h"
79: #include "vtls/vtls.h"
80: #include "connect.h"
81: #include "strerror.h"
82: #include "select.h"
83: #include "multiif.h"
84: #include "url.h"
85: #include "curl_gethostname.h"
86: #include "curl_sasl.h"
87: #include "warnless.h"
88: /* The last 3 #include files should be in this order */
89: #include "curl_printf.h"
90: #include "curl_memory.h"
91: #include "memdebug.h"
92:
93: /* Local API functions */
94: static CURLcode smtp_regular_transfer(struct connectdata *conn, bool *done);
95: static CURLcode smtp_do(struct connectdata *conn, bool *done);
96: static CURLcode smtp_done(struct connectdata *conn, CURLcode status,
97: bool premature);
98: static CURLcode smtp_connect(struct connectdata *conn, bool *done);
99: static CURLcode smtp_disconnect(struct connectdata *conn, bool dead);
100: static CURLcode smtp_multi_statemach(struct connectdata *conn, bool *done);
101: static int smtp_getsock(struct connectdata *conn, curl_socket_t *socks);
102: static CURLcode smtp_doing(struct connectdata *conn, bool *dophase_done);
103: static CURLcode smtp_setup_connection(struct connectdata *conn);
104: static CURLcode smtp_parse_url_options(struct connectdata *conn);
105: static CURLcode smtp_parse_url_path(struct connectdata *conn);
106: static CURLcode smtp_parse_custom_request(struct connectdata *conn);
107: static CURLcode smtp_parse_address(struct connectdata *conn, const char *fqma,
108: char **address, struct hostname *host);
109: static CURLcode smtp_perform_auth(struct connectdata *conn, const char *mech,
110: const char *initresp);
111: static CURLcode smtp_continue_auth(struct connectdata *conn, const char *resp);
112: static void smtp_get_message(char *buffer, char **outptr);
113:
114: /*
115: * SMTP protocol handler.
116: */
117:
118: const struct Curl_handler Curl_handler_smtp = {
119: "SMTP", /* scheme */
120: smtp_setup_connection, /* setup_connection */
121: smtp_do, /* do_it */
122: smtp_done, /* done */
123: ZERO_NULL, /* do_more */
124: smtp_connect, /* connect_it */
125: smtp_multi_statemach, /* connecting */
126: smtp_doing, /* doing */
127: smtp_getsock, /* proto_getsock */
128: smtp_getsock, /* doing_getsock */
129: ZERO_NULL, /* domore_getsock */
130: ZERO_NULL, /* perform_getsock */
131: smtp_disconnect, /* disconnect */
132: ZERO_NULL, /* readwrite */
133: ZERO_NULL, /* connection_check */
134: PORT_SMTP, /* defport */
135: CURLPROTO_SMTP, /* protocol */
136: PROTOPT_CLOSEACTION | PROTOPT_NOURLQUERY | /* flags */
137: PROTOPT_URLOPTIONS
138: };
139:
140: #ifdef USE_SSL
141: /*
142: * SMTPS protocol handler.
143: */
144:
145: const struct Curl_handler Curl_handler_smtps = {
146: "SMTPS", /* scheme */
147: smtp_setup_connection, /* setup_connection */
148: smtp_do, /* do_it */
149: smtp_done, /* done */
150: ZERO_NULL, /* do_more */
151: smtp_connect, /* connect_it */
152: smtp_multi_statemach, /* connecting */
153: smtp_doing, /* doing */
154: smtp_getsock, /* proto_getsock */
155: smtp_getsock, /* doing_getsock */
156: ZERO_NULL, /* domore_getsock */
157: ZERO_NULL, /* perform_getsock */
158: smtp_disconnect, /* disconnect */
159: ZERO_NULL, /* readwrite */
160: ZERO_NULL, /* connection_check */
161: PORT_SMTPS, /* defport */
162: CURLPROTO_SMTPS, /* protocol */
163: PROTOPT_CLOSEACTION | PROTOPT_SSL
164: | PROTOPT_NOURLQUERY | PROTOPT_URLOPTIONS /* flags */
165: };
166: #endif
167:
168: /* SASL parameters for the smtp protocol */
169: static const struct SASLproto saslsmtp = {
170: "smtp", /* The service name */
171: 334, /* Code received when continuation is expected */
172: 235, /* Code to receive upon authentication success */
173: 512 - 8, /* Maximum initial response length (no max) */
174: smtp_perform_auth, /* Send authentication command */
175: smtp_continue_auth, /* Send authentication continuation */
176: smtp_get_message /* Get SASL response message */
177: };
178:
179: #ifdef USE_SSL
180: static void smtp_to_smtps(struct connectdata *conn)
181: {
182: /* Change the connection handler */
183: conn->handler = &Curl_handler_smtps;
184:
185: /* Set the connection's upgraded to TLS flag */
186: conn->tls_upgraded = TRUE;
187: }
188: #else
189: #define smtp_to_smtps(x) Curl_nop_stmt
190: #endif
191:
192: /***********************************************************************
193: *
194: * smtp_endofresp()
195: *
196: * Checks for an ending SMTP status code at the start of the given string, but
197: * also detects various capabilities from the EHLO response including the
198: * supported authentication mechanisms.
199: */
200: static bool smtp_endofresp(struct connectdata *conn, char *line, size_t len,
201: int *resp)
202: {
203: struct smtp_conn *smtpc = &conn->proto.smtpc;
204: bool result = FALSE;
205:
206: /* Nothing for us */
207: if(len < 4 || !ISDIGIT(line[0]) || !ISDIGIT(line[1]) || !ISDIGIT(line[2]))
208: return FALSE;
209:
210: /* Do we have a command response? This should be the response code followed
211: by a space and optionally some text as per RFC-5321 and as outlined in
212: Section 4. Examples of RFC-4954 but some e-mail servers ignore this and
213: only send the response code instead as per Section 4.2. */
214: if(line[3] == ' ' || len == 5) {
215: char tmpline[6];
216:
217: result = TRUE;
218: memset(tmpline, '\0', sizeof(tmpline));
219: memcpy(tmpline, line, (len == 5 ? 5 : 3));
220: *resp = curlx_sltosi(strtol(tmpline, NULL, 10));
221:
222: /* Make sure real server never sends internal value */
223: if(*resp == 1)
224: *resp = 0;
225: }
226: /* Do we have a multiline (continuation) response? */
227: else if(line[3] == '-' &&
228: (smtpc->state == SMTP_EHLO || smtpc->state == SMTP_COMMAND)) {
229: result = TRUE;
230: *resp = 1; /* Internal response code */
231: }
232:
233: return result;
234: }
235:
236: /***********************************************************************
237: *
238: * smtp_get_message()
239: *
240: * Gets the authentication message from the response buffer.
241: */
242: static void smtp_get_message(char *buffer, char **outptr)
243: {
244: size_t len = strlen(buffer);
245: char *message = NULL;
246:
247: if(len > 4) {
248: /* Find the start of the message */
249: len -= 4;
250: for(message = buffer + 4; *message == ' ' || *message == '\t';
251: message++, len--)
252: ;
253:
254: /* Find the end of the message */
255: for(; len--;)
256: if(message[len] != '\r' && message[len] != '\n' && message[len] != ' ' &&
257: message[len] != '\t')
258: break;
259:
260: /* Terminate the message */
261: if(++len) {
262: message[len] = '\0';
263: }
264: }
265: else
266: /* junk input => zero length output */
267: message = &buffer[len];
268:
269: *outptr = message;
270: }
271:
272: /***********************************************************************
273: *
274: * state()
275: *
276: * This is the ONLY way to change SMTP state!
277: */
278: static void state(struct connectdata *conn, smtpstate newstate)
279: {
280: struct smtp_conn *smtpc = &conn->proto.smtpc;
281: #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
282: /* for debug purposes */
283: static const char * const names[] = {
284: "STOP",
285: "SERVERGREET",
286: "EHLO",
287: "HELO",
288: "STARTTLS",
289: "UPGRADETLS",
290: "AUTH",
291: "COMMAND",
292: "MAIL",
293: "RCPT",
294: "DATA",
295: "POSTDATA",
296: "QUIT",
297: /* LAST */
298: };
299:
300: if(smtpc->state != newstate)
301: infof(conn->data, "SMTP %p state change from %s to %s\n",
302: (void *)smtpc, names[smtpc->state], names[newstate]);
303: #endif
304:
305: smtpc->state = newstate;
306: }
307:
308: /***********************************************************************
309: *
310: * smtp_perform_ehlo()
311: *
312: * Sends the EHLO command to not only initialise communication with the ESMTP
313: * server but to also obtain a list of server side supported capabilities.
314: */
315: static CURLcode smtp_perform_ehlo(struct connectdata *conn)
316: {
317: CURLcode result = CURLE_OK;
318: struct smtp_conn *smtpc = &conn->proto.smtpc;
319:
320: smtpc->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanism yet */
321: smtpc->sasl.authused = SASL_AUTH_NONE; /* Clear the authentication mechanism
322: used for esmtp connections */
323: smtpc->tls_supported = FALSE; /* Clear the TLS capability */
324: smtpc->auth_supported = FALSE; /* Clear the AUTH capability */
325:
326: /* Send the EHLO command */
327: result = Curl_pp_sendf(&smtpc->pp, "EHLO %s", smtpc->domain);
328:
329: if(!result)
330: state(conn, SMTP_EHLO);
331:
332: return result;
333: }
334:
335: /***********************************************************************
336: *
337: * smtp_perform_helo()
338: *
339: * Sends the HELO command to initialise communication with the SMTP server.
340: */
341: static CURLcode smtp_perform_helo(struct connectdata *conn)
342: {
343: CURLcode result = CURLE_OK;
344: struct smtp_conn *smtpc = &conn->proto.smtpc;
345:
346: smtpc->sasl.authused = SASL_AUTH_NONE; /* No authentication mechanism used
347: in smtp connections */
348:
349: /* Send the HELO command */
350: result = Curl_pp_sendf(&smtpc->pp, "HELO %s", smtpc->domain);
351:
352: if(!result)
353: state(conn, SMTP_HELO);
354:
355: return result;
356: }
357:
358: /***********************************************************************
359: *
360: * smtp_perform_starttls()
361: *
362: * Sends the STLS command to start the upgrade to TLS.
363: */
364: static CURLcode smtp_perform_starttls(struct connectdata *conn)
365: {
366: /* Send the STARTTLS command */
367: CURLcode result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s", "STARTTLS");
368:
369: if(!result)
370: state(conn, SMTP_STARTTLS);
371:
372: return result;
373: }
374:
375: /***********************************************************************
376: *
377: * smtp_perform_upgrade_tls()
378: *
379: * Performs the upgrade to TLS.
380: */
381: static CURLcode smtp_perform_upgrade_tls(struct connectdata *conn)
382: {
383: /* Start the SSL connection */
384: struct smtp_conn *smtpc = &conn->proto.smtpc;
385: CURLcode result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET,
386: &smtpc->ssldone);
387:
388: if(!result) {
389: if(smtpc->state != SMTP_UPGRADETLS)
390: state(conn, SMTP_UPGRADETLS);
391:
392: if(smtpc->ssldone) {
393: smtp_to_smtps(conn);
394: result = smtp_perform_ehlo(conn);
395: }
396: }
397:
398: return result;
399: }
400:
401: /***********************************************************************
402: *
403: * smtp_perform_auth()
404: *
405: * Sends an AUTH command allowing the client to login with the given SASL
406: * authentication mechanism.
407: */
408: static CURLcode smtp_perform_auth(struct connectdata *conn,
409: const char *mech,
410: const char *initresp)
411: {
412: CURLcode result = CURLE_OK;
413: struct smtp_conn *smtpc = &conn->proto.smtpc;
414:
415: if(initresp) { /* AUTH <mech> ...<crlf> */
416: /* Send the AUTH command with the initial response */
417: result = Curl_pp_sendf(&smtpc->pp, "AUTH %s %s", mech, initresp);
418: }
419: else {
420: /* Send the AUTH command */
421: result = Curl_pp_sendf(&smtpc->pp, "AUTH %s", mech);
422: }
423:
424: return result;
425: }
426:
427: /***********************************************************************
428: *
429: * smtp_continue_auth()
430: *
431: * Sends SASL continuation data or cancellation.
432: */
433: static CURLcode smtp_continue_auth(struct connectdata *conn, const char *resp)
434: {
435: struct smtp_conn *smtpc = &conn->proto.smtpc;
436:
437: return Curl_pp_sendf(&smtpc->pp, "%s", resp);
438: }
439:
440: /***********************************************************************
441: *
442: * smtp_perform_authentication()
443: *
444: * Initiates the authentication sequence, with the appropriate SASL
445: * authentication mechanism.
446: */
447: static CURLcode smtp_perform_authentication(struct connectdata *conn)
448: {
449: CURLcode result = CURLE_OK;
450: struct smtp_conn *smtpc = &conn->proto.smtpc;
451: saslprogress progress;
452:
453: /* Check we have enough data to authenticate with, and the
454: server supports authentiation, and end the connect phase if not */
455: if(!smtpc->auth_supported ||
456: !Curl_sasl_can_authenticate(&smtpc->sasl, conn)) {
457: state(conn, SMTP_STOP);
458: return result;
459: }
460:
461: /* Calculate the SASL login details */
462: result = Curl_sasl_start(&smtpc->sasl, conn, FALSE, &progress);
463:
464: if(!result) {
465: if(progress == SASL_INPROGRESS)
466: state(conn, SMTP_AUTH);
467: else {
468: /* Other mechanisms not supported */
469: infof(conn->data, "No known authentication mechanisms supported!\n");
470: result = CURLE_LOGIN_DENIED;
471: }
472: }
473:
474: return result;
475: }
476:
477: /***********************************************************************
478: *
479: * smtp_perform_command()
480: *
481: * Sends a SMTP based command.
482: */
483: static CURLcode smtp_perform_command(struct connectdata *conn)
484: {
485: CURLcode result = CURLE_OK;
486: struct Curl_easy *data = conn->data;
487: struct SMTP *smtp = data->req.protop;
488:
489: if(smtp->rcpt) {
490: /* We notify the server we are sending UTF-8 data if a) it supports the
491: SMTPUTF8 extension and b) The mailbox contains UTF-8 charaacters, in
492: either the local address or host name parts. This is regardless of
493: whether the host name is encoded using IDN ACE */
494: bool utf8 = FALSE;
495:
496: if((!smtp->custom) || (!smtp->custom[0])) {
497: char *address = NULL;
498: struct hostname host = { NULL, NULL, NULL, NULL };
499:
500: /* Parse the mailbox to verify into the local address and host name
501: parts, converting the host name to an IDN A-label if necessary */
502: result = smtp_parse_address(conn, smtp->rcpt->data,
503: &address, &host);
504: if(result)
505: return result;
506:
507: /* Establish whether we should report SMTPUTF8 to the server for this
508: mailbox as per RFC-6531 sect. 3.1 point 6 */
509: utf8 = (conn->proto.smtpc.utf8_supported) &&
510: ((host.encalloc) || (!Curl_is_ASCII_name(address)) ||
511: (!Curl_is_ASCII_name(host.name)));
512:
513: /* Send the VRFY command (Note: The host name part may be absent when the
514: host is a local system) */
515: result = Curl_pp_sendf(&conn->proto.smtpc.pp, "VRFY %s%s%s%s",
516: address,
517: host.name ? "@" : "",
518: host.name ? host.name : "",
519: utf8 ? " SMTPUTF8" : "");
520:
521: Curl_free_idnconverted_hostname(&host);
522: free(address);
523: }
524: else {
525: /* Establish whether we should report that we support SMTPUTF8 for EXPN
526: commands to the server as per RFC-6531 sect. 3.1 point 6 */
527: utf8 = (conn->proto.smtpc.utf8_supported) &&
528: (!strcmp(smtp->custom, "EXPN"));
529:
530: /* Send the custom recipient based command such as the EXPN command */
531: result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s %s%s", smtp->custom,
532: smtp->rcpt->data,
533: utf8 ? " SMTPUTF8" : "");
534: }
535: }
536: else
537: /* Send the non-recipient based command such as HELP */
538: result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s",
539: smtp->custom && smtp->custom[0] != '\0' ?
540: smtp->custom : "HELP");
541:
542: if(!result)
543: state(conn, SMTP_COMMAND);
544:
545: return result;
546: }
547:
548: /***********************************************************************
549: *
550: * smtp_perform_mail()
551: *
552: * Sends an MAIL command to initiate the upload of a message.
553: */
554: static CURLcode smtp_perform_mail(struct connectdata *conn)
555: {
556: char *from = NULL;
557: char *auth = NULL;
558: char *size = NULL;
559: CURLcode result = CURLE_OK;
560: struct Curl_easy *data = conn->data;
561:
562: /* We notify the server we are sending UTF-8 data if a) it supports the
563: SMTPUTF8 extension and b) The mailbox contains UTF-8 charaacters, in
564: either the local address or host name parts. This is regardless of
565: whether the host name is encoded using IDN ACE */
566: bool utf8 = FALSE;
567:
568: /* Calculate the FROM parameter */
569: if(data->set.str[STRING_MAIL_FROM]) {
570: char *address = NULL;
571: struct hostname host = { NULL, NULL, NULL, NULL };
572:
573: /* Parse the FROM mailbox into the local address and host name parts,
574: converting the host name to an IDN A-label if necessary */
575: result = smtp_parse_address(conn, data->set.str[STRING_MAIL_FROM],
576: &address, &host);
577: if(result)
578: return result;
579:
580: /* Establish whether we should report SMTPUTF8 to the server for this
581: mailbox as per RFC-6531 sect. 3.1 point 4 and sect. 3.4 */
582: utf8 = (conn->proto.smtpc.utf8_supported) &&
583: ((host.encalloc) || (!Curl_is_ASCII_name(address)) ||
584: (!Curl_is_ASCII_name(host.name)));
585:
586: if(host.name) {
587: from = aprintf("<%s@%s>", address, host.name);
588:
589: Curl_free_idnconverted_hostname(&host);
590: }
591: else
592: /* An invalid mailbox was provided but we'll simply let the server worry
593: about that and reply with a 501 error */
594: from = aprintf("<%s>", address);
595:
596: free(address);
597: }
598: else
599: /* Null reverse-path, RFC-5321, sect. 3.6.3 */
600: from = strdup("<>");
601:
602: if(!from)
603: return CURLE_OUT_OF_MEMORY;
604:
605: /* Calculate the optional AUTH parameter */
606: if(data->set.str[STRING_MAIL_AUTH] && conn->proto.smtpc.sasl.authused) {
607: if(data->set.str[STRING_MAIL_AUTH][0] != '\0') {
608: char *address = NULL;
609: struct hostname host = { NULL, NULL, NULL, NULL };
610:
611: /* Parse the AUTH mailbox into the local address and host name parts,
612: converting the host name to an IDN A-label if necessary */
613: result = smtp_parse_address(conn, data->set.str[STRING_MAIL_AUTH],
614: &address, &host);
615: if(result) {
616: free(from);
617: return result;
618: }
619:
620: /* Establish whether we should report SMTPUTF8 to the server for this
621: mailbox as per RFC-6531 sect. 3.1 point 4 and sect. 3.4 */
622: if((!utf8) && (conn->proto.smtpc.utf8_supported) &&
623: ((host.encalloc) || (!Curl_is_ASCII_name(address)) ||
624: (!Curl_is_ASCII_name(host.name))))
625: utf8 = TRUE;
626:
627: if(host.name) {
628: auth = aprintf("<%s@%s>", address, host.name);
629:
630: Curl_free_idnconverted_hostname(&host);
631: }
632: else
633: /* An invalid mailbox was provided but we'll simply let the server
634: worry about it */
635: auth = aprintf("<%s>", address);
636:
637: free(address);
638: }
639: else
640: /* Empty AUTH, RFC-2554, sect. 5 */
641: auth = strdup("<>");
642:
643: if(!auth) {
644: free(from);
645:
646: return CURLE_OUT_OF_MEMORY;
647: }
648: }
649:
650: /* Prepare the mime data if some. */
651: if(data->set.mimepost.kind != MIMEKIND_NONE) {
652: /* Use the whole structure as data. */
653: data->set.mimepost.flags &= ~MIME_BODY_ONLY;
654:
655: /* Add external headers and mime version. */
656: curl_mime_headers(&data->set.mimepost, data->set.headers, 0);
657: result = Curl_mime_prepare_headers(&data->set.mimepost, NULL,
658: NULL, MIMESTRATEGY_MAIL);
659:
660: if(!result)
661: if(!Curl_checkheaders(conn, "Mime-Version"))
662: result = Curl_mime_add_header(&data->set.mimepost.curlheaders,
663: "Mime-Version: 1.0");
664:
665: /* Make sure we will read the entire mime structure. */
666: if(!result)
667: result = Curl_mime_rewind(&data->set.mimepost);
668:
669: if(result) {
670: free(from);
671: free(auth);
672:
673: return result;
674: }
675:
676: data->state.infilesize = Curl_mime_size(&data->set.mimepost);
677:
678: /* Read from mime structure. */
679: data->state.fread_func = (curl_read_callback) Curl_mime_read;
680: data->state.in = (void *) &data->set.mimepost;
681: }
682:
683: /* Calculate the optional SIZE parameter */
684: if(conn->proto.smtpc.size_supported && data->state.infilesize > 0) {
685: size = aprintf("%" CURL_FORMAT_CURL_OFF_T, data->state.infilesize);
686:
687: if(!size) {
688: free(from);
689: free(auth);
690:
691: return CURLE_OUT_OF_MEMORY;
692: }
693: }
694:
695: /* If the mailboxes in the FROM and AUTH parameters don't include a UTF-8
696: based address then quickly scan through the recipient list and check if
697: any there do, as we need to correctly identify our support for SMTPUTF8
698: in the envelope, as per RFC-6531 sect. 3.4 */
699: if(conn->proto.smtpc.utf8_supported && !utf8) {
700: struct SMTP *smtp = data->req.protop;
701: struct curl_slist *rcpt = smtp->rcpt;
702:
703: while(rcpt && !utf8) {
704: /* Does the host name contain non-ASCII characters? */
705: if(!Curl_is_ASCII_name(rcpt->data))
706: utf8 = TRUE;
707:
708: rcpt = rcpt->next;
709: }
710: }
711:
712: /* Send the MAIL command */
713: result = Curl_pp_sendf(&conn->proto.smtpc.pp,
714: "MAIL FROM:%s%s%s%s%s%s",
715: from, /* Mandatory */
716: auth ? " AUTH=" : "", /* Optional on AUTH support */
717: auth ? auth : "", /* */
718: size ? " SIZE=" : "", /* Optional on SIZE support */
719: size ? size : "", /* */
720: utf8 ? " SMTPUTF8" /* Internationalised mailbox */
721: : ""); /* included in our envelope */
722:
723: free(from);
724: free(auth);
725: free(size);
726:
727: if(!result)
728: state(conn, SMTP_MAIL);
729:
730: return result;
731: }
732:
733: /***********************************************************************
734: *
735: * smtp_perform_rcpt_to()
736: *
737: * Sends a RCPT TO command for a given recipient as part of the message upload
738: * process.
739: */
740: static CURLcode smtp_perform_rcpt_to(struct connectdata *conn)
741: {
742: CURLcode result = CURLE_OK;
743: struct Curl_easy *data = conn->data;
744: struct SMTP *smtp = data->req.protop;
745: char *address = NULL;
746: struct hostname host = { NULL, NULL, NULL, NULL };
747:
748: /* Parse the recipient mailbox into the local address and host name parts,
749: converting the host name to an IDN A-label if necessary */
750: result = smtp_parse_address(conn, smtp->rcpt->data,
751: &address, &host);
752: if(result)
753: return result;
754:
755: /* Send the RCPT TO command */
756: if(host.name)
757: result = Curl_pp_sendf(&conn->proto.smtpc.pp, "RCPT TO:<%s@%s>", address,
758: host.name);
759: else
760: /* An invalid mailbox was provided but we'll simply let the server worry
761: about that and reply with a 501 error */
762: result = Curl_pp_sendf(&conn->proto.smtpc.pp, "RCPT TO:<%s>", address);
763:
764: Curl_free_idnconverted_hostname(&host);
765: free(address);
766:
767: if(!result)
768: state(conn, SMTP_RCPT);
769:
770: return result;
771: }
772:
773: /***********************************************************************
774: *
775: * smtp_perform_quit()
776: *
777: * Performs the quit action prior to sclose() being called.
778: */
779: static CURLcode smtp_perform_quit(struct connectdata *conn)
780: {
781: /* Send the QUIT command */
782: CURLcode result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s", "QUIT");
783:
784: if(!result)
785: state(conn, SMTP_QUIT);
786:
787: return result;
788: }
789:
790: /* For the initial server greeting */
791: static CURLcode smtp_state_servergreet_resp(struct connectdata *conn,
792: int smtpcode,
793: smtpstate instate)
794: {
795: CURLcode result = CURLE_OK;
796: struct Curl_easy *data = conn->data;
797:
798: (void)instate; /* no use for this yet */
799:
800: if(smtpcode/100 != 2) {
801: failf(data, "Got unexpected smtp-server response: %d", smtpcode);
802: result = CURLE_WEIRD_SERVER_REPLY;
803: }
804: else
805: result = smtp_perform_ehlo(conn);
806:
807: return result;
808: }
809:
810: /* For STARTTLS responses */
811: static CURLcode smtp_state_starttls_resp(struct connectdata *conn,
812: int smtpcode,
813: smtpstate instate)
814: {
815: CURLcode result = CURLE_OK;
816: struct Curl_easy *data = conn->data;
817:
818: (void)instate; /* no use for this yet */
819:
820: if(smtpcode != 220) {
821: if(data->set.use_ssl != CURLUSESSL_TRY) {
822: failf(data, "STARTTLS denied, code %d", smtpcode);
823: result = CURLE_USE_SSL_FAILED;
824: }
825: else
826: result = smtp_perform_authentication(conn);
827: }
828: else
829: result = smtp_perform_upgrade_tls(conn);
830:
831: return result;
832: }
833:
834: /* For EHLO responses */
835: static CURLcode smtp_state_ehlo_resp(struct connectdata *conn, int smtpcode,
836: smtpstate instate)
837: {
838: CURLcode result = CURLE_OK;
839: struct Curl_easy *data = conn->data;
840: struct smtp_conn *smtpc = &conn->proto.smtpc;
841: const char *line = data->state.buffer;
842: size_t len = strlen(line);
843:
844: (void)instate; /* no use for this yet */
845:
846: if(smtpcode/100 != 2 && smtpcode != 1) {
847: if(data->set.use_ssl <= CURLUSESSL_TRY || conn->ssl[FIRSTSOCKET].use)
848: result = smtp_perform_helo(conn);
849: else {
850: failf(data, "Remote access denied: %d", smtpcode);
851: result = CURLE_REMOTE_ACCESS_DENIED;
852: }
853: }
854: else if(len >= 4) {
855: line += 4;
856: len -= 4;
857:
858: /* Does the server support the STARTTLS capability? */
859: if(len >= 8 && !memcmp(line, "STARTTLS", 8))
860: smtpc->tls_supported = TRUE;
861:
862: /* Does the server support the SIZE capability? */
863: else if(len >= 4 && !memcmp(line, "SIZE", 4))
864: smtpc->size_supported = TRUE;
865:
866: /* Does the server support the UTF-8 capability? */
867: else if(len >= 8 && !memcmp(line, "SMTPUTF8", 8))
868: smtpc->utf8_supported = TRUE;
869:
870: /* Does the server support authentication? */
871: else if(len >= 5 && !memcmp(line, "AUTH ", 5)) {
872: smtpc->auth_supported = TRUE;
873:
874: /* Advance past the AUTH keyword */
875: line += 5;
876: len -= 5;
877:
878: /* Loop through the data line */
879: for(;;) {
880: size_t llen;
881: size_t wordlen;
882: unsigned int mechbit;
883:
884: while(len &&
885: (*line == ' ' || *line == '\t' ||
886: *line == '\r' || *line == '\n')) {
887:
888: line++;
889: len--;
890: }
891:
892: if(!len)
893: break;
894:
895: /* Extract the word */
896: for(wordlen = 0; wordlen < len && line[wordlen] != ' ' &&
897: line[wordlen] != '\t' && line[wordlen] != '\r' &&
898: line[wordlen] != '\n';)
899: wordlen++;
900:
901: /* Test the word for a matching authentication mechanism */
902: mechbit = Curl_sasl_decode_mech(line, wordlen, &llen);
903: if(mechbit && llen == wordlen)
904: smtpc->sasl.authmechs |= mechbit;
905:
906: line += wordlen;
907: len -= wordlen;
908: }
909: }
910:
911: if(smtpcode != 1) {
912: if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
913: /* We don't have a SSL/TLS connection yet, but SSL is requested */
914: if(smtpc->tls_supported)
915: /* Switch to TLS connection now */
916: result = smtp_perform_starttls(conn);
917: else if(data->set.use_ssl == CURLUSESSL_TRY)
918: /* Fallback and carry on with authentication */
919: result = smtp_perform_authentication(conn);
920: else {
921: failf(data, "STARTTLS not supported.");
922: result = CURLE_USE_SSL_FAILED;
923: }
924: }
925: else
926: result = smtp_perform_authentication(conn);
927: }
928: }
929: else {
930: failf(data, "Unexpectedly short EHLO response");
931: result = CURLE_WEIRD_SERVER_REPLY;
932: }
933:
934: return result;
935: }
936:
937: /* For HELO responses */
938: static CURLcode smtp_state_helo_resp(struct connectdata *conn, int smtpcode,
939: smtpstate instate)
940: {
941: CURLcode result = CURLE_OK;
942: struct Curl_easy *data = conn->data;
943:
944: (void)instate; /* no use for this yet */
945:
946: if(smtpcode/100 != 2) {
947: failf(data, "Remote access denied: %d", smtpcode);
948: result = CURLE_REMOTE_ACCESS_DENIED;
949: }
950: else
951: /* End of connect phase */
952: state(conn, SMTP_STOP);
953:
954: return result;
955: }
956:
957: /* For SASL authentication responses */
958: static CURLcode smtp_state_auth_resp(struct connectdata *conn,
959: int smtpcode,
960: smtpstate instate)
961: {
962: CURLcode result = CURLE_OK;
963: struct Curl_easy *data = conn->data;
964: struct smtp_conn *smtpc = &conn->proto.smtpc;
965: saslprogress progress;
966:
967: (void)instate; /* no use for this yet */
968:
969: result = Curl_sasl_continue(&smtpc->sasl, conn, smtpcode, &progress);
970: if(!result)
971: switch(progress) {
972: case SASL_DONE:
973: state(conn, SMTP_STOP); /* Authenticated */
974: break;
975: case SASL_IDLE: /* No mechanism left after cancellation */
976: failf(data, "Authentication cancelled");
977: result = CURLE_LOGIN_DENIED;
978: break;
979: default:
980: break;
981: }
982:
983: return result;
984: }
985:
986: /* For command responses */
987: static CURLcode smtp_state_command_resp(struct connectdata *conn, int smtpcode,
988: smtpstate instate)
989: {
990: CURLcode result = CURLE_OK;
991: struct Curl_easy *data = conn->data;
992: struct SMTP *smtp = data->req.protop;
993: char *line = data->state.buffer;
994: size_t len = strlen(line);
995:
996: (void)instate; /* no use for this yet */
997:
998: if((smtp->rcpt && smtpcode/100 != 2 && smtpcode != 553 && smtpcode != 1) ||
999: (!smtp->rcpt && smtpcode/100 != 2 && smtpcode != 1)) {
1000: failf(data, "Command failed: %d", smtpcode);
1001: result = CURLE_RECV_ERROR;
1002: }
1003: else {
1004: /* Temporarily add the LF character back and send as body to the client */
1005: if(!data->set.opt_no_body) {
1006: line[len] = '\n';
1007: result = Curl_client_write(conn, CLIENTWRITE_BODY, line, len + 1);
1008: line[len] = '\0';
1009: }
1010:
1011: if(smtpcode != 1) {
1012: if(smtp->rcpt) {
1013: smtp->rcpt = smtp->rcpt->next;
1014:
1015: if(smtp->rcpt) {
1016: /* Send the next command */
1017: result = smtp_perform_command(conn);
1018: }
1019: else
1020: /* End of DO phase */
1021: state(conn, SMTP_STOP);
1022: }
1023: else
1024: /* End of DO phase */
1025: state(conn, SMTP_STOP);
1026: }
1027: }
1028:
1029: return result;
1030: }
1031:
1032: /* For MAIL responses */
1033: static CURLcode smtp_state_mail_resp(struct connectdata *conn, int smtpcode,
1034: smtpstate instate)
1035: {
1036: CURLcode result = CURLE_OK;
1037: struct Curl_easy *data = conn->data;
1038:
1039: (void)instate; /* no use for this yet */
1040:
1041: if(smtpcode/100 != 2) {
1042: failf(data, "MAIL failed: %d", smtpcode);
1043: result = CURLE_SEND_ERROR;
1044: }
1045: else
1046: /* Start the RCPT TO command */
1047: result = smtp_perform_rcpt_to(conn);
1048:
1049: return result;
1050: }
1051:
1052: /* For RCPT responses */
1053: static CURLcode smtp_state_rcpt_resp(struct connectdata *conn, int smtpcode,
1054: smtpstate instate)
1055: {
1056: CURLcode result = CURLE_OK;
1057: struct Curl_easy *data = conn->data;
1058: struct SMTP *smtp = data->req.protop;
1059: bool is_smtp_err = FALSE;
1060: bool is_smtp_blocking_err = FALSE;
1061:
1062: (void)instate; /* no use for this yet */
1063:
1064: is_smtp_err = (smtpcode/100 != 2) ? TRUE : FALSE;
1065:
1066: /* If there's multiple RCPT TO to be issued, it's possible to ignore errors
1067: and proceed with only the valid addresses. */
1068: is_smtp_blocking_err =
1069: (is_smtp_err && !data->set.mail_rcpt_allowfails) ? TRUE : FALSE;
1070:
1071: if(is_smtp_err) {
1072: /* Remembering the last failure which we can report if all "RCPT TO" have
1073: failed and we cannot proceed. */
1074: smtp->rcpt_last_error = smtpcode;
1075:
1076: if(is_smtp_blocking_err) {
1077: failf(data, "RCPT failed: %d", smtpcode);
1078: result = CURLE_SEND_ERROR;
1079: }
1080: }
1081: else {
1082: /* Some RCPT TO commands have succeeded. */
1083: smtp->rcpt_had_ok = TRUE;
1084: }
1085:
1086: if(!is_smtp_blocking_err) {
1087: smtp->rcpt = smtp->rcpt->next;
1088:
1089: if(smtp->rcpt)
1090: /* Send the next RCPT TO command */
1091: result = smtp_perform_rcpt_to(conn);
1092: else {
1093: /* We weren't able to issue a successful RCPT TO command while going
1094: over recipients (potentially multiple). Sending back last error. */
1095: if(!smtp->rcpt_had_ok) {
1096: failf(data, "RCPT failed: %d (last error)", smtp->rcpt_last_error);
1097: result = CURLE_SEND_ERROR;
1098: }
1099: else {
1100: /* Send the DATA command */
1101: result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s", "DATA");
1102:
1103: if(!result)
1104: state(conn, SMTP_DATA);
1105: }
1106: }
1107: }
1108:
1109: return result;
1110: }
1111:
1112: /* For DATA response */
1113: static CURLcode smtp_state_data_resp(struct connectdata *conn, int smtpcode,
1114: smtpstate instate)
1115: {
1116: CURLcode result = CURLE_OK;
1117: struct Curl_easy *data = conn->data;
1118:
1119: (void)instate; /* no use for this yet */
1120:
1121: if(smtpcode != 354) {
1122: failf(data, "DATA failed: %d", smtpcode);
1123: result = CURLE_SEND_ERROR;
1124: }
1125: else {
1126: /* Set the progress upload size */
1127: Curl_pgrsSetUploadSize(data, data->state.infilesize);
1128:
1129: /* SMTP upload */
1130: Curl_setup_transfer(data, -1, -1, FALSE, FIRSTSOCKET);
1131:
1132: /* End of DO phase */
1133: state(conn, SMTP_STOP);
1134: }
1135:
1136: return result;
1137: }
1138:
1139: /* For POSTDATA responses, which are received after the entire DATA
1140: part has been sent to the server */
1141: static CURLcode smtp_state_postdata_resp(struct connectdata *conn,
1142: int smtpcode,
1143: smtpstate instate)
1144: {
1145: CURLcode result = CURLE_OK;
1146:
1147: (void)instate; /* no use for this yet */
1148:
1149: if(smtpcode != 250)
1150: result = CURLE_RECV_ERROR;
1151:
1152: /* End of DONE phase */
1153: state(conn, SMTP_STOP);
1154:
1155: return result;
1156: }
1157:
1158: static CURLcode smtp_statemach_act(struct connectdata *conn)
1159: {
1160: CURLcode result = CURLE_OK;
1161: curl_socket_t sock = conn->sock[FIRSTSOCKET];
1162: struct Curl_easy *data = conn->data;
1163: int smtpcode;
1164: struct smtp_conn *smtpc = &conn->proto.smtpc;
1165: struct pingpong *pp = &smtpc->pp;
1166: size_t nread = 0;
1167:
1168: /* Busy upgrading the connection; right now all I/O is SSL/TLS, not SMTP */
1169: if(smtpc->state == SMTP_UPGRADETLS)
1170: return smtp_perform_upgrade_tls(conn);
1171:
1172: /* Flush any data that needs to be sent */
1173: if(pp->sendleft)
1174: return Curl_pp_flushsend(pp);
1175:
1176: do {
1177: /* Read the response from the server */
1178: result = Curl_pp_readresp(sock, pp, &smtpcode, &nread);
1179: if(result)
1180: return result;
1181:
1182: /* Store the latest response for later retrieval if necessary */
1183: if(smtpc->state != SMTP_QUIT && smtpcode != 1)
1184: data->info.httpcode = smtpcode;
1185:
1186: if(!smtpcode)
1187: break;
1188:
1189: /* We have now received a full SMTP server response */
1190: switch(smtpc->state) {
1191: case SMTP_SERVERGREET:
1192: result = smtp_state_servergreet_resp(conn, smtpcode, smtpc->state);
1193: break;
1194:
1195: case SMTP_EHLO:
1196: result = smtp_state_ehlo_resp(conn, smtpcode, smtpc->state);
1197: break;
1198:
1199: case SMTP_HELO:
1200: result = smtp_state_helo_resp(conn, smtpcode, smtpc->state);
1201: break;
1202:
1203: case SMTP_STARTTLS:
1204: result = smtp_state_starttls_resp(conn, smtpcode, smtpc->state);
1205: break;
1206:
1207: case SMTP_AUTH:
1208: result = smtp_state_auth_resp(conn, smtpcode, smtpc->state);
1209: break;
1210:
1211: case SMTP_COMMAND:
1212: result = smtp_state_command_resp(conn, smtpcode, smtpc->state);
1213: break;
1214:
1215: case SMTP_MAIL:
1216: result = smtp_state_mail_resp(conn, smtpcode, smtpc->state);
1217: break;
1218:
1219: case SMTP_RCPT:
1220: result = smtp_state_rcpt_resp(conn, smtpcode, smtpc->state);
1221: break;
1222:
1223: case SMTP_DATA:
1224: result = smtp_state_data_resp(conn, smtpcode, smtpc->state);
1225: break;
1226:
1227: case SMTP_POSTDATA:
1228: result = smtp_state_postdata_resp(conn, smtpcode, smtpc->state);
1229: break;
1230:
1231: case SMTP_QUIT:
1232: /* fallthrough, just stop! */
1233: default:
1234: /* internal error */
1235: state(conn, SMTP_STOP);
1236: break;
1237: }
1238: } while(!result && smtpc->state != SMTP_STOP && Curl_pp_moredata(pp));
1239:
1240: return result;
1241: }
1242:
1243: /* Called repeatedly until done from multi.c */
1244: static CURLcode smtp_multi_statemach(struct connectdata *conn, bool *done)
1245: {
1246: CURLcode result = CURLE_OK;
1247: struct smtp_conn *smtpc = &conn->proto.smtpc;
1248:
1249: if((conn->handler->flags & PROTOPT_SSL) && !smtpc->ssldone) {
1250: result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &smtpc->ssldone);
1251: if(result || !smtpc->ssldone)
1252: return result;
1253: }
1254:
1255: result = Curl_pp_statemach(&smtpc->pp, FALSE, FALSE);
1256: *done = (smtpc->state == SMTP_STOP) ? TRUE : FALSE;
1257:
1258: return result;
1259: }
1260:
1261: static CURLcode smtp_block_statemach(struct connectdata *conn,
1262: bool disconnecting)
1263: {
1264: CURLcode result = CURLE_OK;
1265: struct smtp_conn *smtpc = &conn->proto.smtpc;
1266:
1267: while(smtpc->state != SMTP_STOP && !result)
1268: result = Curl_pp_statemach(&smtpc->pp, TRUE, disconnecting);
1269:
1270: return result;
1271: }
1272:
1273: /* Allocate and initialize the SMTP struct for the current Curl_easy if
1274: required */
1275: static CURLcode smtp_init(struct connectdata *conn)
1276: {
1277: CURLcode result = CURLE_OK;
1278: struct Curl_easy *data = conn->data;
1279: struct SMTP *smtp;
1280:
1281: smtp = data->req.protop = calloc(sizeof(struct SMTP), 1);
1282: if(!smtp)
1283: result = CURLE_OUT_OF_MEMORY;
1284:
1285: return result;
1286: }
1287:
1288: /* For the SMTP "protocol connect" and "doing" phases only */
1289: static int smtp_getsock(struct connectdata *conn, curl_socket_t *socks)
1290: {
1291: return Curl_pp_getsock(&conn->proto.smtpc.pp, socks);
1292: }
1293:
1294: /***********************************************************************
1295: *
1296: * smtp_connect()
1297: *
1298: * This function should do everything that is to be considered a part of
1299: * the connection phase.
1300: *
1301: * The variable pointed to by 'done' will be TRUE if the protocol-layer
1302: * connect phase is done when this function returns, or FALSE if not.
1303: */
1304: static CURLcode smtp_connect(struct connectdata *conn, bool *done)
1305: {
1306: CURLcode result = CURLE_OK;
1307: struct smtp_conn *smtpc = &conn->proto.smtpc;
1308: struct pingpong *pp = &smtpc->pp;
1309:
1310: *done = FALSE; /* default to not done yet */
1311:
1312: /* We always support persistent connections in SMTP */
1313: connkeep(conn, "SMTP default");
1314:
1315: /* Set the default response time-out */
1316: pp->response_time = RESP_TIMEOUT;
1317: pp->statemach_act = smtp_statemach_act;
1318: pp->endofresp = smtp_endofresp;
1319: pp->conn = conn;
1320:
1321: /* Initialize the SASL storage */
1322: Curl_sasl_init(&smtpc->sasl, &saslsmtp);
1323:
1324: /* Initialise the pingpong layer */
1325: Curl_pp_init(pp);
1326:
1327: /* Parse the URL options */
1328: result = smtp_parse_url_options(conn);
1329: if(result)
1330: return result;
1331:
1332: /* Parse the URL path */
1333: result = smtp_parse_url_path(conn);
1334: if(result)
1335: return result;
1336:
1337: /* Start off waiting for the server greeting response */
1338: state(conn, SMTP_SERVERGREET);
1339:
1340: result = smtp_multi_statemach(conn, done);
1341:
1342: return result;
1343: }
1344:
1345: /***********************************************************************
1346: *
1347: * smtp_done()
1348: *
1349: * The DONE function. This does what needs to be done after a single DO has
1350: * performed.
1351: *
1352: * Input argument is already checked for validity.
1353: */
1354: static CURLcode smtp_done(struct connectdata *conn, CURLcode status,
1355: bool premature)
1356: {
1357: CURLcode result = CURLE_OK;
1358: struct Curl_easy *data = conn->data;
1359: struct SMTP *smtp = data->req.protop;
1360: struct pingpong *pp = &conn->proto.smtpc.pp;
1361: char *eob;
1362: ssize_t len;
1363: ssize_t bytes_written;
1364:
1365: (void)premature;
1366:
1367: if(!smtp || !pp->conn)
1368: return CURLE_OK;
1369:
1370: /* Cleanup our per-request based variables */
1371: Curl_safefree(smtp->custom);
1372:
1373: if(status) {
1374: connclose(conn, "SMTP done with bad status"); /* marked for closure */
1375: result = status; /* use the already set error code */
1376: }
1377: else if(!data->set.connect_only && data->set.mail_rcpt &&
1378: (data->set.upload || data->set.mimepost.kind)) {
1379: /* Calculate the EOB taking into account any terminating CRLF from the
1380: previous line of the email or the CRLF of the DATA command when there
1381: is "no mail data". RFC-5321, sect. 4.1.1.4.
1382:
1383: Note: As some SSL backends, such as OpenSSL, will cause Curl_write() to
1384: fail when using a different pointer following a previous write, that
1385: returned CURLE_AGAIN, we duplicate the EOB now rather than when the
1386: bytes written doesn't equal len. */
1387: if(smtp->trailing_crlf || !conn->data->state.infilesize) {
1388: eob = strdup(&SMTP_EOB[2]);
1389: len = SMTP_EOB_LEN - 2;
1390: }
1391: else {
1392: eob = strdup(SMTP_EOB);
1393: len = SMTP_EOB_LEN;
1394: }
1395:
1396: if(!eob)
1397: return CURLE_OUT_OF_MEMORY;
1398:
1399: /* Send the end of block data */
1400: result = Curl_write(conn, conn->writesockfd, eob, len, &bytes_written);
1401: if(result) {
1402: free(eob);
1403: return result;
1404: }
1405:
1406: if(bytes_written != len) {
1407: /* The whole chunk was not sent so keep it around and adjust the
1408: pingpong structure accordingly */
1409: pp->sendthis = eob;
1410: pp->sendsize = len;
1411: pp->sendleft = len - bytes_written;
1412: }
1413: else {
1414: /* Successfully sent so adjust the response timeout relative to now */
1415: pp->response = Curl_now();
1416:
1417: free(eob);
1418: }
1419:
1420: state(conn, SMTP_POSTDATA);
1421:
1422: /* Run the state-machine */
1423: result = smtp_block_statemach(conn, FALSE);
1424: }
1425:
1426: /* Clear the transfer mode for the next request */
1427: smtp->transfer = FTPTRANSFER_BODY;
1428:
1429: return result;
1430: }
1431:
1432: /***********************************************************************
1433: *
1434: * smtp_perform()
1435: *
1436: * This is the actual DO function for SMTP. Transfer a mail, send a command
1437: * or get some data according to the options previously setup.
1438: */
1439: static CURLcode smtp_perform(struct connectdata *conn, bool *connected,
1440: bool *dophase_done)
1441: {
1442: /* This is SMTP and no proxy */
1443: CURLcode result = CURLE_OK;
1444: struct Curl_easy *data = conn->data;
1445: struct SMTP *smtp = data->req.protop;
1446:
1447: DEBUGF(infof(conn->data, "DO phase starts\n"));
1448:
1449: if(data->set.opt_no_body) {
1450: /* Requested no body means no transfer */
1451: smtp->transfer = FTPTRANSFER_INFO;
1452: }
1453:
1454: *dophase_done = FALSE; /* not done yet */
1455:
1456: /* Store the first recipient (or NULL if not specified) */
1457: smtp->rcpt = data->set.mail_rcpt;
1458:
1459: /* Track of whether we've successfully sent at least one RCPT TO command */
1460: smtp->rcpt_had_ok = FALSE;
1461:
1462: /* Track of the last error we've received by sending RCPT TO command */
1463: smtp->rcpt_last_error = 0;
1464:
1465: /* Initial data character is the first character in line: it is implicitly
1466: preceded by a virtual CRLF. */
1467: smtp->trailing_crlf = TRUE;
1468: smtp->eob = 2;
1469:
1470: /* Start the first command in the DO phase */
1471: if((data->set.upload || data->set.mimepost.kind) && data->set.mail_rcpt)
1472: /* MAIL transfer */
1473: result = smtp_perform_mail(conn);
1474: else
1475: /* SMTP based command (VRFY, EXPN, NOOP, RSET or HELP) */
1476: result = smtp_perform_command(conn);
1477:
1478: if(result)
1479: return result;
1480:
1481: /* Run the state-machine */
1482: result = smtp_multi_statemach(conn, dophase_done);
1483:
1484: *connected = conn->bits.tcpconnect[FIRSTSOCKET];
1485:
1486: if(*dophase_done)
1487: DEBUGF(infof(conn->data, "DO phase is complete\n"));
1488:
1489: return result;
1490: }
1491:
1492: /***********************************************************************
1493: *
1494: * smtp_do()
1495: *
1496: * This function is registered as 'curl_do' function. It decodes the path
1497: * parts etc as a wrapper to the actual DO function (smtp_perform).
1498: *
1499: * The input argument is already checked for validity.
1500: */
1501: static CURLcode smtp_do(struct connectdata *conn, bool *done)
1502: {
1503: CURLcode result = CURLE_OK;
1504:
1505: *done = FALSE; /* default to false */
1506:
1507: /* Parse the custom request */
1508: result = smtp_parse_custom_request(conn);
1509: if(result)
1510: return result;
1511:
1512: result = smtp_regular_transfer(conn, done);
1513:
1514: return result;
1515: }
1516:
1517: /***********************************************************************
1518: *
1519: * smtp_disconnect()
1520: *
1521: * Disconnect from an SMTP server. Cleanup protocol-specific per-connection
1522: * resources. BLOCKING.
1523: */
1524: static CURLcode smtp_disconnect(struct connectdata *conn, bool dead_connection)
1525: {
1526: struct smtp_conn *smtpc = &conn->proto.smtpc;
1527:
1528: /* We cannot send quit unconditionally. If this connection is stale or
1529: bad in any way, sending quit and waiting around here will make the
1530: disconnect wait in vain and cause more problems than we need to. */
1531:
1532: /* The SMTP session may or may not have been allocated/setup at this
1533: point! */
1534: if(!dead_connection && smtpc->pp.conn && smtpc->pp.conn->bits.protoconnstart)
1535: if(!smtp_perform_quit(conn))
1536: (void)smtp_block_statemach(conn, TRUE); /* ignore errors on QUIT */
1537:
1538: /* Disconnect from the server */
1539: Curl_pp_disconnect(&smtpc->pp);
1540:
1541: /* Cleanup the SASL module */
1542: Curl_sasl_cleanup(conn, smtpc->sasl.authused);
1543:
1544: /* Cleanup our connection based variables */
1545: Curl_safefree(smtpc->domain);
1546:
1547: return CURLE_OK;
1548: }
1549:
1550: /* Call this when the DO phase has completed */
1551: static CURLcode smtp_dophase_done(struct connectdata *conn, bool connected)
1552: {
1553: struct SMTP *smtp = conn->data->req.protop;
1554:
1555: (void)connected;
1556:
1557: if(smtp->transfer != FTPTRANSFER_BODY)
1558: /* no data to transfer */
1559: Curl_setup_transfer(conn->data, -1, -1, FALSE, -1);
1560:
1561: return CURLE_OK;
1562: }
1563:
1564: /* Called from multi.c while DOing */
1565: static CURLcode smtp_doing(struct connectdata *conn, bool *dophase_done)
1566: {
1567: CURLcode result = smtp_multi_statemach(conn, dophase_done);
1568:
1569: if(result)
1570: DEBUGF(infof(conn->data, "DO phase failed\n"));
1571: else if(*dophase_done) {
1572: result = smtp_dophase_done(conn, FALSE /* not connected */);
1573:
1574: DEBUGF(infof(conn->data, "DO phase is complete\n"));
1575: }
1576:
1577: return result;
1578: }
1579:
1580: /***********************************************************************
1581: *
1582: * smtp_regular_transfer()
1583: *
1584: * The input argument is already checked for validity.
1585: *
1586: * Performs all commands done before a regular transfer between a local and a
1587: * remote host.
1588: */
1589: static CURLcode smtp_regular_transfer(struct connectdata *conn,
1590: bool *dophase_done)
1591: {
1592: CURLcode result = CURLE_OK;
1593: bool connected = FALSE;
1594: struct Curl_easy *data = conn->data;
1595:
1596: /* Make sure size is unknown at this point */
1597: data->req.size = -1;
1598:
1599: /* Set the progress data */
1600: Curl_pgrsSetUploadCounter(data, 0);
1601: Curl_pgrsSetDownloadCounter(data, 0);
1602: Curl_pgrsSetUploadSize(data, -1);
1603: Curl_pgrsSetDownloadSize(data, -1);
1604:
1605: /* Carry out the perform */
1606: result = smtp_perform(conn, &connected, dophase_done);
1607:
1608: /* Perform post DO phase operations if necessary */
1609: if(!result && *dophase_done)
1610: result = smtp_dophase_done(conn, connected);
1611:
1612: return result;
1613: }
1614:
1615: static CURLcode smtp_setup_connection(struct connectdata *conn)
1616: {
1617: CURLcode result;
1618:
1619: /* Clear the TLS upgraded flag */
1620: conn->tls_upgraded = FALSE;
1621:
1622: /* Initialise the SMTP layer */
1623: result = smtp_init(conn);
1624: if(result)
1625: return result;
1626:
1627: return CURLE_OK;
1628: }
1629:
1630: /***********************************************************************
1631: *
1632: * smtp_parse_url_options()
1633: *
1634: * Parse the URL login options.
1635: */
1636: static CURLcode smtp_parse_url_options(struct connectdata *conn)
1637: {
1638: CURLcode result = CURLE_OK;
1639: struct smtp_conn *smtpc = &conn->proto.smtpc;
1640: const char *ptr = conn->options;
1641:
1642: smtpc->sasl.resetprefs = TRUE;
1643:
1644: while(!result && ptr && *ptr) {
1645: const char *key = ptr;
1646: const char *value;
1647:
1648: while(*ptr && *ptr != '=')
1649: ptr++;
1650:
1651: value = ptr + 1;
1652:
1653: while(*ptr && *ptr != ';')
1654: ptr++;
1655:
1656: if(strncasecompare(key, "AUTH=", 5))
1657: result = Curl_sasl_parse_url_auth_option(&smtpc->sasl,
1658: value, ptr - value);
1659: else
1660: result = CURLE_URL_MALFORMAT;
1661:
1662: if(*ptr == ';')
1663: ptr++;
1664: }
1665:
1666: return result;
1667: }
1668:
1669: /***********************************************************************
1670: *
1671: * smtp_parse_url_path()
1672: *
1673: * Parse the URL path into separate path components.
1674: */
1675: static CURLcode smtp_parse_url_path(struct connectdata *conn)
1676: {
1677: /* The SMTP struct is already initialised in smtp_connect() */
1678: struct Curl_easy *data = conn->data;
1679: struct smtp_conn *smtpc = &conn->proto.smtpc;
1680: const char *path = &data->state.up.path[1]; /* skip leading path */
1681: char localhost[HOSTNAME_MAX + 1];
1682:
1683: /* Calculate the path if necessary */
1684: if(!*path) {
1685: if(!Curl_gethostname(localhost, sizeof(localhost)))
1686: path = localhost;
1687: else
1688: path = "localhost";
1689: }
1690:
1691: /* URL decode the path and use it as the domain in our EHLO */
1692: return Curl_urldecode(conn->data, path, 0, &smtpc->domain, NULL, TRUE);
1693: }
1694:
1695: /***********************************************************************
1696: *
1697: * smtp_parse_custom_request()
1698: *
1699: * Parse the custom request.
1700: */
1701: static CURLcode smtp_parse_custom_request(struct connectdata *conn)
1702: {
1703: CURLcode result = CURLE_OK;
1704: struct Curl_easy *data = conn->data;
1705: struct SMTP *smtp = data->req.protop;
1706: const char *custom = data->set.str[STRING_CUSTOMREQUEST];
1707:
1708: /* URL decode the custom request */
1709: if(custom)
1710: result = Curl_urldecode(data, custom, 0, &smtp->custom, NULL, TRUE);
1711:
1712: return result;
1713: }
1714:
1715: /***********************************************************************
1716: *
1717: * smtp_parse_address()
1718: *
1719: * Parse the fully qualified mailbox address into a local address part and the
1720: * host name, converting the host name to an IDN A-label, as per RFC-5890, if
1721: * necessary.
1722: *
1723: * Parameters:
1724: *
1725: * conn [in] - The connection handle.
1726: * fqma [in] - The fully qualified mailbox address (which may or
1727: * may not contain UTF-8 characters).
1728: * address [in/out] - A new allocated buffer which holds the local
1729: * address part of the mailbox. This buffer must be
1730: * free'ed by the caller.
1731: * host [in/out] - The host name structure that holds the original,
1732: * and optionally encoded, host name.
1733: * Curl_free_idnconverted_hostname() must be called
1734: * once the caller has finished with the structure.
1735: *
1736: * Returns CURLE_OK on success.
1737: *
1738: * Notes:
1739: *
1740: * Should a UTF-8 host name require conversion to IDN ACE and we cannot honor
1741: * that conversion then we shall return success. This allow the caller to send
1742: * the data to the server as a U-label (as per RFC-6531 sect. 3.2).
1743: *
1744: * If an mailbox '@' separator cannot be located then the mailbox is considered
1745: * to be either a local mailbox or an invalid mailbox (depending on what the
1746: * calling function deems it to be) then the input will simply be returned in
1747: * the address part with the host name being NULL.
1748: */
1749: static CURLcode smtp_parse_address(struct connectdata *conn, const char *fqma,
1750: char **address, struct hostname *host)
1751: {
1752: CURLcode result = CURLE_OK;
1753: size_t length;
1754:
1755: /* Duplicate the fully qualified email address so we can manipulate it,
1756: ensuring it doesn't contain the delimiters if specified */
1757: char *dup = strdup(fqma[0] == '<' ? fqma + 1 : fqma);
1758: if(!dup)
1759: return CURLE_OUT_OF_MEMORY;
1760:
1761: length = strlen(dup);
1762: if(dup[length - 1] == '>')
1763: dup[length - 1] = '\0';
1764:
1765: /* Extract the host name from the address (if we can) */
1766: host->name = strpbrk(dup, "@");
1767: if(host->name) {
1768: *host->name = '\0';
1769: host->name = host->name + 1;
1770:
1771: /* Attempt to convert the host name to IDN ACE */
1772: (void) Curl_idnconvert_hostname(conn, host);
1773:
1774: /* If Curl_idnconvert_hostname() fails then we shall attempt to continue
1775: and send the host name using UTF-8 rather than as 7-bit ACE (which is
1776: our preference) */
1777: }
1778:
1779: /* Extract the local address from the mailbox */
1780: *address = dup;
1781:
1782: return result;
1783: }
1784:
1785: CURLcode Curl_smtp_escape_eob(struct connectdata *conn, const ssize_t nread)
1786: {
1787: /* When sending a SMTP payload we must detect CRLF. sequences making sure
1788: they are sent as CRLF.. instead, as a . on the beginning of a line will
1789: be deleted by the server when not part of an EOB terminator and a
1790: genuine CRLF.CRLF which isn't escaped will wrongly be detected as end of
1791: data by the server
1792: */
1793: ssize_t i;
1794: ssize_t si;
1795: struct Curl_easy *data = conn->data;
1796: struct SMTP *smtp = data->req.protop;
1797: char *scratch = data->state.scratch;
1798: char *newscratch = NULL;
1799: char *oldscratch = NULL;
1800: size_t eob_sent;
1801:
1802: /* Do we need to allocate a scratch buffer? */
1803: if(!scratch || data->set.crlf) {
1804: oldscratch = scratch;
1805:
1806: scratch = newscratch = malloc(2 * data->set.upload_buffer_size);
1807: if(!newscratch) {
1808: failf(data, "Failed to alloc scratch buffer!");
1809:
1810: return CURLE_OUT_OF_MEMORY;
1811: }
1812: }
1813: DEBUGASSERT(data->set.upload_buffer_size >= (size_t)nread);
1814:
1815: /* Have we already sent part of the EOB? */
1816: eob_sent = smtp->eob;
1817:
1818: /* This loop can be improved by some kind of Boyer-Moore style of
1819: approach but that is saved for later... */
1820: for(i = 0, si = 0; i < nread; i++) {
1821: if(SMTP_EOB[smtp->eob] == data->req.upload_fromhere[i]) {
1822: smtp->eob++;
1823:
1824: /* Is the EOB potentially the terminating CRLF? */
1825: if(2 == smtp->eob || SMTP_EOB_LEN == smtp->eob)
1826: smtp->trailing_crlf = TRUE;
1827: else
1828: smtp->trailing_crlf = FALSE;
1829: }
1830: else if(smtp->eob) {
1831: /* A previous substring matched so output that first */
1832: memcpy(&scratch[si], &SMTP_EOB[eob_sent], smtp->eob - eob_sent);
1833: si += smtp->eob - eob_sent;
1834:
1835: /* Then compare the first byte */
1836: if(SMTP_EOB[0] == data->req.upload_fromhere[i])
1837: smtp->eob = 1;
1838: else
1839: smtp->eob = 0;
1840:
1841: eob_sent = 0;
1842:
1843: /* Reset the trailing CRLF flag as there was more data */
1844: smtp->trailing_crlf = FALSE;
1845: }
1846:
1847: /* Do we have a match for CRLF. as per RFC-5321, sect. 4.5.2 */
1848: if(SMTP_EOB_FIND_LEN == smtp->eob) {
1849: /* Copy the replacement data to the target buffer */
1850: memcpy(&scratch[si], &SMTP_EOB_REPL[eob_sent],
1851: SMTP_EOB_REPL_LEN - eob_sent);
1852: si += SMTP_EOB_REPL_LEN - eob_sent;
1853: smtp->eob = 0;
1854: eob_sent = 0;
1855: }
1856: else if(!smtp->eob)
1857: scratch[si++] = data->req.upload_fromhere[i];
1858: }
1859:
1860: if(smtp->eob - eob_sent) {
1861: /* A substring matched before processing ended so output that now */
1862: memcpy(&scratch[si], &SMTP_EOB[eob_sent], smtp->eob - eob_sent);
1863: si += smtp->eob - eob_sent;
1864: }
1865:
1866: /* Only use the new buffer if we replaced something */
1867: if(si != nread) {
1868: /* Upload from the new (replaced) buffer instead */
1869: data->req.upload_fromhere = scratch;
1870:
1871: /* Save the buffer so it can be freed later */
1872: data->state.scratch = scratch;
1873:
1874: /* Free the old scratch buffer */
1875: free(oldscratch);
1876:
1877: /* Set the new amount too */
1878: data->req.upload_present = si;
1879: }
1880: else
1881: free(newscratch);
1882:
1883: return CURLE_OK;
1884: }
1885:
1886: #endif /* CURL_DISABLE_SMTP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to smtp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib