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