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