Annotation of embedaddon/curl/lib/imap.c, revision 1.1.1.1
1.1 misho 1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2019, 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: * RFC2195 CRAM-MD5 authentication
22: * RFC2595 Using TLS with IMAP, POP3 and ACAP
23: * RFC2831 DIGEST-MD5 authentication
24: * RFC3501 IMAPv4 protocol
25: * RFC4422 Simple Authentication and Security Layer (SASL)
26: * RFC4616 PLAIN authentication
27: * RFC4752 The Kerberos V5 ("GSSAPI") SASL Mechanism
28: * RFC4959 IMAP Extension for SASL Initial Client Response
29: * RFC5092 IMAP URL Scheme
30: * RFC6749 OAuth 2.0 Authorization Framework
31: * RFC8314 Use of TLS for Email Submission and Access
32: * Draft LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
33: *
34: ***************************************************************************/
35:
36: #include "curl_setup.h"
37:
38: #ifndef CURL_DISABLE_IMAP
39:
40: #ifdef HAVE_NETINET_IN_H
41: #include <netinet/in.h>
42: #endif
43: #ifdef HAVE_ARPA_INET_H
44: #include <arpa/inet.h>
45: #endif
46: #ifdef HAVE_UTSNAME_H
47: #include <sys/utsname.h>
48: #endif
49: #ifdef HAVE_NETDB_H
50: #include <netdb.h>
51: #endif
52: #ifdef __VMS
53: #include <in.h>
54: #include <inet.h>
55: #endif
56:
57: #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
58: #undef in_addr_t
59: #define in_addr_t unsigned long
60: #endif
61:
62: #include <curl/curl.h>
63: #include "urldata.h"
64: #include "sendf.h"
65: #include "hostip.h"
66: #include "progress.h"
67: #include "transfer.h"
68: #include "escape.h"
69: #include "http.h" /* for HTTP proxy tunnel stuff */
70: #include "socks.h"
71: #include "imap.h"
72: #include "mime.h"
73: #include "strtoofft.h"
74: #include "strcase.h"
75: #include "vtls/vtls.h"
76: #include "connect.h"
77: #include "strerror.h"
78: #include "select.h"
79: #include "multiif.h"
80: #include "url.h"
81: #include "strcase.h"
82: #include "curl_sasl.h"
83: #include "warnless.h"
84:
85: /* The last 3 #include files should be in this order */
86: #include "curl_printf.h"
87: #include "curl_memory.h"
88: #include "memdebug.h"
89:
90: /* Local API functions */
91: static CURLcode imap_regular_transfer(struct connectdata *conn, bool *done);
92: static CURLcode imap_do(struct connectdata *conn, bool *done);
93: static CURLcode imap_done(struct connectdata *conn, CURLcode status,
94: bool premature);
95: static CURLcode imap_connect(struct connectdata *conn, bool *done);
96: static CURLcode imap_disconnect(struct connectdata *conn, bool dead);
97: static CURLcode imap_multi_statemach(struct connectdata *conn, bool *done);
98: static int imap_getsock(struct connectdata *conn, curl_socket_t *socks);
99: static CURLcode imap_doing(struct connectdata *conn, bool *dophase_done);
100: static CURLcode imap_setup_connection(struct connectdata *conn);
101: static char *imap_atom(const char *str, bool escape_only);
102: static CURLcode imap_sendf(struct connectdata *conn, const char *fmt, ...);
103: static CURLcode imap_parse_url_options(struct connectdata *conn);
104: static CURLcode imap_parse_url_path(struct connectdata *conn);
105: static CURLcode imap_parse_custom_request(struct connectdata *conn);
106: static CURLcode imap_perform_authenticate(struct connectdata *conn,
107: const char *mech,
108: const char *initresp);
109: static CURLcode imap_continue_authenticate(struct connectdata *conn,
110: const char *resp);
111: static void imap_get_message(char *buffer, char **outptr);
112:
113: /*
114: * IMAP protocol handler.
115: */
116:
117: const struct Curl_handler Curl_handler_imap = {
118: "IMAP", /* scheme */
119: imap_setup_connection, /* setup_connection */
120: imap_do, /* do_it */
121: imap_done, /* done */
122: ZERO_NULL, /* do_more */
123: imap_connect, /* connect_it */
124: imap_multi_statemach, /* connecting */
125: imap_doing, /* doing */
126: imap_getsock, /* proto_getsock */
127: imap_getsock, /* doing_getsock */
128: ZERO_NULL, /* domore_getsock */
129: ZERO_NULL, /* perform_getsock */
130: imap_disconnect, /* disconnect */
131: ZERO_NULL, /* readwrite */
132: ZERO_NULL, /* connection_check */
133: PORT_IMAP, /* defport */
134: CURLPROTO_IMAP, /* protocol */
135: PROTOPT_CLOSEACTION| /* flags */
136: PROTOPT_URLOPTIONS
137: };
138:
139: #ifdef USE_SSL
140: /*
141: * IMAPS protocol handler.
142: */
143:
144: const struct Curl_handler Curl_handler_imaps = {
145: "IMAPS", /* scheme */
146: imap_setup_connection, /* setup_connection */
147: imap_do, /* do_it */
148: imap_done, /* done */
149: ZERO_NULL, /* do_more */
150: imap_connect, /* connect_it */
151: imap_multi_statemach, /* connecting */
152: imap_doing, /* doing */
153: imap_getsock, /* proto_getsock */
154: imap_getsock, /* doing_getsock */
155: ZERO_NULL, /* domore_getsock */
156: ZERO_NULL, /* perform_getsock */
157: imap_disconnect, /* disconnect */
158: ZERO_NULL, /* readwrite */
159: ZERO_NULL, /* connection_check */
160: PORT_IMAPS, /* defport */
161: CURLPROTO_IMAPS, /* protocol */
162: PROTOPT_CLOSEACTION | PROTOPT_SSL | /* flags */
163: PROTOPT_URLOPTIONS
164: };
165: #endif
166:
167: #define IMAP_RESP_OK 1
168: #define IMAP_RESP_NOT_OK 2
169: #define IMAP_RESP_PREAUTH 3
170:
171: /* SASL parameters for the imap protocol */
172: static const struct SASLproto saslimap = {
173: "imap", /* The service name */
174: '+', /* Code received when continuation is expected */
175: IMAP_RESP_OK, /* Code to receive upon authentication success */
176: 0, /* Maximum initial response length (no max) */
177: imap_perform_authenticate, /* Send authentication command */
178: imap_continue_authenticate, /* Send authentication continuation */
179: imap_get_message /* Get SASL response message */
180: };
181:
182:
183: #ifdef USE_SSL
184: static void imap_to_imaps(struct connectdata *conn)
185: {
186: /* Change the connection handler */
187: conn->handler = &Curl_handler_imaps;
188:
189: /* Set the connection's upgraded to TLS flag */
190: conn->tls_upgraded = TRUE;
191: }
192: #else
193: #define imap_to_imaps(x) Curl_nop_stmt
194: #endif
195:
196: /***********************************************************************
197: *
198: * imap_matchresp()
199: *
200: * Determines whether the untagged response is related to the specified
201: * command by checking if it is in format "* <command-name> ..." or
202: * "* <number> <command-name> ...".
203: *
204: * The "* " marker is assumed to have already been checked by the caller.
205: */
206: static bool imap_matchresp(const char *line, size_t len, const char *cmd)
207: {
208: const char *end = line + len;
209: size_t cmd_len = strlen(cmd);
210:
211: /* Skip the untagged response marker */
212: line += 2;
213:
214: /* Do we have a number after the marker? */
215: if(line < end && ISDIGIT(*line)) {
216: /* Skip the number */
217: do
218: line++;
219: while(line < end && ISDIGIT(*line));
220:
221: /* Do we have the space character? */
222: if(line == end || *line != ' ')
223: return FALSE;
224:
225: line++;
226: }
227:
228: /* Does the command name match and is it followed by a space character or at
229: the end of line? */
230: if(line + cmd_len <= end && strncasecompare(line, cmd, cmd_len) &&
231: (line[cmd_len] == ' ' || line + cmd_len + 2 == end))
232: return TRUE;
233:
234: return FALSE;
235: }
236:
237: /***********************************************************************
238: *
239: * imap_endofresp()
240: *
241: * Checks whether the given string is a valid tagged, untagged or continuation
242: * response which can be processed by the response handler.
243: */
244: static bool imap_endofresp(struct connectdata *conn, char *line, size_t len,
245: int *resp)
246: {
247: struct IMAP *imap = conn->data->req.protop;
248: struct imap_conn *imapc = &conn->proto.imapc;
249: const char *id = imapc->resptag;
250: size_t id_len = strlen(id);
251:
252: /* Do we have a tagged command response? */
253: if(len >= id_len + 1 && !memcmp(id, line, id_len) && line[id_len] == ' ') {
254: line += id_len + 1;
255: len -= id_len + 1;
256:
257: if(len >= 2 && !memcmp(line, "OK", 2))
258: *resp = IMAP_RESP_OK;
259: else if(len >= 7 && !memcmp(line, "PREAUTH", 7))
260: *resp = IMAP_RESP_PREAUTH;
261: else
262: *resp = IMAP_RESP_NOT_OK;
263:
264: return TRUE;
265: }
266:
267: /* Do we have an untagged command response? */
268: if(len >= 2 && !memcmp("* ", line, 2)) {
269: switch(imapc->state) {
270: /* States which are interested in untagged responses */
271: case IMAP_CAPABILITY:
272: if(!imap_matchresp(line, len, "CAPABILITY"))
273: return FALSE;
274: break;
275:
276: case IMAP_LIST:
277: if((!imap->custom && !imap_matchresp(line, len, "LIST")) ||
278: (imap->custom && !imap_matchresp(line, len, imap->custom) &&
279: (!strcasecompare(imap->custom, "STORE") ||
280: !imap_matchresp(line, len, "FETCH")) &&
281: !strcasecompare(imap->custom, "SELECT") &&
282: !strcasecompare(imap->custom, "EXAMINE") &&
283: !strcasecompare(imap->custom, "SEARCH") &&
284: !strcasecompare(imap->custom, "EXPUNGE") &&
285: !strcasecompare(imap->custom, "LSUB") &&
286: !strcasecompare(imap->custom, "UID") &&
287: !strcasecompare(imap->custom, "NOOP")))
288: return FALSE;
289: break;
290:
291: case IMAP_SELECT:
292: /* SELECT is special in that its untagged responses do not have a
293: common prefix so accept anything! */
294: break;
295:
296: case IMAP_FETCH:
297: if(!imap_matchresp(line, len, "FETCH"))
298: return FALSE;
299: break;
300:
301: case IMAP_SEARCH:
302: if(!imap_matchresp(line, len, "SEARCH"))
303: return FALSE;
304: break;
305:
306: /* Ignore other untagged responses */
307: default:
308: return FALSE;
309: }
310:
311: *resp = '*';
312: return TRUE;
313: }
314:
315: /* Do we have a continuation response? This should be a + symbol followed by
316: a space and optionally some text as per RFC-3501 for the AUTHENTICATE and
317: APPEND commands and as outlined in Section 4. Examples of RFC-4959 but
318: some e-mail servers ignore this and only send a single + instead. */
319: if(imap && !imap->custom && ((len == 3 && line[0] == '+') ||
320: (len >= 2 && !memcmp("+ ", line, 2)))) {
321: switch(imapc->state) {
322: /* States which are interested in continuation responses */
323: case IMAP_AUTHENTICATE:
324: case IMAP_APPEND:
325: *resp = '+';
326: break;
327:
328: default:
329: failf(conn->data, "Unexpected continuation response");
330: *resp = -1;
331: break;
332: }
333:
334: return TRUE;
335: }
336:
337: return FALSE; /* Nothing for us */
338: }
339:
340: /***********************************************************************
341: *
342: * imap_get_message()
343: *
344: * Gets the authentication message from the response buffer.
345: */
346: static void imap_get_message(char *buffer, char **outptr)
347: {
348: size_t len = strlen(buffer);
349: char *message = NULL;
350:
351: if(len > 2) {
352: /* Find the start of the message */
353: len -= 2;
354: for(message = buffer + 2; *message == ' ' || *message == '\t';
355: message++, len--)
356: ;
357:
358: /* Find the end of the message */
359: for(; len--;)
360: if(message[len] != '\r' && message[len] != '\n' && message[len] != ' ' &&
361: message[len] != '\t')
362: break;
363:
364: /* Terminate the message */
365: if(++len) {
366: message[len] = '\0';
367: }
368: }
369: else
370: /* junk input => zero length output */
371: message = &buffer[len];
372:
373: *outptr = message;
374: }
375:
376: /***********************************************************************
377: *
378: * state()
379: *
380: * This is the ONLY way to change IMAP state!
381: */
382: static void state(struct connectdata *conn, imapstate newstate)
383: {
384: struct imap_conn *imapc = &conn->proto.imapc;
385: #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
386: /* for debug purposes */
387: static const char * const names[]={
388: "STOP",
389: "SERVERGREET",
390: "CAPABILITY",
391: "STARTTLS",
392: "UPGRADETLS",
393: "AUTHENTICATE",
394: "LOGIN",
395: "LIST",
396: "SELECT",
397: "FETCH",
398: "FETCH_FINAL",
399: "APPEND",
400: "APPEND_FINAL",
401: "SEARCH",
402: "LOGOUT",
403: /* LAST */
404: };
405:
406: if(imapc->state != newstate)
407: infof(conn->data, "IMAP %p state change from %s to %s\n",
408: (void *)imapc, names[imapc->state], names[newstate]);
409: #endif
410:
411: imapc->state = newstate;
412: }
413:
414: /***********************************************************************
415: *
416: * imap_perform_capability()
417: *
418: * Sends the CAPABILITY command in order to obtain a list of server side
419: * supported capabilities.
420: */
421: static CURLcode imap_perform_capability(struct connectdata *conn)
422: {
423: CURLcode result = CURLE_OK;
424: struct imap_conn *imapc = &conn->proto.imapc;
425: imapc->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanisms yet */
426: imapc->sasl.authused = SASL_AUTH_NONE; /* Clear the auth. mechanism used */
427: imapc->tls_supported = FALSE; /* Clear the TLS capability */
428:
429: /* Send the CAPABILITY command */
430: result = imap_sendf(conn, "CAPABILITY");
431:
432: if(!result)
433: state(conn, IMAP_CAPABILITY);
434:
435: return result;
436: }
437:
438: /***********************************************************************
439: *
440: * imap_perform_starttls()
441: *
442: * Sends the STARTTLS command to start the upgrade to TLS.
443: */
444: static CURLcode imap_perform_starttls(struct connectdata *conn)
445: {
446: /* Send the STARTTLS command */
447: CURLcode result = imap_sendf(conn, "STARTTLS");
448:
449: if(!result)
450: state(conn, IMAP_STARTTLS);
451:
452: return result;
453: }
454:
455: /***********************************************************************
456: *
457: * imap_perform_upgrade_tls()
458: *
459: * Performs the upgrade to TLS.
460: */
461: static CURLcode imap_perform_upgrade_tls(struct connectdata *conn)
462: {
463: /* Start the SSL connection */
464: struct imap_conn *imapc = &conn->proto.imapc;
465: CURLcode result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET,
466: &imapc->ssldone);
467:
468: if(!result) {
469: if(imapc->state != IMAP_UPGRADETLS)
470: state(conn, IMAP_UPGRADETLS);
471:
472: if(imapc->ssldone) {
473: imap_to_imaps(conn);
474: result = imap_perform_capability(conn);
475: }
476: }
477:
478: return result;
479: }
480:
481: /***********************************************************************
482: *
483: * imap_perform_login()
484: *
485: * Sends a clear text LOGIN command to authenticate with.
486: */
487: static CURLcode imap_perform_login(struct connectdata *conn)
488: {
489: CURLcode result = CURLE_OK;
490: char *user;
491: char *passwd;
492:
493: /* Check we have a username and password to authenticate with and end the
494: connect phase if we don't */
495: if(!conn->bits.user_passwd) {
496: state(conn, IMAP_STOP);
497:
498: return result;
499: }
500:
501: /* Make sure the username and password are in the correct atom format */
502: user = imap_atom(conn->user, false);
503: passwd = imap_atom(conn->passwd, false);
504:
505: /* Send the LOGIN command */
506: result = imap_sendf(conn, "LOGIN %s %s", user ? user : "",
507: passwd ? passwd : "");
508:
509: free(user);
510: free(passwd);
511:
512: if(!result)
513: state(conn, IMAP_LOGIN);
514:
515: return result;
516: }
517:
518: /***********************************************************************
519: *
520: * imap_perform_authenticate()
521: *
522: * Sends an AUTHENTICATE command allowing the client to login with the given
523: * SASL authentication mechanism.
524: */
525: static CURLcode imap_perform_authenticate(struct connectdata *conn,
526: const char *mech,
527: const char *initresp)
528: {
529: CURLcode result = CURLE_OK;
530:
531: if(initresp) {
532: /* Send the AUTHENTICATE command with the initial response */
533: result = imap_sendf(conn, "AUTHENTICATE %s %s", mech, initresp);
534: }
535: else {
536: /* Send the AUTHENTICATE command */
537: result = imap_sendf(conn, "AUTHENTICATE %s", mech);
538: }
539:
540: return result;
541: }
542:
543: /***********************************************************************
544: *
545: * imap_continue_authenticate()
546: *
547: * Sends SASL continuation data or cancellation.
548: */
549: static CURLcode imap_continue_authenticate(struct connectdata *conn,
550: const char *resp)
551: {
552: struct imap_conn *imapc = &conn->proto.imapc;
553:
554: return Curl_pp_sendf(&imapc->pp, "%s", resp);
555: }
556:
557: /***********************************************************************
558: *
559: * imap_perform_authentication()
560: *
561: * Initiates the authentication sequence, with the appropriate SASL
562: * authentication mechanism, falling back to clear text should a common
563: * mechanism not be available between the client and server.
564: */
565: static CURLcode imap_perform_authentication(struct connectdata *conn)
566: {
567: CURLcode result = CURLE_OK;
568: struct imap_conn *imapc = &conn->proto.imapc;
569: saslprogress progress;
570:
571: /* Check if already authenticated OR if there is enough data to authenticate
572: with and end the connect phase if we don't */
573: if(imapc->preauth ||
574: !Curl_sasl_can_authenticate(&imapc->sasl, conn)) {
575: state(conn, IMAP_STOP);
576: return result;
577: }
578:
579: /* Calculate the SASL login details */
580: result = Curl_sasl_start(&imapc->sasl, conn, imapc->ir_supported, &progress);
581:
582: if(!result) {
583: if(progress == SASL_INPROGRESS)
584: state(conn, IMAP_AUTHENTICATE);
585: else if(!imapc->login_disabled && (imapc->preftype & IMAP_TYPE_CLEARTEXT))
586: /* Perform clear text authentication */
587: result = imap_perform_login(conn);
588: else {
589: /* Other mechanisms not supported */
590: infof(conn->data, "No known authentication mechanisms supported!\n");
591: result = CURLE_LOGIN_DENIED;
592: }
593: }
594:
595: return result;
596: }
597:
598: /***********************************************************************
599: *
600: * imap_perform_list()
601: *
602: * Sends a LIST command or an alternative custom request.
603: */
604: static CURLcode imap_perform_list(struct connectdata *conn)
605: {
606: CURLcode result = CURLE_OK;
607: struct Curl_easy *data = conn->data;
608: struct IMAP *imap = data->req.protop;
609:
610: if(imap->custom)
611: /* Send the custom request */
612: result = imap_sendf(conn, "%s%s", imap->custom,
613: imap->custom_params ? imap->custom_params : "");
614: else {
615: /* Make sure the mailbox is in the correct atom format if necessary */
616: char *mailbox = imap->mailbox ? imap_atom(imap->mailbox, true)
617: : strdup("");
618: if(!mailbox)
619: return CURLE_OUT_OF_MEMORY;
620:
621: /* Send the LIST command */
622: result = imap_sendf(conn, "LIST \"%s\" *", mailbox);
623:
624: free(mailbox);
625: }
626:
627: if(!result)
628: state(conn, IMAP_LIST);
629:
630: return result;
631: }
632:
633: /***********************************************************************
634: *
635: * imap_perform_select()
636: *
637: * Sends a SELECT command to ask the server to change the selected mailbox.
638: */
639: static CURLcode imap_perform_select(struct connectdata *conn)
640: {
641: CURLcode result = CURLE_OK;
642: struct Curl_easy *data = conn->data;
643: struct IMAP *imap = data->req.protop;
644: struct imap_conn *imapc = &conn->proto.imapc;
645: char *mailbox;
646:
647: /* Invalidate old information as we are switching mailboxes */
648: Curl_safefree(imapc->mailbox);
649: Curl_safefree(imapc->mailbox_uidvalidity);
650:
651: /* Check we have a mailbox */
652: if(!imap->mailbox) {
653: failf(conn->data, "Cannot SELECT without a mailbox.");
654: return CURLE_URL_MALFORMAT;
655: }
656:
657: /* Make sure the mailbox is in the correct atom format */
658: mailbox = imap_atom(imap->mailbox, false);
659: if(!mailbox)
660: return CURLE_OUT_OF_MEMORY;
661:
662: /* Send the SELECT command */
663: result = imap_sendf(conn, "SELECT %s", mailbox);
664:
665: free(mailbox);
666:
667: if(!result)
668: state(conn, IMAP_SELECT);
669:
670: return result;
671: }
672:
673: /***********************************************************************
674: *
675: * imap_perform_fetch()
676: *
677: * Sends a FETCH command to initiate the download of a message.
678: */
679: static CURLcode imap_perform_fetch(struct connectdata *conn)
680: {
681: CURLcode result = CURLE_OK;
682: struct IMAP *imap = conn->data->req.protop;
683: /* Check we have a UID */
684: if(imap->uid) {
685:
686: /* Send the FETCH command */
687: if(imap->partial)
688: result = imap_sendf(conn, "UID FETCH %s BODY[%s]<%s>",
689: imap->uid,
690: imap->section ? imap->section : "",
691: imap->partial);
692: else
693: result = imap_sendf(conn, "UID FETCH %s BODY[%s]",
694: imap->uid,
695: imap->section ? imap->section : "");
696: }
697: else if(imap->mindex) {
698:
699: /* Send the FETCH command */
700: if(imap->partial)
701: result = imap_sendf(conn, "FETCH %s BODY[%s]<%s>",
702: imap->mindex,
703: imap->section ? imap->section : "",
704: imap->partial);
705: else
706: result = imap_sendf(conn, "FETCH %s BODY[%s]",
707: imap->mindex,
708: imap->section ? imap->section : "");
709: }
710: else {
711: failf(conn->data, "Cannot FETCH without a UID.");
712: return CURLE_URL_MALFORMAT;
713: }
714: if(!result)
715: state(conn, IMAP_FETCH);
716:
717: return result;
718: }
719:
720: /***********************************************************************
721: *
722: * imap_perform_append()
723: *
724: * Sends an APPEND command to initiate the upload of a message.
725: */
726: static CURLcode imap_perform_append(struct connectdata *conn)
727: {
728: CURLcode result = CURLE_OK;
729: struct Curl_easy *data = conn->data;
730: struct IMAP *imap = data->req.protop;
731: char *mailbox;
732:
733: /* Check we have a mailbox */
734: if(!imap->mailbox) {
735: failf(data, "Cannot APPEND without a mailbox.");
736: return CURLE_URL_MALFORMAT;
737: }
738:
739: /* Prepare the mime data if some. */
740: if(data->set.mimepost.kind != MIMEKIND_NONE) {
741: /* Use the whole structure as data. */
742: data->set.mimepost.flags &= ~MIME_BODY_ONLY;
743:
744: /* Add external headers and mime version. */
745: curl_mime_headers(&data->set.mimepost, data->set.headers, 0);
746: result = Curl_mime_prepare_headers(&data->set.mimepost, NULL,
747: NULL, MIMESTRATEGY_MAIL);
748:
749: if(!result)
750: if(!Curl_checkheaders(conn, "Mime-Version"))
751: result = Curl_mime_add_header(&data->set.mimepost.curlheaders,
752: "Mime-Version: 1.0");
753:
754: /* Make sure we will read the entire mime structure. */
755: if(!result)
756: result = Curl_mime_rewind(&data->set.mimepost);
757:
758: if(result)
759: return result;
760:
761: data->state.infilesize = Curl_mime_size(&data->set.mimepost);
762:
763: /* Read from mime structure. */
764: data->state.fread_func = (curl_read_callback) Curl_mime_read;
765: data->state.in = (void *) &data->set.mimepost;
766: }
767:
768: /* Check we know the size of the upload */
769: if(data->state.infilesize < 0) {
770: failf(data, "Cannot APPEND with unknown input file size\n");
771: return CURLE_UPLOAD_FAILED;
772: }
773:
774: /* Make sure the mailbox is in the correct atom format */
775: mailbox = imap_atom(imap->mailbox, false);
776: if(!mailbox)
777: return CURLE_OUT_OF_MEMORY;
778:
779: /* Send the APPEND command */
780: result = imap_sendf(conn, "APPEND %s (\\Seen) {%" CURL_FORMAT_CURL_OFF_T "}",
781: mailbox, data->state.infilesize);
782:
783: free(mailbox);
784:
785: if(!result)
786: state(conn, IMAP_APPEND);
787:
788: return result;
789: }
790:
791: /***********************************************************************
792: *
793: * imap_perform_search()
794: *
795: * Sends a SEARCH command.
796: */
797: static CURLcode imap_perform_search(struct connectdata *conn)
798: {
799: CURLcode result = CURLE_OK;
800: struct IMAP *imap = conn->data->req.protop;
801:
802: /* Check we have a query string */
803: if(!imap->query) {
804: failf(conn->data, "Cannot SEARCH without a query string.");
805: return CURLE_URL_MALFORMAT;
806: }
807:
808: /* Send the SEARCH command */
809: result = imap_sendf(conn, "SEARCH %s", imap->query);
810:
811: if(!result)
812: state(conn, IMAP_SEARCH);
813:
814: return result;
815: }
816:
817: /***********************************************************************
818: *
819: * imap_perform_logout()
820: *
821: * Performs the logout action prior to sclose() being called.
822: */
823: static CURLcode imap_perform_logout(struct connectdata *conn)
824: {
825: /* Send the LOGOUT command */
826: CURLcode result = imap_sendf(conn, "LOGOUT");
827:
828: if(!result)
829: state(conn, IMAP_LOGOUT);
830:
831: return result;
832: }
833:
834: /* For the initial server greeting */
835: static CURLcode imap_state_servergreet_resp(struct connectdata *conn,
836: int imapcode,
837: imapstate instate)
838: {
839: struct Curl_easy *data = conn->data;
840: (void)instate; /* no use for this yet */
841:
842: if(imapcode == IMAP_RESP_PREAUTH) {
843: /* PREAUTH */
844: struct imap_conn *imapc = &conn->proto.imapc;
845: imapc->preauth = TRUE;
846: infof(data, "PREAUTH connection, already authenticated!\n");
847: }
848: else if(imapcode != IMAP_RESP_OK) {
849: failf(data, "Got unexpected imap-server response");
850: return CURLE_WEIRD_SERVER_REPLY;
851: }
852:
853: return imap_perform_capability(conn);
854: }
855:
856: /* For CAPABILITY responses */
857: static CURLcode imap_state_capability_resp(struct connectdata *conn,
858: int imapcode,
859: imapstate instate)
860: {
861: CURLcode result = CURLE_OK;
862: struct Curl_easy *data = conn->data;
863: struct imap_conn *imapc = &conn->proto.imapc;
864: const char *line = data->state.buffer;
865:
866: (void)instate; /* no use for this yet */
867:
868: /* Do we have a untagged response? */
869: if(imapcode == '*') {
870: line += 2;
871:
872: /* Loop through the data line */
873: for(;;) {
874: size_t wordlen;
875: while(*line &&
876: (*line == ' ' || *line == '\t' ||
877: *line == '\r' || *line == '\n')) {
878:
879: line++;
880: }
881:
882: if(!*line)
883: break;
884:
885: /* Extract the word */
886: for(wordlen = 0; line[wordlen] && line[wordlen] != ' ' &&
887: line[wordlen] != '\t' && line[wordlen] != '\r' &&
888: line[wordlen] != '\n';)
889: wordlen++;
890:
891: /* Does the server support the STARTTLS capability? */
892: if(wordlen == 8 && !memcmp(line, "STARTTLS", 8))
893: imapc->tls_supported = TRUE;
894:
895: /* Has the server explicitly disabled clear text authentication? */
896: else if(wordlen == 13 && !memcmp(line, "LOGINDISABLED", 13))
897: imapc->login_disabled = TRUE;
898:
899: /* Does the server support the SASL-IR capability? */
900: else if(wordlen == 7 && !memcmp(line, "SASL-IR", 7))
901: imapc->ir_supported = TRUE;
902:
903: /* Do we have a SASL based authentication mechanism? */
904: else if(wordlen > 5 && !memcmp(line, "AUTH=", 5)) {
905: size_t llen;
906: unsigned int mechbit;
907:
908: line += 5;
909: wordlen -= 5;
910:
911: /* Test the word for a matching authentication mechanism */
912: mechbit = Curl_sasl_decode_mech(line, wordlen, &llen);
913: if(mechbit && llen == wordlen)
914: imapc->sasl.authmechs |= mechbit;
915: }
916:
917: line += wordlen;
918: }
919: }
920: else if(imapcode == IMAP_RESP_OK) {
921: if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
922: /* We don't have a SSL/TLS connection yet, but SSL is requested */
923: if(imapc->tls_supported)
924: /* Switch to TLS connection now */
925: result = imap_perform_starttls(conn);
926: else if(data->set.use_ssl == CURLUSESSL_TRY)
927: /* Fallback and carry on with authentication */
928: result = imap_perform_authentication(conn);
929: else {
930: failf(data, "STARTTLS not supported.");
931: result = CURLE_USE_SSL_FAILED;
932: }
933: }
934: else
935: result = imap_perform_authentication(conn);
936: }
937: else
938: result = imap_perform_authentication(conn);
939:
940: return result;
941: }
942:
943: /* For STARTTLS responses */
944: static CURLcode imap_state_starttls_resp(struct connectdata *conn,
945: int imapcode,
946: imapstate instate)
947: {
948: CURLcode result = CURLE_OK;
949: struct Curl_easy *data = conn->data;
950:
951: (void)instate; /* no use for this yet */
952:
953: if(imapcode != IMAP_RESP_OK) {
954: if(data->set.use_ssl != CURLUSESSL_TRY) {
955: failf(data, "STARTTLS denied");
956: result = CURLE_USE_SSL_FAILED;
957: }
958: else
959: result = imap_perform_authentication(conn);
960: }
961: else
962: result = imap_perform_upgrade_tls(conn);
963:
964: return result;
965: }
966:
967: /* For SASL authentication responses */
968: static CURLcode imap_state_auth_resp(struct connectdata *conn,
969: int imapcode,
970: imapstate instate)
971: {
972: CURLcode result = CURLE_OK;
973: struct Curl_easy *data = conn->data;
974: struct imap_conn *imapc = &conn->proto.imapc;
975: saslprogress progress;
976:
977: (void)instate; /* no use for this yet */
978:
979: result = Curl_sasl_continue(&imapc->sasl, conn, imapcode, &progress);
980: if(!result)
981: switch(progress) {
982: case SASL_DONE:
983: state(conn, IMAP_STOP); /* Authenticated */
984: break;
985: case SASL_IDLE: /* No mechanism left after cancellation */
986: if((!imapc->login_disabled) && (imapc->preftype & IMAP_TYPE_CLEARTEXT))
987: /* Perform clear text authentication */
988: result = imap_perform_login(conn);
989: else {
990: failf(data, "Authentication cancelled");
991: result = CURLE_LOGIN_DENIED;
992: }
993: break;
994: default:
995: break;
996: }
997:
998: return result;
999: }
1000:
1001: /* For LOGIN responses */
1002: static CURLcode imap_state_login_resp(struct connectdata *conn,
1003: int imapcode,
1004: imapstate instate)
1005: {
1006: CURLcode result = CURLE_OK;
1007: struct Curl_easy *data = conn->data;
1008:
1009: (void)instate; /* no use for this yet */
1010:
1011: if(imapcode != IMAP_RESP_OK) {
1012: failf(data, "Access denied. %c", imapcode);
1013: result = CURLE_LOGIN_DENIED;
1014: }
1015: else
1016: /* End of connect phase */
1017: state(conn, IMAP_STOP);
1018:
1019: return result;
1020: }
1021:
1022: /* For LIST and SEARCH responses */
1023: static CURLcode imap_state_listsearch_resp(struct connectdata *conn,
1024: int imapcode,
1025: imapstate instate)
1026: {
1027: CURLcode result = CURLE_OK;
1028: char *line = conn->data->state.buffer;
1029: size_t len = strlen(line);
1030:
1031: (void)instate; /* No use for this yet */
1032:
1033: if(imapcode == '*') {
1034: /* Temporarily add the LF character back and send as body to the client */
1035: line[len] = '\n';
1036: result = Curl_client_write(conn, CLIENTWRITE_BODY, line, len + 1);
1037: line[len] = '\0';
1038: }
1039: else if(imapcode != IMAP_RESP_OK)
1040: result = CURLE_QUOTE_ERROR;
1041: else
1042: /* End of DO phase */
1043: state(conn, IMAP_STOP);
1044:
1045: return result;
1046: }
1047:
1048: /* For SELECT responses */
1049: static CURLcode imap_state_select_resp(struct connectdata *conn, int imapcode,
1050: imapstate instate)
1051: {
1052: CURLcode result = CURLE_OK;
1053: struct Curl_easy *data = conn->data;
1054: struct IMAP *imap = conn->data->req.protop;
1055: struct imap_conn *imapc = &conn->proto.imapc;
1056: const char *line = data->state.buffer;
1057:
1058: (void)instate; /* no use for this yet */
1059:
1060: if(imapcode == '*') {
1061: /* See if this is an UIDVALIDITY response */
1062: char tmp[20];
1063: if(sscanf(line + 2, "OK [UIDVALIDITY %19[0123456789]]", tmp) == 1) {
1064: Curl_safefree(imapc->mailbox_uidvalidity);
1065: imapc->mailbox_uidvalidity = strdup(tmp);
1066: }
1067: }
1068: else if(imapcode == IMAP_RESP_OK) {
1069: /* Check if the UIDVALIDITY has been specified and matches */
1070: if(imap->uidvalidity && imapc->mailbox_uidvalidity &&
1071: !strcasecompare(imap->uidvalidity, imapc->mailbox_uidvalidity)) {
1072: failf(conn->data, "Mailbox UIDVALIDITY has changed");
1073: result = CURLE_REMOTE_FILE_NOT_FOUND;
1074: }
1075: else {
1076: /* Note the currently opened mailbox on this connection */
1077: imapc->mailbox = strdup(imap->mailbox);
1078:
1079: if(imap->custom)
1080: result = imap_perform_list(conn);
1081: else if(imap->query)
1082: result = imap_perform_search(conn);
1083: else
1084: result = imap_perform_fetch(conn);
1085: }
1086: }
1087: else {
1088: failf(data, "Select failed");
1089: result = CURLE_LOGIN_DENIED;
1090: }
1091:
1092: return result;
1093: }
1094:
1095: /* For the (first line of the) FETCH responses */
1096: static CURLcode imap_state_fetch_resp(struct connectdata *conn, int imapcode,
1097: imapstate instate)
1098: {
1099: CURLcode result = CURLE_OK;
1100: struct Curl_easy *data = conn->data;
1101: struct imap_conn *imapc = &conn->proto.imapc;
1102: struct pingpong *pp = &imapc->pp;
1103: const char *ptr = data->state.buffer;
1104: bool parsed = FALSE;
1105: curl_off_t size = 0;
1106:
1107: (void)instate; /* no use for this yet */
1108:
1109: if(imapcode != '*') {
1110: Curl_pgrsSetDownloadSize(data, -1);
1111: state(conn, IMAP_STOP);
1112: return CURLE_REMOTE_FILE_NOT_FOUND;
1113: }
1114:
1115: /* Something like this is received "* 1 FETCH (BODY[TEXT] {2021}\r" so parse
1116: the continuation data contained within the curly brackets */
1117: while(*ptr && (*ptr != '{'))
1118: ptr++;
1119:
1120: if(*ptr == '{') {
1121: char *endptr;
1122: if(!curlx_strtoofft(ptr + 1, &endptr, 10, &size)) {
1123: if(endptr - ptr > 1 && endptr[0] == '}' &&
1124: endptr[1] == '\r' && endptr[2] == '\0')
1125: parsed = TRUE;
1126: }
1127: }
1128:
1129: if(parsed) {
1130: infof(data, "Found %" CURL_FORMAT_CURL_OFF_T " bytes to download\n",
1131: size);
1132: Curl_pgrsSetDownloadSize(data, size);
1133:
1134: if(pp->cache) {
1135: /* At this point there is a bunch of data in the header "cache" that is
1136: actually body content, send it as body and then skip it. Do note
1137: that there may even be additional "headers" after the body. */
1138: size_t chunk = pp->cache_size;
1139:
1140: if(chunk > (size_t)size)
1141: /* The conversion from curl_off_t to size_t is always fine here */
1142: chunk = (size_t)size;
1143:
1144: if(!chunk) {
1145: /* no size, we're done with the data */
1146: state(conn, IMAP_STOP);
1147: return CURLE_OK;
1148: }
1149: result = Curl_client_write(conn, CLIENTWRITE_BODY, pp->cache, chunk);
1150: if(result)
1151: return result;
1152:
1153: data->req.bytecount += chunk;
1154:
1155: infof(data, "Written %zu bytes, %" CURL_FORMAT_CURL_OFF_TU
1156: " bytes are left for transfer\n", chunk, size - chunk);
1157:
1158: /* Have we used the entire cache or just part of it?*/
1159: if(pp->cache_size > chunk) {
1160: /* Only part of it so shrink the cache to fit the trailing data */
1161: memmove(pp->cache, pp->cache + chunk, pp->cache_size - chunk);
1162: pp->cache_size -= chunk;
1163: }
1164: else {
1165: /* Free the cache */
1166: Curl_safefree(pp->cache);
1167:
1168: /* Reset the cache size */
1169: pp->cache_size = 0;
1170: }
1171: }
1172:
1173: if(data->req.bytecount == size)
1174: /* The entire data is already transferred! */
1175: Curl_setup_transfer(data, -1, -1, FALSE, -1);
1176: else {
1177: /* IMAP download */
1178: data->req.maxdownload = size;
1179: Curl_setup_transfer(data, FIRSTSOCKET, size, FALSE, -1);
1180: }
1181: }
1182: else {
1183: /* We don't know how to parse this line */
1184: failf(pp->conn->data, "Failed to parse FETCH response.");
1185: result = CURLE_WEIRD_SERVER_REPLY;
1186: }
1187:
1188: /* End of DO phase */
1189: state(conn, IMAP_STOP);
1190:
1191: return result;
1192: }
1193:
1194: /* For final FETCH responses performed after the download */
1195: static CURLcode imap_state_fetch_final_resp(struct connectdata *conn,
1196: int imapcode,
1197: imapstate instate)
1198: {
1199: CURLcode result = CURLE_OK;
1200:
1201: (void)instate; /* No use for this yet */
1202:
1203: if(imapcode != IMAP_RESP_OK)
1204: result = CURLE_WEIRD_SERVER_REPLY;
1205: else
1206: /* End of DONE phase */
1207: state(conn, IMAP_STOP);
1208:
1209: return result;
1210: }
1211:
1212: /* For APPEND responses */
1213: static CURLcode imap_state_append_resp(struct connectdata *conn, int imapcode,
1214: imapstate instate)
1215: {
1216: CURLcode result = CURLE_OK;
1217: struct Curl_easy *data = conn->data;
1218:
1219: (void)instate; /* No use for this yet */
1220:
1221: if(imapcode != '+') {
1222: result = CURLE_UPLOAD_FAILED;
1223: }
1224: else {
1225: /* Set the progress upload size */
1226: Curl_pgrsSetUploadSize(data, data->state.infilesize);
1227:
1228: /* IMAP upload */
1229: Curl_setup_transfer(data, -1, -1, FALSE, FIRSTSOCKET);
1230:
1231: /* End of DO phase */
1232: state(conn, IMAP_STOP);
1233: }
1234:
1235: return result;
1236: }
1237:
1238: /* For final APPEND responses performed after the upload */
1239: static CURLcode imap_state_append_final_resp(struct connectdata *conn,
1240: int imapcode,
1241: imapstate instate)
1242: {
1243: CURLcode result = CURLE_OK;
1244:
1245: (void)instate; /* No use for this yet */
1246:
1247: if(imapcode != IMAP_RESP_OK)
1248: result = CURLE_UPLOAD_FAILED;
1249: else
1250: /* End of DONE phase */
1251: state(conn, IMAP_STOP);
1252:
1253: return result;
1254: }
1255:
1256: static CURLcode imap_statemach_act(struct connectdata *conn)
1257: {
1258: CURLcode result = CURLE_OK;
1259: curl_socket_t sock = conn->sock[FIRSTSOCKET];
1260: int imapcode;
1261: struct imap_conn *imapc = &conn->proto.imapc;
1262: struct pingpong *pp = &imapc->pp;
1263: size_t nread = 0;
1264:
1265: /* Busy upgrading the connection; right now all I/O is SSL/TLS, not IMAP */
1266: if(imapc->state == IMAP_UPGRADETLS)
1267: return imap_perform_upgrade_tls(conn);
1268:
1269: /* Flush any data that needs to be sent */
1270: if(pp->sendleft)
1271: return Curl_pp_flushsend(pp);
1272:
1273: do {
1274: /* Read the response from the server */
1275: result = Curl_pp_readresp(sock, pp, &imapcode, &nread);
1276: if(result)
1277: return result;
1278:
1279: /* Was there an error parsing the response line? */
1280: if(imapcode == -1)
1281: return CURLE_WEIRD_SERVER_REPLY;
1282:
1283: if(!imapcode)
1284: break;
1285:
1286: /* We have now received a full IMAP server response */
1287: switch(imapc->state) {
1288: case IMAP_SERVERGREET:
1289: result = imap_state_servergreet_resp(conn, imapcode, imapc->state);
1290: break;
1291:
1292: case IMAP_CAPABILITY:
1293: result = imap_state_capability_resp(conn, imapcode, imapc->state);
1294: break;
1295:
1296: case IMAP_STARTTLS:
1297: result = imap_state_starttls_resp(conn, imapcode, imapc->state);
1298: break;
1299:
1300: case IMAP_AUTHENTICATE:
1301: result = imap_state_auth_resp(conn, imapcode, imapc->state);
1302: break;
1303:
1304: case IMAP_LOGIN:
1305: result = imap_state_login_resp(conn, imapcode, imapc->state);
1306: break;
1307:
1308: case IMAP_LIST:
1309: case IMAP_SEARCH:
1310: result = imap_state_listsearch_resp(conn, imapcode, imapc->state);
1311: break;
1312:
1313: case IMAP_SELECT:
1314: result = imap_state_select_resp(conn, imapcode, imapc->state);
1315: break;
1316:
1317: case IMAP_FETCH:
1318: result = imap_state_fetch_resp(conn, imapcode, imapc->state);
1319: break;
1320:
1321: case IMAP_FETCH_FINAL:
1322: result = imap_state_fetch_final_resp(conn, imapcode, imapc->state);
1323: break;
1324:
1325: case IMAP_APPEND:
1326: result = imap_state_append_resp(conn, imapcode, imapc->state);
1327: break;
1328:
1329: case IMAP_APPEND_FINAL:
1330: result = imap_state_append_final_resp(conn, imapcode, imapc->state);
1331: break;
1332:
1333: case IMAP_LOGOUT:
1334: /* fallthrough, just stop! */
1335: default:
1336: /* internal error */
1337: state(conn, IMAP_STOP);
1338: break;
1339: }
1340: } while(!result && imapc->state != IMAP_STOP && Curl_pp_moredata(pp));
1341:
1342: return result;
1343: }
1344:
1345: /* Called repeatedly until done from multi.c */
1346: static CURLcode imap_multi_statemach(struct connectdata *conn, bool *done)
1347: {
1348: CURLcode result = CURLE_OK;
1349: struct imap_conn *imapc = &conn->proto.imapc;
1350:
1351: if((conn->handler->flags & PROTOPT_SSL) && !imapc->ssldone) {
1352: result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &imapc->ssldone);
1353: if(result || !imapc->ssldone)
1354: return result;
1355: }
1356:
1357: result = Curl_pp_statemach(&imapc->pp, FALSE, FALSE);
1358: *done = (imapc->state == IMAP_STOP) ? TRUE : FALSE;
1359:
1360: return result;
1361: }
1362:
1363: static CURLcode imap_block_statemach(struct connectdata *conn,
1364: bool disconnecting)
1365: {
1366: CURLcode result = CURLE_OK;
1367: struct imap_conn *imapc = &conn->proto.imapc;
1368:
1369: while(imapc->state != IMAP_STOP && !result)
1370: result = Curl_pp_statemach(&imapc->pp, TRUE, disconnecting);
1371:
1372: return result;
1373: }
1374:
1375: /* Allocate and initialize the struct IMAP for the current Curl_easy if
1376: required */
1377: static CURLcode imap_init(struct connectdata *conn)
1378: {
1379: CURLcode result = CURLE_OK;
1380: struct Curl_easy *data = conn->data;
1381: struct IMAP *imap;
1382:
1383: imap = data->req.protop = calloc(sizeof(struct IMAP), 1);
1384: if(!imap)
1385: result = CURLE_OUT_OF_MEMORY;
1386:
1387: return result;
1388: }
1389:
1390: /* For the IMAP "protocol connect" and "doing" phases only */
1391: static int imap_getsock(struct connectdata *conn, curl_socket_t *socks)
1392: {
1393: return Curl_pp_getsock(&conn->proto.imapc.pp, socks);
1394: }
1395:
1396: /***********************************************************************
1397: *
1398: * imap_connect()
1399: *
1400: * This function should do everything that is to be considered a part of the
1401: * connection phase.
1402: *
1403: * The variable 'done' points to will be TRUE if the protocol-layer connect
1404: * phase is done when this function returns, or FALSE if not.
1405: */
1406: static CURLcode imap_connect(struct connectdata *conn, bool *done)
1407: {
1408: CURLcode result = CURLE_OK;
1409: struct imap_conn *imapc = &conn->proto.imapc;
1410: struct pingpong *pp = &imapc->pp;
1411:
1412: *done = FALSE; /* default to not done yet */
1413:
1414: /* We always support persistent connections in IMAP */
1415: connkeep(conn, "IMAP default");
1416:
1417: /* Set the default response time-out */
1418: pp->response_time = RESP_TIMEOUT;
1419: pp->statemach_act = imap_statemach_act;
1420: pp->endofresp = imap_endofresp;
1421: pp->conn = conn;
1422:
1423: /* Set the default preferred authentication type and mechanism */
1424: imapc->preftype = IMAP_TYPE_ANY;
1425: Curl_sasl_init(&imapc->sasl, &saslimap);
1426:
1427: /* Initialise the pingpong layer */
1428: Curl_pp_init(pp);
1429:
1430: /* Parse the URL options */
1431: result = imap_parse_url_options(conn);
1432: if(result)
1433: return result;
1434:
1435: /* Start off waiting for the server greeting response */
1436: state(conn, IMAP_SERVERGREET);
1437:
1438: /* Start off with an response id of '*' */
1439: strcpy(imapc->resptag, "*");
1440:
1441: result = imap_multi_statemach(conn, done);
1442:
1443: return result;
1444: }
1445:
1446: /***********************************************************************
1447: *
1448: * imap_done()
1449: *
1450: * The DONE function. This does what needs to be done after a single DO has
1451: * performed.
1452: *
1453: * Input argument is already checked for validity.
1454: */
1455: static CURLcode imap_done(struct connectdata *conn, CURLcode status,
1456: bool premature)
1457: {
1458: CURLcode result = CURLE_OK;
1459: struct Curl_easy *data = conn->data;
1460: struct IMAP *imap = data->req.protop;
1461:
1462: (void)premature;
1463:
1464: if(!imap)
1465: return CURLE_OK;
1466:
1467: if(status) {
1468: connclose(conn, "IMAP done with bad status"); /* marked for closure */
1469: result = status; /* use the already set error code */
1470: }
1471: else if(!data->set.connect_only && !imap->custom &&
1472: (imap->uid || imap->mindex || data->set.upload ||
1473: data->set.mimepost.kind != MIMEKIND_NONE)) {
1474: /* Handle responses after FETCH or APPEND transfer has finished */
1475:
1476: if(!data->set.upload && data->set.mimepost.kind == MIMEKIND_NONE)
1477: state(conn, IMAP_FETCH_FINAL);
1478: else {
1479: /* End the APPEND command first by sending an empty line */
1480: result = Curl_pp_sendf(&conn->proto.imapc.pp, "%s", "");
1481: if(!result)
1482: state(conn, IMAP_APPEND_FINAL);
1483: }
1484:
1485: /* Run the state-machine */
1486: if(!result)
1487: result = imap_block_statemach(conn, FALSE);
1488: }
1489:
1490: /* Cleanup our per-request based variables */
1491: Curl_safefree(imap->mailbox);
1492: Curl_safefree(imap->uidvalidity);
1493: Curl_safefree(imap->uid);
1494: Curl_safefree(imap->mindex);
1495: Curl_safefree(imap->section);
1496: Curl_safefree(imap->partial);
1497: Curl_safefree(imap->query);
1498: Curl_safefree(imap->custom);
1499: Curl_safefree(imap->custom_params);
1500:
1501: /* Clear the transfer mode for the next request */
1502: imap->transfer = FTPTRANSFER_BODY;
1503:
1504: return result;
1505: }
1506:
1507: /***********************************************************************
1508: *
1509: * imap_perform()
1510: *
1511: * This is the actual DO function for IMAP. Fetch or append a message, or do
1512: * other things according to the options previously setup.
1513: */
1514: static CURLcode imap_perform(struct connectdata *conn, bool *connected,
1515: bool *dophase_done)
1516: {
1517: /* This is IMAP and no proxy */
1518: CURLcode result = CURLE_OK;
1519: struct Curl_easy *data = conn->data;
1520: struct IMAP *imap = data->req.protop;
1521: struct imap_conn *imapc = &conn->proto.imapc;
1522: bool selected = FALSE;
1523:
1524: DEBUGF(infof(conn->data, "DO phase starts\n"));
1525:
1526: if(conn->data->set.opt_no_body) {
1527: /* Requested no body means no transfer */
1528: imap->transfer = FTPTRANSFER_INFO;
1529: }
1530:
1531: *dophase_done = FALSE; /* not done yet */
1532:
1533: /* Determine if the requested mailbox (with the same UIDVALIDITY if set)
1534: has already been selected on this connection */
1535: if(imap->mailbox && imapc->mailbox &&
1536: strcasecompare(imap->mailbox, imapc->mailbox) &&
1537: (!imap->uidvalidity || !imapc->mailbox_uidvalidity ||
1538: strcasecompare(imap->uidvalidity, imapc->mailbox_uidvalidity)))
1539: selected = TRUE;
1540:
1541: /* Start the first command in the DO phase */
1542: if(conn->data->set.upload || data->set.mimepost.kind != MIMEKIND_NONE)
1543: /* APPEND can be executed directly */
1544: result = imap_perform_append(conn);
1545: else if(imap->custom && (selected || !imap->mailbox))
1546: /* Custom command using the same mailbox or no mailbox */
1547: result = imap_perform_list(conn);
1548: else if(!imap->custom && selected && (imap->uid || imap->mindex))
1549: /* FETCH from the same mailbox */
1550: result = imap_perform_fetch(conn);
1551: else if(!imap->custom && selected && imap->query)
1552: /* SEARCH the current mailbox */
1553: result = imap_perform_search(conn);
1554: else if(imap->mailbox && !selected &&
1555: (imap->custom || imap->uid || imap->mindex || imap->query))
1556: /* SELECT the mailbox */
1557: result = imap_perform_select(conn);
1558: else
1559: /* LIST */
1560: result = imap_perform_list(conn);
1561:
1562: if(result)
1563: return result;
1564:
1565: /* Run the state-machine */
1566: result = imap_multi_statemach(conn, dophase_done);
1567:
1568: *connected = conn->bits.tcpconnect[FIRSTSOCKET];
1569:
1570: if(*dophase_done)
1571: DEBUGF(infof(conn->data, "DO phase is complete\n"));
1572:
1573: return result;
1574: }
1575:
1576: /***********************************************************************
1577: *
1578: * imap_do()
1579: *
1580: * This function is registered as 'curl_do' function. It decodes the path
1581: * parts etc as a wrapper to the actual DO function (imap_perform).
1582: *
1583: * The input argument is already checked for validity.
1584: */
1585: static CURLcode imap_do(struct connectdata *conn, bool *done)
1586: {
1587: CURLcode result = CURLE_OK;
1588:
1589: *done = FALSE; /* default to false */
1590:
1591: /* Parse the URL path */
1592: result = imap_parse_url_path(conn);
1593: if(result)
1594: return result;
1595:
1596: /* Parse the custom request */
1597: result = imap_parse_custom_request(conn);
1598: if(result)
1599: return result;
1600:
1601: result = imap_regular_transfer(conn, done);
1602:
1603: return result;
1604: }
1605:
1606: /***********************************************************************
1607: *
1608: * imap_disconnect()
1609: *
1610: * Disconnect from an IMAP server. Cleanup protocol-specific per-connection
1611: * resources. BLOCKING.
1612: */
1613: static CURLcode imap_disconnect(struct connectdata *conn, bool dead_connection)
1614: {
1615: struct imap_conn *imapc = &conn->proto.imapc;
1616:
1617: /* We cannot send quit unconditionally. If this connection is stale or
1618: bad in any way, sending quit and waiting around here will make the
1619: disconnect wait in vain and cause more problems than we need to. */
1620:
1621: /* The IMAP session may or may not have been allocated/setup at this
1622: point! */
1623: if(!dead_connection && imapc->pp.conn && imapc->pp.conn->bits.protoconnstart)
1624: if(!imap_perform_logout(conn))
1625: (void)imap_block_statemach(conn, TRUE); /* ignore errors on LOGOUT */
1626:
1627: /* Disconnect from the server */
1628: Curl_pp_disconnect(&imapc->pp);
1629:
1630: /* Cleanup the SASL module */
1631: Curl_sasl_cleanup(conn, imapc->sasl.authused);
1632:
1633: /* Cleanup our connection based variables */
1634: Curl_safefree(imapc->mailbox);
1635: Curl_safefree(imapc->mailbox_uidvalidity);
1636:
1637: return CURLE_OK;
1638: }
1639:
1640: /* Call this when the DO phase has completed */
1641: static CURLcode imap_dophase_done(struct connectdata *conn, bool connected)
1642: {
1643: struct IMAP *imap = conn->data->req.protop;
1644:
1645: (void)connected;
1646:
1647: if(imap->transfer != FTPTRANSFER_BODY)
1648: /* no data to transfer */
1649: Curl_setup_transfer(conn->data, -1, -1, FALSE, -1);
1650:
1651: return CURLE_OK;
1652: }
1653:
1654: /* Called from multi.c while DOing */
1655: static CURLcode imap_doing(struct connectdata *conn, bool *dophase_done)
1656: {
1657: CURLcode result = imap_multi_statemach(conn, dophase_done);
1658:
1659: if(result)
1660: DEBUGF(infof(conn->data, "DO phase failed\n"));
1661: else if(*dophase_done) {
1662: result = imap_dophase_done(conn, FALSE /* not connected */);
1663:
1664: DEBUGF(infof(conn->data, "DO phase is complete\n"));
1665: }
1666:
1667: return result;
1668: }
1669:
1670: /***********************************************************************
1671: *
1672: * imap_regular_transfer()
1673: *
1674: * The input argument is already checked for validity.
1675: *
1676: * Performs all commands done before a regular transfer between a local and a
1677: * remote host.
1678: */
1679: static CURLcode imap_regular_transfer(struct connectdata *conn,
1680: bool *dophase_done)
1681: {
1682: CURLcode result = CURLE_OK;
1683: bool connected = FALSE;
1684: struct Curl_easy *data = conn->data;
1685:
1686: /* Make sure size is unknown at this point */
1687: data->req.size = -1;
1688:
1689: /* Set the progress data */
1690: Curl_pgrsSetUploadCounter(data, 0);
1691: Curl_pgrsSetDownloadCounter(data, 0);
1692: Curl_pgrsSetUploadSize(data, -1);
1693: Curl_pgrsSetDownloadSize(data, -1);
1694:
1695: /* Carry out the perform */
1696: result = imap_perform(conn, &connected, dophase_done);
1697:
1698: /* Perform post DO phase operations if necessary */
1699: if(!result && *dophase_done)
1700: result = imap_dophase_done(conn, connected);
1701:
1702: return result;
1703: }
1704:
1705: static CURLcode imap_setup_connection(struct connectdata *conn)
1706: {
1707: /* Initialise the IMAP layer */
1708: CURLcode result = imap_init(conn);
1709: if(result)
1710: return result;
1711:
1712: /* Clear the TLS upgraded flag */
1713: conn->tls_upgraded = FALSE;
1714:
1715: return CURLE_OK;
1716: }
1717:
1718: /***********************************************************************
1719: *
1720: * imap_sendf()
1721: *
1722: * Sends the formatted string as an IMAP command to the server.
1723: *
1724: * Designed to never block.
1725: */
1726: static CURLcode imap_sendf(struct connectdata *conn, const char *fmt, ...)
1727: {
1728: CURLcode result = CURLE_OK;
1729: struct imap_conn *imapc = &conn->proto.imapc;
1730: char *taggedfmt;
1731: va_list ap;
1732:
1733: DEBUGASSERT(fmt);
1734:
1735: /* Calculate the next command ID wrapping at 3 digits */
1736: imapc->cmdid = (imapc->cmdid + 1) % 1000;
1737:
1738: /* Calculate the tag based on the connection ID and command ID */
1739: msnprintf(imapc->resptag, sizeof(imapc->resptag), "%c%03d",
1740: 'A' + curlx_sltosi(conn->connection_id % 26), imapc->cmdid);
1741:
1742: /* Prefix the format with the tag */
1743: taggedfmt = aprintf("%s %s", imapc->resptag, fmt);
1744: if(!taggedfmt)
1745: return CURLE_OUT_OF_MEMORY;
1746:
1747: /* Send the data with the tag */
1748: va_start(ap, fmt);
1749: result = Curl_pp_vsendf(&imapc->pp, taggedfmt, ap);
1750: va_end(ap);
1751:
1752: free(taggedfmt);
1753:
1754: return result;
1755: }
1756:
1757: /***********************************************************************
1758: *
1759: * imap_atom()
1760: *
1761: * Checks the input string for characters that need escaping and returns an
1762: * atom ready for sending to the server.
1763: *
1764: * The returned string needs to be freed.
1765: *
1766: */
1767: static char *imap_atom(const char *str, bool escape_only)
1768: {
1769: /* !checksrc! disable PARENBRACE 1 */
1770: const char atom_specials[] = "(){ %*]";
1771: const char *p1;
1772: char *p2;
1773: size_t backsp_count = 0;
1774: size_t quote_count = 0;
1775: bool others_exists = FALSE;
1776: size_t newlen = 0;
1777: char *newstr = NULL;
1778:
1779: if(!str)
1780: return NULL;
1781:
1782: /* Look for "atom-specials", counting the backslash and quote characters as
1783: these will need escaping */
1784: p1 = str;
1785: while(*p1) {
1786: if(*p1 == '\\')
1787: backsp_count++;
1788: else if(*p1 == '"')
1789: quote_count++;
1790: else if(!escape_only) {
1791: const char *p3 = atom_specials;
1792:
1793: while(*p3 && !others_exists) {
1794: if(*p1 == *p3)
1795: others_exists = TRUE;
1796:
1797: p3++;
1798: }
1799: }
1800:
1801: p1++;
1802: }
1803:
1804: /* Does the input contain any "atom-special" characters? */
1805: if(!backsp_count && !quote_count && !others_exists)
1806: return strdup(str);
1807:
1808: /* Calculate the new string length */
1809: newlen = strlen(str) + backsp_count + quote_count + (escape_only ? 0 : 2);
1810:
1811: /* Allocate the new string */
1812: newstr = (char *) malloc((newlen + 1) * sizeof(char));
1813: if(!newstr)
1814: return NULL;
1815:
1816: /* Surround the string in quotes if necessary */
1817: p2 = newstr;
1818: if(!escape_only) {
1819: newstr[0] = '"';
1820: newstr[newlen - 1] = '"';
1821: p2++;
1822: }
1823:
1824: /* Copy the string, escaping backslash and quote characters along the way */
1825: p1 = str;
1826: while(*p1) {
1827: if(*p1 == '\\' || *p1 == '"') {
1828: *p2 = '\\';
1829: p2++;
1830: }
1831:
1832: *p2 = *p1;
1833:
1834: p1++;
1835: p2++;
1836: }
1837:
1838: /* Terminate the string */
1839: newstr[newlen] = '\0';
1840:
1841: return newstr;
1842: }
1843:
1844: /***********************************************************************
1845: *
1846: * imap_is_bchar()
1847: *
1848: * Portable test of whether the specified char is a "bchar" as defined in the
1849: * grammar of RFC-5092.
1850: */
1851: static bool imap_is_bchar(char ch)
1852: {
1853: switch(ch) {
1854: /* bchar */
1855: case ':': case '@': case '/':
1856: /* bchar -> achar */
1857: case '&': case '=':
1858: /* bchar -> achar -> uchar -> unreserved */
1859: case '0': case '1': case '2': case '3': case '4': case '5': case '6':
1860: case '7': case '8': case '9':
1861: case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1862: case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1863: case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1864: case 'V': case 'W': case 'X': case 'Y': case 'Z':
1865: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1866: case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
1867: case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
1868: case 'v': case 'w': case 'x': case 'y': case 'z':
1869: case '-': case '.': case '_': case '~':
1870: /* bchar -> achar -> uchar -> sub-delims-sh */
1871: case '!': case '$': case '\'': case '(': case ')': case '*':
1872: case '+': case ',':
1873: /* bchar -> achar -> uchar -> pct-encoded */
1874: case '%': /* HEXDIG chars are already included above */
1875: return true;
1876:
1877: default:
1878: return false;
1879: }
1880: }
1881:
1882: /***********************************************************************
1883: *
1884: * imap_parse_url_options()
1885: *
1886: * Parse the URL login options.
1887: */
1888: static CURLcode imap_parse_url_options(struct connectdata *conn)
1889: {
1890: CURLcode result = CURLE_OK;
1891: struct imap_conn *imapc = &conn->proto.imapc;
1892: const char *ptr = conn->options;
1893:
1894: imapc->sasl.resetprefs = TRUE;
1895:
1896: while(!result && ptr && *ptr) {
1897: const char *key = ptr;
1898: const char *value;
1899:
1900: while(*ptr && *ptr != '=')
1901: ptr++;
1902:
1903: value = ptr + 1;
1904:
1905: while(*ptr && *ptr != ';')
1906: ptr++;
1907:
1908: if(strncasecompare(key, "AUTH=", 5))
1909: result = Curl_sasl_parse_url_auth_option(&imapc->sasl,
1910: value, ptr - value);
1911: else
1912: result = CURLE_URL_MALFORMAT;
1913:
1914: if(*ptr == ';')
1915: ptr++;
1916: }
1917:
1918: switch(imapc->sasl.prefmech) {
1919: case SASL_AUTH_NONE:
1920: imapc->preftype = IMAP_TYPE_NONE;
1921: break;
1922: case SASL_AUTH_DEFAULT:
1923: imapc->preftype = IMAP_TYPE_ANY;
1924: break;
1925: default:
1926: imapc->preftype = IMAP_TYPE_SASL;
1927: break;
1928: }
1929:
1930: return result;
1931: }
1932:
1933: /***********************************************************************
1934: *
1935: * imap_parse_url_path()
1936: *
1937: * Parse the URL path into separate path components.
1938: *
1939: */
1940: static CURLcode imap_parse_url_path(struct connectdata *conn)
1941: {
1942: /* The imap struct is already initialised in imap_connect() */
1943: CURLcode result = CURLE_OK;
1944: struct Curl_easy *data = conn->data;
1945: struct IMAP *imap = data->req.protop;
1946: const char *begin = &data->state.up.path[1]; /* skip leading slash */
1947: const char *ptr = begin;
1948:
1949: /* See how much of the URL is a valid path and decode it */
1950: while(imap_is_bchar(*ptr))
1951: ptr++;
1952:
1953: if(ptr != begin) {
1954: /* Remove the trailing slash if present */
1955: const char *end = ptr;
1956: if(end > begin && end[-1] == '/')
1957: end--;
1958:
1959: result = Curl_urldecode(data, begin, end - begin, &imap->mailbox, NULL,
1960: TRUE);
1961: if(result)
1962: return result;
1963: }
1964: else
1965: imap->mailbox = NULL;
1966:
1967: /* There can be any number of parameters in the form ";NAME=VALUE" */
1968: while(*ptr == ';') {
1969: char *name;
1970: char *value;
1971: size_t valuelen;
1972:
1973: /* Find the length of the name parameter */
1974: begin = ++ptr;
1975: while(*ptr && *ptr != '=')
1976: ptr++;
1977:
1978: if(!*ptr)
1979: return CURLE_URL_MALFORMAT;
1980:
1981: /* Decode the name parameter */
1982: result = Curl_urldecode(data, begin, ptr - begin, &name, NULL, TRUE);
1983: if(result)
1984: return result;
1985:
1986: /* Find the length of the value parameter */
1987: begin = ++ptr;
1988: while(imap_is_bchar(*ptr))
1989: ptr++;
1990:
1991: /* Decode the value parameter */
1992: result = Curl_urldecode(data, begin, ptr - begin, &value, &valuelen, TRUE);
1993: if(result) {
1994: free(name);
1995: return result;
1996: }
1997:
1998: DEBUGF(infof(conn->data, "IMAP URL parameter '%s' = '%s'\n", name, value));
1999:
2000: /* Process the known hierarchical parameters (UIDVALIDITY, UID, SECTION and
2001: PARTIAL) stripping of the trailing slash character if it is present.
2002:
2003: Note: Unknown parameters trigger a URL_MALFORMAT error. */
2004: if(strcasecompare(name, "UIDVALIDITY") && !imap->uidvalidity) {
2005: if(valuelen > 0 && value[valuelen - 1] == '/')
2006: value[valuelen - 1] = '\0';
2007:
2008: imap->uidvalidity = value;
2009: value = NULL;
2010: }
2011: else if(strcasecompare(name, "UID") && !imap->uid) {
2012: if(valuelen > 0 && value[valuelen - 1] == '/')
2013: value[valuelen - 1] = '\0';
2014:
2015: imap->uid = value;
2016: value = NULL;
2017: }
2018: else if(strcasecompare(name, "MAILINDEX") && !imap->mindex) {
2019: if(valuelen > 0 && value[valuelen - 1] == '/')
2020: value[valuelen - 1] = '\0';
2021:
2022: imap->mindex = value;
2023: value = NULL;
2024: }
2025: else if(strcasecompare(name, "SECTION") && !imap->section) {
2026: if(valuelen > 0 && value[valuelen - 1] == '/')
2027: value[valuelen - 1] = '\0';
2028:
2029: imap->section = value;
2030: value = NULL;
2031: }
2032: else if(strcasecompare(name, "PARTIAL") && !imap->partial) {
2033: if(valuelen > 0 && value[valuelen - 1] == '/')
2034: value[valuelen - 1] = '\0';
2035:
2036: imap->partial = value;
2037: value = NULL;
2038: }
2039: else {
2040: free(name);
2041: free(value);
2042:
2043: return CURLE_URL_MALFORMAT;
2044: }
2045:
2046: free(name);
2047: free(value);
2048: }
2049:
2050: /* Does the URL contain a query parameter? Only valid when we have a mailbox
2051: and no UID as per RFC-5092 */
2052: if(imap->mailbox && !imap->uid && !imap->mindex) {
2053: /* Get the query parameter, URL decoded */
2054: (void)curl_url_get(data->state.uh, CURLUPART_QUERY, &imap->query,
2055: CURLU_URLDECODE);
2056: }
2057:
2058: /* Any extra stuff at the end of the URL is an error */
2059: if(*ptr)
2060: return CURLE_URL_MALFORMAT;
2061:
2062: return CURLE_OK;
2063: }
2064:
2065: /***********************************************************************
2066: *
2067: * imap_parse_custom_request()
2068: *
2069: * Parse the custom request.
2070: */
2071: static CURLcode imap_parse_custom_request(struct connectdata *conn)
2072: {
2073: CURLcode result = CURLE_OK;
2074: struct Curl_easy *data = conn->data;
2075: struct IMAP *imap = data->req.protop;
2076: const char *custom = data->set.str[STRING_CUSTOMREQUEST];
2077:
2078: if(custom) {
2079: /* URL decode the custom request */
2080: result = Curl_urldecode(data, custom, 0, &imap->custom, NULL, TRUE);
2081:
2082: /* Extract the parameters if specified */
2083: if(!result) {
2084: const char *params = imap->custom;
2085:
2086: while(*params && *params != ' ')
2087: params++;
2088:
2089: if(*params) {
2090: imap->custom_params = strdup(params);
2091: imap->custom[params - imap->custom] = '\0';
2092:
2093: if(!imap->custom_params)
2094: result = CURLE_OUT_OF_MEMORY;
2095: }
2096: }
2097: }
2098:
2099: return result;
2100: }
2101:
2102: #endif /* CURL_DISABLE_IMAP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to imap.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