luna - curl/lib/imap.c

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