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