lib/smtp.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2015, 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 http://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  * RFC1870 SMTP Service Extension for Message Size
  22  * RFC2195 CRAM-MD5 authentication
  23  * RFC2831 DIGEST-MD5 authentication
  24  * RFC3207 SMTP over TLS
  25  * RFC4422 Simple Authentication and Security Layer (SASL)
  26  * RFC4616 PLAIN authentication
  27  * RFC4752 The Kerberos V5 ("GSSAPI") SASL Mechanism
  28  * RFC4954 SMTP Authentication
  29  * RFC5321 SMTP protocol
  30  * RFC6749 OAuth 2.0 Authorization Framework
  31  * Draft   SMTP URL Interface   <draft-earhart-url-smtp-00.txt>
  32  * Draft   LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
  33  *
  34  ***************************************************************************/
  35
  36 #include "curl_setup.h"
  37
  38 #ifndef CURL_DISABLE_SMTP
  39
  40 #ifdef HAVE_NETINET_IN_H
  41 #include <netinet/in.h>
  42 #endif
  43 #ifdef HAVE_ARPA_INET_H
  44 #include <arpa/inet.h>
  45 #endif
  46 #ifdef HAVE_UTSNAME_H
  47 #include <sys/utsname.h>
  48 #endif
  49 #ifdef HAVE_NETDB_H
  50 #include <netdb.h>
  51 #endif
  52 #ifdef __VMS
  53 #include <in.h>
  54 #include <inet.h>
  55 #endif
  56
  57 #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
  58 #undef in_addr_t
  59 #define in_addr_t unsigned long
  60 #endif
  61
  62 #include <curl/curl.h>
  63 #include "urldata.h"
  64 #include "sendf.h"
  65 #include "hostip.h"
  66 #include "progress.h"
  67 #include "transfer.h"
  68 #include "escape.h"
  69 #include "http.h" /* for HTTP proxy tunnel stuff */
  70 #include "socks.h"
  71 #include "smtp.h"
  72
  73 #include "strtoofft.h"
  74 #include "strequal.h"
  75 #include "vtls/vtls.h"
  76 #include "connect.h"
  77 #include "strerror.h"
  78 #include "select.h"
  79 #include "multiif.h"
  80 #include "url.h"
  81 #include "rawstr.h"
  82 #include "curl_gethostname.h"
  83 #include "curl_sasl.h"
  84 #include "warnless.h"
  85 #include "curl_printf.h"
  86 #include "curl_memory.h"
  87 /* The last #include file should be: */
  88 #include "memdebug.h"
  89
  90 /* Local API functions */
  91 static CURLcode smtp_regular_transfer(struct connectdata *conn, bool *done);
  92 static CURLcode smtp_do(struct connectdata *conn, bool *done);
  93 static CURLcode smtp_done(struct connectdata *conn, CURLcode status,
  94                           bool premature);
  95 static CURLcode smtp_connect(struct connectdata *conn, bool *done);
  96 static CURLcode smtp_disconnect(struct connectdata *conn, bool dead);
  97 static CURLcode smtp_multi_statemach(struct connectdata *conn, bool *done);
  98 static int smtp_getsock(struct connectdata *conn, curl_socket_t *socks,
  99                         int numsocks);
 100 static CURLcode smtp_doing(struct connectdata *conn, bool *dophase_done);
 101 static CURLcode smtp_setup_connection(struct connectdata *conn);
 102 static CURLcode smtp_parse_url_options(struct connectdata *conn);
 103 static CURLcode smtp_parse_url_path(struct connectdata *conn);
 104 static CURLcode smtp_parse_custom_request(struct connectdata *conn);
 105 static CURLcode smtp_perform_auth(struct connectdata *conn, const char *mech,
 106                                   const char *initresp);
 107 static CURLcode smtp_continue_auth(struct connectdata *conn, const char *resp);
 108 static void smtp_get_message(char *buffer, char** outptr);
 109
 110 /*
 111  * SMTP protocol handler.
 112  */
 113
 114 const struct Curl_handler Curl_handler_smtp = {
 115   "SMTP",                           /* scheme */
 116   smtp_setup_connection,            /* setup_connection */
 117   smtp_do,                          /* do_it */
 118   smtp_done,                        /* done */
 119   ZERO_NULL,                        /* do_more */
 120   smtp_connect,                     /* connect_it */
 121   smtp_multi_statemach,             /* connecting */
 122   smtp_doing,                       /* doing */
 123   smtp_getsock,                     /* proto_getsock */
 124   smtp_getsock,                     /* doing_getsock */
 125   ZERO_NULL,                        /* domore_getsock */
 126   ZERO_NULL,                        /* perform_getsock */
 127   smtp_disconnect,                  /* disconnect */
 128   ZERO_NULL,                        /* readwrite */
 129   PORT_SMTP,                        /* defport */
 130   CURLPROTO_SMTP,                   /* protocol */
 131   PROTOPT_CLOSEACTION | PROTOPT_NOURLQUERY /* flags */
 132 };
 133
 134 #ifdef USE_SSL
 135 /*
 136  * SMTPS protocol handler.
 137  */
 138
 139 const struct Curl_handler Curl_handler_smtps = {
 140   "SMTPS",                          /* scheme */
 141   smtp_setup_connection,            /* setup_connection */
 142   smtp_do,                          /* do_it */
 143   smtp_done,                        /* done */
 144   ZERO_NULL,                        /* do_more */
 145   smtp_connect,                     /* connect_it */
 146   smtp_multi_statemach,             /* connecting */
 147   smtp_doing,                       /* doing */
 148   smtp_getsock,                     /* proto_getsock */
 149   smtp_getsock,                     /* doing_getsock */
 150   ZERO_NULL,                        /* domore_getsock */
 151   ZERO_NULL,                        /* perform_getsock */
 152   smtp_disconnect,                  /* disconnect */
 153   ZERO_NULL,                        /* readwrite */
 154   PORT_SMTPS,                       /* defport */
 155   CURLPROTO_SMTPS,                  /* protocol */
 156   PROTOPT_CLOSEACTION | PROTOPT_SSL
 157   | PROTOPT_NOURLQUERY              /* flags */
 158 };
 159 #endif
 160
 161 #ifndef CURL_DISABLE_HTTP
 162 /*
 163  * HTTP-proxyed SMTP protocol handler.
 164  */
 165
 166 static const struct Curl_handler Curl_handler_smtp_proxy = {
 167   "SMTP",                               /* scheme */
 168   Curl_http_setup_conn,                 /* setup_connection */
 169   Curl_http,                            /* do_it */
 170   Curl_http_done,                       /* done */
 171   ZERO_NULL,                            /* do_more */
 172   ZERO_NULL,                            /* connect_it */
 173   ZERO_NULL,                            /* connecting */
 174   ZERO_NULL,                            /* doing */
 175   ZERO_NULL,                            /* proto_getsock */
 176   ZERO_NULL,                            /* doing_getsock */
 177   ZERO_NULL,                            /* domore_getsock */
 178   ZERO_NULL,                            /* perform_getsock */
 179   ZERO_NULL,                            /* disconnect */
 180   ZERO_NULL,                            /* readwrite */
 181   PORT_SMTP,                            /* defport */
 182   CURLPROTO_HTTP,                       /* protocol */
 183   PROTOPT_NONE                          /* flags */
 184 };
 185
 186 #ifdef USE_SSL
 187 /*
 188  * HTTP-proxyed SMTPS protocol handler.
 189  */
 190
 191 static const struct Curl_handler Curl_handler_smtps_proxy = {
 192   "SMTPS",                              /* scheme */
 193   Curl_http_setup_conn,                 /* setup_connection */
 194   Curl_http,                            /* do_it */
 195   Curl_http_done,                       /* done */
 196   ZERO_NULL,                            /* do_more */
 197   ZERO_NULL,                            /* connect_it */
 198   ZERO_NULL,                            /* connecting */
 199   ZERO_NULL,                            /* doing */
 200   ZERO_NULL,                            /* proto_getsock */
 201   ZERO_NULL,                            /* doing_getsock */
 202   ZERO_NULL,                            /* domore_getsock */
 203   ZERO_NULL,                            /* perform_getsock */
 204   ZERO_NULL,                            /* disconnect */
 205   ZERO_NULL,                            /* readwrite */
 206   PORT_SMTPS,                           /* defport */
 207   CURLPROTO_HTTP,                       /* protocol */
 208   PROTOPT_NONE                          /* flags */
 209 };
 210 #endif
 211 #endif
 212
 213 /* SASL parameters for the smtp protocol */
 214 static const struct SASLproto saslsmtp = {
 215   "smtp",                     /* The service name */
 216   334,                        /* Code received when continuation is expected */
 217   235,                        /* Code to receive upon authentication success */
 218   512 - 8,                    /* Maximum initial response length (no max) */
 219   smtp_perform_auth,          /* Send authentication command */
 220   smtp_continue_auth,         /* Send authentication continuation */
 221   smtp_get_message            /* Get SASL response message */
 222 };
 223
 224 #ifdef USE_SSL
 225 static void smtp_to_smtps(struct connectdata *conn)
 226 {
 227   conn->handler = &Curl_handler_smtps;
 228 }
 229 #else
 230 #define smtp_to_smtps(x) Curl_nop_stmt
 231 #endif
 232
 233 /***********************************************************************
 234  *
 235  * smtp_endofresp()
 236  *
 237  * Checks for an ending SMTP status code at the start of the given string, but
 238  * also detects various capabilities from the EHLO response including the
 239  * supported authentication mechanisms.
 240  */
 241 static bool smtp_endofresp(struct connectdata *conn, char *line, size_t len,
 242                            int *resp)
 243 {
 244   struct smtp_conn *smtpc = &conn->proto.smtpc;
 245   bool result = FALSE;
 246
 247   /* Nothing for us */
 248   if(len < 4 || !ISDIGIT(line[0]) || !ISDIGIT(line[1]) || !ISDIGIT(line[2]))
 249     return FALSE;
 250
 251   /* Do we have a command response? This should be the response code followed
 252      by a space and optionally some text as per RFC-5321 and as outlined in
 253      Section 4. Examples of RFC-4954 but some e-mail servers ignore this and
 254      only send the response code instead as per Section 4.2. */
 255   if(line[3] == ' ' || len == 5) {
 256     result = TRUE;
 257     *resp = curlx_sltosi(strtol(line, NULL, 10));
 258
 259     /* Make sure real server never sends internal value */
 260     if(*resp == 1)
 261       *resp = 0;
 262   }
 263   /* Do we have a multiline (continuation) response? */
 264   else if(line[3] == '-' &&
 265           (smtpc->state == SMTP_EHLO || smtpc->state == SMTP_COMMAND)) {
 266     result = TRUE;
 267     *resp = 1;  /* Internal response code */
 268   }
 269
 270   return result;
 271 }
 272
 273 /***********************************************************************
 274  *
 275  * smtp_get_message()
 276  *
 277  * Gets the authentication message from the response buffer.
 278  */
 279 static void smtp_get_message(char *buffer, char** outptr)
 280 {
 281   size_t len = 0;
 282   char* message = NULL;
 283
 284   /* Find the start of the message */
 285   for(message = buffer + 4; *message == ' ' || *message == '\t'; message++)
 286     ;
 287
 288   /* Find the end of the message */
 289   for(len = strlen(message); len--;)
 290     if(message[len] != '\r' && message[len] != '\n' && message[len] != ' ' &&
 291         message[len] != '\t')
 292       break;
 293
 294   /* Terminate the message */
 295   if(++len) {
 296     message[len] = '\0';
 297   }
 298
 299   *outptr = message;
 300 }
 301
 302 /***********************************************************************
 303  *
 304  * state()
 305  *
 306  * This is the ONLY way to change SMTP state!
 307  */
 308 static void state(struct connectdata *conn, smtpstate newstate)
 309 {
 310   struct smtp_conn *smtpc = &conn->proto.smtpc;
 311 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
 312   /* for debug purposes */
 313   static const char * const names[] = {
 314     "STOP",
 315     "SERVERGREET",
 316     "EHLO",
 317     "HELO",
 318     "STARTTLS",
 319     "UPGRADETLS",
 320     "AUTH",
 321     "COMMAND",
 322     "MAIL",
 323     "RCPT",
 324     "DATA",
 325     "POSTDATA",
 326     "QUIT",
 327     /* LAST */
 328   };
 329
 330   if(smtpc->state != newstate)
 331     infof(conn->data, "SMTP %p state change from %s to %s\n",
 332           (void *)smtpc, names[smtpc->state], names[newstate]);
 333 #endif
 334
 335   smtpc->state = newstate;
 336 }
 337
 338 /***********************************************************************
 339  *
 340  * smtp_perform_ehlo()
 341  *
 342  * Sends the EHLO command to not only initialise communication with the ESMTP
 343  * server but to also obtain a list of server side supported capabilities.
 344  */
 345 static CURLcode smtp_perform_ehlo(struct connectdata *conn)
 346 {
 347   CURLcode result = CURLE_OK;
 348   struct smtp_conn *smtpc = &conn->proto.smtpc;
 349
 350   smtpc->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanism yet */
 351   smtpc->sasl.authused = SASL_AUTH_NONE;  /* Clear the authentication mechanism
 352                                              used for esmtp connections */
 353   smtpc->tls_supported = FALSE;           /* Clear the TLS capability */
 354   smtpc->auth_supported = FALSE;          /* Clear the AUTH capability */
 355
 356   /* Send the EHLO command */
 357   result = Curl_pp_sendf(&smtpc->pp, "EHLO %s", smtpc->domain);
 358
 359   if(!result)
 360     state(conn, SMTP_EHLO);
 361
 362   return result;
 363 }
 364
 365 /***********************************************************************
 366  *
 367  * smtp_perform_helo()
 368  *
 369  * Sends the HELO command to initialise communication with the SMTP server.
 370  */
 371 static CURLcode smtp_perform_helo(struct connectdata *conn)
 372 {
 373   CURLcode result = CURLE_OK;
 374   struct smtp_conn *smtpc = &conn->proto.smtpc;
 375
 376   smtpc->sasl.authused = SASL_AUTH_NONE; /* No authentication mechanism used
 377                                             in smtp connections */
 378
 379   /* Send the HELO command */
 380   result = Curl_pp_sendf(&smtpc->pp, "HELO %s", smtpc->domain);
 381
 382   if(!result)
 383     state(conn, SMTP_HELO);
 384
 385   return result;
 386 }
 387
 388 /***********************************************************************
 389  *
 390  * smtp_perform_starttls()
 391  *
 392  * Sends the STLS command to start the upgrade to TLS.
 393  */
 394 static CURLcode smtp_perform_starttls(struct connectdata *conn)
 395 {
 396   CURLcode result = CURLE_OK;
 397
 398   /* Send the STARTTLS command */
 399   result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s", "STARTTLS");
 400
 401   if(!result)
 402     state(conn, SMTP_STARTTLS);
 403
 404   return result;
 405 }
 406
 407 /***********************************************************************
 408  *
 409  * smtp_perform_upgrade_tls()
 410  *
 411  * Performs the upgrade to TLS.
 412  */
 413 static CURLcode smtp_perform_upgrade_tls(struct connectdata *conn)
 414 {
 415   CURLcode result = CURLE_OK;
 416   struct smtp_conn *smtpc = &conn->proto.smtpc;
 417
 418   /* Start the SSL connection */
 419   result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &smtpc->ssldone);
 420
 421   if(!result) {
 422     if(smtpc->state != SMTP_UPGRADETLS)
 423       state(conn, SMTP_UPGRADETLS);
 424
 425     if(smtpc->ssldone) {
 426       smtp_to_smtps(conn);
 427       result = smtp_perform_ehlo(conn);
 428     }
 429   }
 430
 431   return result;
 432 }
 433
 434 /***********************************************************************
 435  *
 436  * smtp_perform_auth()
 437  *
 438  * Sends an AUTH command allowing the client to login with the given SASL
 439  * authentication mechanism.
 440  */
 441 static CURLcode smtp_perform_auth(struct connectdata *conn,
 442                                   const char *mech,
 443                                   const char *initresp)
 444 {
 445   CURLcode result = CURLE_OK;
 446   struct smtp_conn *smtpc = &conn->proto.smtpc;
 447
 448   if(initresp) {                                  /* AUTH <mech> ...<crlf> */
 449     /* Send the AUTH command with the initial response */
 450     result = Curl_pp_sendf(&smtpc->pp, "AUTH %s %s", mech, initresp);
 451   }
 452   else {
 453     /* Send the AUTH command */
 454     result = Curl_pp_sendf(&smtpc->pp, "AUTH %s", mech);
 455   }
 456
 457   return result;
 458 }
 459
 460 /***********************************************************************
 461  *
 462  * smtp_continue_auth()
 463  *
 464  * Sends SASL continuation data or cancellation.
 465  */
 466 static CURLcode smtp_continue_auth(struct connectdata *conn, const char *resp)
 467 {
 468   struct smtp_conn *smtpc = &conn->proto.smtpc;
 469
 470   return Curl_pp_sendf(&smtpc->pp, "%s", resp);
 471 }
 472
 473 /***********************************************************************
 474  *
 475  * smtp_perform_authentication()
 476  *
 477  * Initiates the authentication sequence, with the appropriate SASL
 478  * authentication mechanism.
 479  */
 480 static CURLcode smtp_perform_authentication(struct connectdata *conn)
 481 {
 482   CURLcode result = CURLE_OK;
 483   struct smtp_conn *smtpc = &conn->proto.smtpc;
 484   saslprogress progress;
 485
 486   /* Check we have enough data to authenticate with, and the
 487      server supports authentiation, and end the connect phase if not */
 488   if(!smtpc->auth_supported ||
 489       !Curl_sasl_can_authenticate(&smtpc->sasl, conn)) {
 490     state(conn, SMTP_STOP);
 491     return result;
 492   }
 493
 494   /* Calculate the SASL login details */
 495   result = Curl_sasl_start(&smtpc->sasl, conn, FALSE, &progress);
 496
 497   if(!result) {
 498     if(progress == SASL_INPROGRESS)
 499       state(conn, SMTP_AUTH);
 500     else {
 501       /* Other mechanisms not supported */
 502       infof(conn->data, "No known authentication mechanisms supported!\n");
 503       result = CURLE_LOGIN_DENIED;
 504     }
 505   }
 506
 507   return result;
 508 }
 509
 510 /***********************************************************************
 511  *
 512  * smtp_perform_command()
 513  *
 514  * Sends a SMTP based command.
 515  */
 516 static CURLcode smtp_perform_command(struct connectdata *conn)
 517 {
 518   CURLcode result = CURLE_OK;
 519   struct SessionHandle *data = conn->data;
 520   struct SMTP *smtp = data->req.protop;
 521
 522   /* Send the command */
 523   if(smtp->rcpt)
 524     result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s %s",
 525                             smtp->custom && smtp->custom[0] != '\0' ?
 526                             smtp->custom : "VRFY",
 527                             smtp->rcpt->data);
 528   else
 529     result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s",
 530                            smtp->custom && smtp->custom[0] != '\0' ?
 531                            smtp->custom : "HELP");
 532
 533   if(!result)
 534     state(conn, SMTP_COMMAND);
 535
 536   return result;
 537 }
 538
 539 /***********************************************************************
 540  *
 541  * smtp_perform_mail()
 542  *
 543  * Sends an MAIL command to initiate the upload of a message.
 544  */
 545 static CURLcode smtp_perform_mail(struct connectdata *conn)
 546 {
 547   char *from = NULL;
 548   char *auth = NULL;
 549   char *size = NULL;
 550   CURLcode result = CURLE_OK;
 551   struct SessionHandle *data = conn->data;
 552
 553   /* Calculate the FROM parameter */
 554   if(!data->set.str[STRING_MAIL_FROM])
 555     /* Null reverse-path, RFC-5321, sect. 3.6.3 */
 556     from = strdup("<>");
 557   else if(data->set.str[STRING_MAIL_FROM][0] == '<')
 558     from = aprintf("%s", data->set.str[STRING_MAIL_FROM]);
 559   else
 560     from = aprintf("<%s>", data->set.str[STRING_MAIL_FROM]);
 561
 562   if(!from)
 563     return CURLE_OUT_OF_MEMORY;
 564
 565   /* Calculate the optional AUTH parameter */
 566   if(data->set.str[STRING_MAIL_AUTH] && conn->proto.smtpc.sasl.authused) {
 567     if(data->set.str[STRING_MAIL_AUTH][0] != '\0')
 568       auth = aprintf("%s", data->set.str[STRING_MAIL_AUTH]);
 569     else
 570       /* Empty AUTH, RFC-2554, sect. 5 */
 571       auth = strdup("<>");
 572
 573     if(!auth) {
 574       free(from);
 575
 576       return CURLE_OUT_OF_MEMORY;
 577     }
 578   }
 579
 580   /* Calculate the optional SIZE parameter */
 581   if(conn->proto.smtpc.size_supported && conn->data->state.infilesize > 0) {
 582     size = aprintf("%" CURL_FORMAT_CURL_OFF_T, data->state.infilesize);
 583
 584     if(!size) {
 585       free(from);
 586       free(auth);
 587
 588       return CURLE_OUT_OF_MEMORY;
 589     }
 590   }
 591
 592   /* Send the MAIL command */
 593   if(!auth && !size)
 594     result = Curl_pp_sendf(&conn->proto.smtpc.pp,
 595                            "MAIL FROM:%s", from);
 596   else if(auth && !size)
 597     result = Curl_pp_sendf(&conn->proto.smtpc.pp,
 598                            "MAIL FROM:%s AUTH=%s", from, auth);
 599   else if(auth && size)
 600     result = Curl_pp_sendf(&conn->proto.smtpc.pp,
 601                            "MAIL FROM:%s AUTH=%s SIZE=%s", from, auth, size);
 602   else
 603     result = Curl_pp_sendf(&conn->proto.smtpc.pp,
 604                            "MAIL FROM:%s SIZE=%s", from, size);
 605
 606   free(from);
 607   free(auth);
 608   free(size);
 609
 610   if(!result)
 611     state(conn, SMTP_MAIL);
 612
 613   return result;
 614 }
 615
 616 /***********************************************************************
 617  *
 618  * smtp_perform_rcpt_to()
 619  *
 620  * Sends a RCPT TO command for a given recipient as part of the message upload
 621  * process.
 622  */
 623 static CURLcode smtp_perform_rcpt_to(struct connectdata *conn)
 624 {
 625   CURLcode result = CURLE_OK;
 626   struct SessionHandle *data = conn->data;
 627   struct SMTP *smtp = data->req.protop;
 628
 629   /* Send the RCPT TO command */
 630   if(smtp->rcpt->data[0] == '<')
 631     result = Curl_pp_sendf(&conn->proto.smtpc.pp, "RCPT TO:%s",
 632                             smtp->rcpt->data);
 633   else
 634     result = Curl_pp_sendf(&conn->proto.smtpc.pp, "RCPT TO:<%s>",
 635                             smtp->rcpt->data);
 636   if(!result)
 637     state(conn, SMTP_RCPT);
 638
 639   return result;
 640 }
 641
 642 /***********************************************************************
 643  *
 644  * smtp_perform_quit()
 645  *
 646  * Performs the quit action prior to sclose() being called.
 647  */
 648 static CURLcode smtp_perform_quit(struct connectdata *conn)
 649 {
 650   CURLcode result = CURLE_OK;
 651
 652   /* Send the QUIT command */
 653   result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s", "QUIT");
 654
 655   if(!result)
 656     state(conn, SMTP_QUIT);
 657
 658   return result;
 659 }
 660
 661 /* For the initial server greeting */
 662 static CURLcode smtp_state_servergreet_resp(struct connectdata *conn,
 663                                             int smtpcode,
 664                                             smtpstate instate)
 665 {
 666   CURLcode result = CURLE_OK;
 667   struct SessionHandle *data = conn->data;
 668
 669   (void)instate; /* no use for this yet */
 670
 671   if(smtpcode/100 != 2) {
 672     failf(data, "Got unexpected smtp-server response: %d", smtpcode);
 673     result = CURLE_FTP_WEIRD_SERVER_REPLY;
 674   }
 675   else
 676     result = smtp_perform_ehlo(conn);
 677
 678   return result;
 679 }
 680
 681 /* For STARTTLS responses */
 682 static CURLcode smtp_state_starttls_resp(struct connectdata *conn,
 683                                          int smtpcode,
 684                                          smtpstate instate)
 685 {
 686   CURLcode result = CURLE_OK;
 687   struct SessionHandle *data = conn->data;
 688
 689   (void)instate; /* no use for this yet */
 690
 691   if(smtpcode != 220) {
 692     if(data->set.use_ssl != CURLUSESSL_TRY) {
 693       failf(data, "STARTTLS denied. %c", smtpcode);
 694       result = CURLE_USE_SSL_FAILED;
 695     }
 696     else
 697       result = smtp_perform_authentication(conn);
 698   }
 699   else
 700     result = smtp_perform_upgrade_tls(conn);
 701
 702   return result;
 703 }
 704
 705 /* For EHLO responses */
 706 static CURLcode smtp_state_ehlo_resp(struct connectdata *conn, int smtpcode,
 707                                      smtpstate instate)
 708 {
 709   CURLcode result = CURLE_OK;
 710   struct SessionHandle *data = conn->data;
 711   struct smtp_conn *smtpc = &conn->proto.smtpc;
 712   const char *line = data->state.buffer;
 713   size_t len = strlen(line);
 714   size_t wordlen;
 715
 716   (void)instate; /* no use for this yet */
 717
 718   if(smtpcode/100 != 2 && smtpcode != 1) {
 719     if(data->set.use_ssl <= CURLUSESSL_TRY || conn->ssl[FIRSTSOCKET].use)
 720       result = smtp_perform_helo(conn);
 721     else {
 722       failf(data, "Remote access denied: %d", smtpcode);
 723       result = CURLE_REMOTE_ACCESS_DENIED;
 724     }
 725   }
 726   else {
 727     line += 4;
 728     len -= 4;
 729
 730     /* Does the server support the STARTTLS capability? */
 731     if(len >= 8 && !memcmp(line, "STARTTLS", 8))
 732       smtpc->tls_supported = TRUE;
 733
 734     /* Does the server support the SIZE capability? */
 735     else if(len >= 4 && !memcmp(line, "SIZE", 4))
 736       smtpc->size_supported = TRUE;
 737
 738     /* Does the server support authentication? */
 739     else if(len >= 5 && !memcmp(line, "AUTH ", 5)) {
 740       smtpc->auth_supported = TRUE;
 741
 742       /* Advance past the AUTH keyword */
 743       line += 5;
 744       len -= 5;
 745
 746       /* Loop through the data line */
 747       for(;;) {
 748         size_t llen;
 749         unsigned int mechbit;
 750
 751         while(len &&
 752               (*line == ' ' || *line == '\t' ||
 753                *line == '\r' || *line == '\n')) {
 754
 755           line++;
 756           len--;
 757         }
 758
 759         if(!len)
 760           break;
 761
 762         /* Extract the word */
 763         for(wordlen = 0; wordlen < len && line[wordlen] != ' ' &&
 764               line[wordlen] != '\t' && line[wordlen] != '\r' &&
 765               line[wordlen] != '\n';)
 766           wordlen++;
 767
 768         /* Test the word for a matching authentication mechanism */
 769         if((mechbit = Curl_sasl_decode_mech(line, wordlen, &llen)) &&
 770            llen == wordlen)
 771           smtpc->sasl.authmechs |= mechbit;
 772
 773         line += wordlen;
 774         len -= wordlen;
 775       }
 776     }
 777
 778     if(smtpcode != 1) {
 779       if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
 780         /* We don't have a SSL/TLS connection yet, but SSL is requested */
 781         if(smtpc->tls_supported)
 782           /* Switch to TLS connection now */
 783           result = smtp_perform_starttls(conn);
 784         else if(data->set.use_ssl == CURLUSESSL_TRY)
 785           /* Fallback and carry on with authentication */
 786           result = smtp_perform_authentication(conn);
 787         else {
 788           failf(data, "STARTTLS not supported.");
 789           result = CURLE_USE_SSL_FAILED;
 790         }
 791       }
 792       else
 793         result = smtp_perform_authentication(conn);
 794     }
 795   }
 796
 797   return result;
 798 }
 799
 800 /* For HELO responses */
 801 static CURLcode smtp_state_helo_resp(struct connectdata *conn, int smtpcode,
 802                                      smtpstate instate)
 803 {
 804   CURLcode result = CURLE_OK;
 805   struct SessionHandle *data = conn->data;
 806
 807   (void)instate; /* no use for this yet */
 808
 809   if(smtpcode/100 != 2) {
 810     failf(data, "Remote access denied: %d", smtpcode);
 811     result = CURLE_REMOTE_ACCESS_DENIED;
 812   }
 813   else
 814     /* End of connect phase */
 815     state(conn, SMTP_STOP);
 816
 817   return result;
 818 }
 819
 820 /* For SASL authentication responses */
 821 static CURLcode smtp_state_auth_resp(struct connectdata *conn,
 822                                      int smtpcode,
 823                                      smtpstate instate)
 824 {
 825   CURLcode result = CURLE_OK;
 826   struct SessionHandle *data = conn->data;
 827   struct smtp_conn *smtpc = &conn->proto.smtpc;
 828   saslprogress progress;
 829
 830   (void)instate; /* no use for this yet */
 831
 832   result = Curl_sasl_continue(&smtpc->sasl, conn, smtpcode, &progress);
 833   if(!result)
 834     switch(progress) {
 835     case SASL_DONE:
 836       state(conn, SMTP_STOP);  /* Authenticated */
 837       break;
 838     case SASL_IDLE:            /* No mechanism left after cancellation */
 839       failf(data, "Authentication cancelled");
 840       result = CURLE_LOGIN_DENIED;
 841       break;
 842     default:
 843       break;
 844     }
 845
 846   return result;
 847 }
 848
 849 /* For command responses */
 850 static CURLcode smtp_state_command_resp(struct connectdata *conn, int smtpcode,
 851                                         smtpstate instate)
 852 {
 853   CURLcode result = CURLE_OK;
 854   struct SessionHandle *data = conn->data;
 855   struct SMTP *smtp = data->req.protop;
 856   char *line = data->state.buffer;
 857   size_t len = strlen(line);
 858
 859   (void)instate; /* no use for this yet */
 860
 861   if((smtp->rcpt && smtpcode/100 != 2 && smtpcode != 553 && smtpcode != 1) ||
 862      (!smtp->rcpt && smtpcode/100 != 2 && smtpcode != 1)) {
 863     failf(data, "Command failed: %d", smtpcode);
 864     result = CURLE_RECV_ERROR;
 865   }
 866   else {
 867     /* Temporarily add the LF character back and send as body to the client */
 868     if(!data->set.opt_no_body) {
 869       line[len] = '\n';
 870       result = Curl_client_write(conn, CLIENTWRITE_BODY, line, len + 1);
 871       line[len] = '\0';
 872     }
 873
 874     if(smtpcode != 1) {
 875       if(smtp->rcpt) {
 876         smtp->rcpt = smtp->rcpt->next;
 877
 878         if(smtp->rcpt) {
 879           /* Send the next command */
 880           result = smtp_perform_command(conn);
 881         }
 882         else
 883           /* End of DO phase */
 884           state(conn, SMTP_STOP);
 885       }
 886       else
 887         /* End of DO phase */
 888         state(conn, SMTP_STOP);
 889     }
 890   }
 891
 892   return result;
 893 }
 894
 895 /* For MAIL responses */
 896 static CURLcode smtp_state_mail_resp(struct connectdata *conn, int smtpcode,
 897                                      smtpstate instate)
 898 {
 899   CURLcode result = CURLE_OK;
 900   struct SessionHandle *data = conn->data;
 901
 902   (void)instate; /* no use for this yet */
 903
 904   if(smtpcode/100 != 2) {
 905     failf(data, "MAIL failed: %d", smtpcode);
 906     result = CURLE_SEND_ERROR;
 907   }
 908   else
 909     /* Start the RCPT TO command */
 910     result = smtp_perform_rcpt_to(conn);
 911
 912   return result;
 913 }
 914
 915 /* For RCPT responses */
 916 static CURLcode smtp_state_rcpt_resp(struct connectdata *conn, int smtpcode,
 917                                      smtpstate instate)
 918 {
 919   CURLcode result = CURLE_OK;
 920   struct SessionHandle *data = conn->data;
 921   struct SMTP *smtp = data->req.protop;
 922
 923   (void)instate; /* no use for this yet */
 924
 925   if(smtpcode/100 != 2) {
 926     failf(data, "RCPT failed: %d", smtpcode);
 927     result = CURLE_SEND_ERROR;
 928   }
 929   else {
 930     smtp->rcpt = smtp->rcpt->next;
 931
 932     if(smtp->rcpt)
 933       /* Send the next RCPT TO command */
 934       result = smtp_perform_rcpt_to(conn);
 935     else {
 936       /* Send the DATA command */
 937       result = Curl_pp_sendf(&conn->proto.smtpc.pp, "%s", "DATA");
 938
 939       if(!result)
 940         state(conn, SMTP_DATA);
 941     }
 942   }
 943
 944   return result;
 945 }
 946
 947 /* For DATA response */
 948 static CURLcode smtp_state_data_resp(struct connectdata *conn, int smtpcode,
 949                                      smtpstate instate)
 950 {
 951   CURLcode result = CURLE_OK;
 952   struct SessionHandle *data = conn->data;
 953
 954   (void)instate; /* no use for this yet */
 955
 956   if(smtpcode != 354) {
 957     failf(data, "DATA failed: %d", smtpcode);
 958     result = CURLE_SEND_ERROR;
 959   }
 960   else {
 961     /* Set the progress upload size */
 962     Curl_pgrsSetUploadSize(data, data->state.infilesize);
 963
 964     /* SMTP upload */
 965     Curl_setup_transfer(conn, -1, -1, FALSE, NULL, FIRSTSOCKET, NULL);
 966
 967     /* End of DO phase */
 968     state(conn, SMTP_STOP);
 969   }
 970
 971   return result;
 972 }
 973
 974 /* For POSTDATA responses, which are received after the entire DATA
 975    part has been sent to the server */
 976 static CURLcode smtp_state_postdata_resp(struct connectdata *conn,
 977                                          int smtpcode,
 978                                          smtpstate instate)
 979 {
 980   CURLcode result = CURLE_OK;
 981
 982   (void)instate; /* no use for this yet */
 983
 984   if(smtpcode != 250)
 985     result = CURLE_RECV_ERROR;
 986
 987   /* End of DONE phase */
 988   state(conn, SMTP_STOP);
 989
 990   return result;
 991 }
 992
 993 static CURLcode smtp_statemach_act(struct connectdata *conn)
 994 {
 995   CURLcode result = CURLE_OK;
 996   curl_socket_t sock = conn->sock[FIRSTSOCKET];
 997   struct SessionHandle *data = conn->data;
 998   int smtpcode;
 999   struct smtp_conn *smtpc = &conn->proto.smtpc;
1000   struct pingpong *pp = &smtpc->pp;
1001   size_t nread = 0;
1002
1003   /* Busy upgrading the connection; right now all I/O is SSL/TLS, not SMTP */
1004   if(smtpc->state == SMTP_UPGRADETLS)
1005     return smtp_perform_upgrade_tls(conn);
1006
1007   /* Flush any data that needs to be sent */
1008   if(pp->sendleft)
1009     return Curl_pp_flushsend(pp);
1010
1011   do {
1012     /* Read the response from the server */
1013     result = Curl_pp_readresp(sock, pp, &smtpcode, &nread);
1014     if(result)
1015       return result;
1016
1017     /* Store the latest response for later retrieval if necessary */
1018     if(smtpc->state != SMTP_QUIT && smtpcode != 1)
1019       data->info.httpcode = smtpcode;
1020
1021     if(!smtpcode)
1022       break;
1023
1024     /* We have now received a full SMTP server response */
1025     switch(smtpc->state) {
1026     case SMTP_SERVERGREET:
1027       result = smtp_state_servergreet_resp(conn, smtpcode, smtpc->state);
1028       break;
1029
1030     case SMTP_EHLO:
1031       result = smtp_state_ehlo_resp(conn, smtpcode, smtpc->state);
1032       break;
1033
1034     case SMTP_HELO:
1035       result = smtp_state_helo_resp(conn, smtpcode, smtpc->state);
1036       break;
1037
1038     case SMTP_STARTTLS:
1039       result = smtp_state_starttls_resp(conn, smtpcode, smtpc->state);
1040       break;
1041
1042     case SMTP_AUTH:
1043       result = smtp_state_auth_resp(conn, smtpcode, smtpc->state);
1044       break;
1045
1046     case SMTP_COMMAND:
1047       result = smtp_state_command_resp(conn, smtpcode, smtpc->state);
1048       break;
1049
1050     case SMTP_MAIL:
1051       result = smtp_state_mail_resp(conn, smtpcode, smtpc->state);
1052       break;
1053
1054     case SMTP_RCPT:
1055       result = smtp_state_rcpt_resp(conn, smtpcode, smtpc->state);
1056       break;
1057
1058     case SMTP_DATA:
1059       result = smtp_state_data_resp(conn, smtpcode, smtpc->state);
1060       break;
1061
1062     case SMTP_POSTDATA:
1063       result = smtp_state_postdata_resp(conn, smtpcode, smtpc->state);
1064       break;
1065
1066     case SMTP_QUIT:
1067       /* fallthrough, just stop! */
1068     default:
1069       /* internal error */
1070       state(conn, SMTP_STOP);
1071       break;
1072     }
1073   } while(!result && smtpc->state != SMTP_STOP && Curl_pp_moredata(pp));
1074
1075   return result;
1076 }
1077
1078 /* Called repeatedly until done from multi.c */
1079 static CURLcode smtp_multi_statemach(struct connectdata *conn, bool *done)
1080 {
1081   CURLcode result = CURLE_OK;
1082   struct smtp_conn *smtpc = &conn->proto.smtpc;
1083
1084   if((conn->handler->flags & PROTOPT_SSL) && !smtpc->ssldone) {
1085     result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &smtpc->ssldone);
1086     if(result || !smtpc->ssldone)
1087       return result;
1088   }
1089
1090   result = Curl_pp_statemach(&smtpc->pp, FALSE);
1091   *done = (smtpc->state == SMTP_STOP) ? TRUE : FALSE;
1092
1093   return result;
1094 }
1095
1096 static CURLcode smtp_block_statemach(struct connectdata *conn)
1097 {
1098   CURLcode result = CURLE_OK;
1099   struct smtp_conn *smtpc = &conn->proto.smtpc;
1100
1101   while(smtpc->state != SMTP_STOP && !result)
1102     result = Curl_pp_statemach(&smtpc->pp, TRUE);
1103
1104   return result;
1105 }
1106
1107 /* Allocate and initialize the SMTP struct for the current SessionHandle if
1108    required */
1109 static CURLcode smtp_init(struct connectdata *conn)
1110 {
1111   CURLcode result = CURLE_OK;
1112   struct SessionHandle *data = conn->data;
1113   struct SMTP *smtp;
1114
1115   smtp = data->req.protop = calloc(sizeof(struct SMTP), 1);
1116   if(!smtp)
1117     result = CURLE_OUT_OF_MEMORY;
1118
1119   return result;
1120 }
1121
1122 /* For the SMTP "protocol connect" and "doing" phases only */
1123 static int smtp_getsock(struct connectdata *conn, curl_socket_t *socks,
1124                         int numsocks)
1125 {
1126   return Curl_pp_getsock(&conn->proto.smtpc.pp, socks, numsocks);
1127 }
1128
1129 /***********************************************************************
1130  *
1131  * smtp_connect()
1132  *
1133  * This function should do everything that is to be considered a part of
1134  * the connection phase.
1135  *
1136  * The variable pointed to by 'done' will be TRUE if the protocol-layer
1137  * connect phase is done when this function returns, or FALSE if not.
1138  */
1139 static CURLcode smtp_connect(struct connectdata *conn, bool *done)
1140 {
1141   CURLcode result = CURLE_OK;
1142   struct smtp_conn *smtpc = &conn->proto.smtpc;
1143   struct pingpong *pp = &smtpc->pp;
1144
1145   *done = FALSE; /* default to not done yet */
1146
1147   /* We always support persistent connections in SMTP */
1148   connkeep(conn, "SMTP default");
1149
1150   /* Set the default response time-out */
1151   pp->response_time = RESP_TIMEOUT;
1152   pp->statemach_act = smtp_statemach_act;
1153   pp->endofresp = smtp_endofresp;
1154   pp->conn = conn;
1155
1156   /* Initialize the SASL storage */
1157   Curl_sasl_init(&smtpc->sasl, &saslsmtp);
1158
1159   /* Initialise the pingpong layer */
1160   Curl_pp_init(pp);
1161
1162   /* Parse the URL options */
1163   result = smtp_parse_url_options(conn);
1164   if(result)
1165     return result;
1166
1167   /* Parse the URL path */
1168   result = smtp_parse_url_path(conn);
1169   if(result)
1170     return result;
1171
1172   /* Start off waiting for the server greeting response */
1173   state(conn, SMTP_SERVERGREET);
1174
1175   result = smtp_multi_statemach(conn, done);
1176
1177   return result;
1178 }
1179
1180 /***********************************************************************
1181  *
1182  * smtp_done()
1183  *
1184  * The DONE function. This does what needs to be done after a single DO has
1185  * performed.
1186  *
1187  * Input argument is already checked for validity.
1188  */
1189 static CURLcode smtp_done(struct connectdata *conn, CURLcode status,
1190                           bool premature)
1191 {
1192   CURLcode result = CURLE_OK;
1193   struct SessionHandle *data = conn->data;
1194   struct SMTP *smtp = data->req.protop;
1195   struct pingpong *pp = &conn->proto.smtpc.pp;
1196   char *eob;
1197   ssize_t len;
1198   ssize_t bytes_written;
1199
1200   (void)premature;
1201
1202   if(!smtp || !pp->conn)
1203     /* When the easy handle is removed from the multi interface while libcurl
1204        is still trying to resolve the host name, the SMTP struct is not yet
1205        initialized. However, the removal action calls Curl_done() which in
1206        turn calls this function, so we simply return success. */
1207     return CURLE_OK;
1208
1209   if(status) {
1210     connclose(conn, "SMTP done with bad status"); /* marked for closure */
1211     result = status;         /* use the already set error code */
1212   }
1213   else if(!data->set.connect_only && data->set.upload && data->set.mail_rcpt) {
1214     /* Calculate the EOB taking into account any terminating CRLF from the
1215        previous line of the email or the CRLF of the DATA command when there
1216        is "no mail data". RFC-5321, sect. 4.1.1.4.
1217
1218        Note: As some SSL backends, such as OpenSSL, will cause Curl_write() to
1219        fail when using a different pointer following a previous write, that
1220        returned CURLE_AGAIN, we duplicate the EOB now rather than when the
1221        bytes written doesn't equal len. */
1222     if(smtp->trailing_crlf || !conn->data->state.infilesize) {
1223       eob = strdup(SMTP_EOB + 2);
1224       len = SMTP_EOB_LEN - 2;
1225     }
1226     else {
1227       eob = strdup(SMTP_EOB);
1228       len = SMTP_EOB_LEN;
1229     }
1230
1231     if(!eob)
1232       return CURLE_OUT_OF_MEMORY;
1233
1234     /* Send the end of block data */
1235     result = Curl_write(conn, conn->writesockfd, eob, len, &bytes_written);
1236     if(result) {
1237       free(eob);
1238       return result;
1239     }
1240
1241     if(bytes_written != len) {
1242       /* The whole chunk was not sent so keep it around and adjust the
1243          pingpong structure accordingly */
1244       pp->sendthis = eob;
1245       pp->sendsize = len;
1246       pp->sendleft = len - bytes_written;
1247     }
1248     else {
1249       /* Successfully sent so adjust the response timeout relative to now */
1250       pp->response = Curl_tvnow();
1251
1252       free(eob);
1253     }
1254
1255     state(conn, SMTP_POSTDATA);
1256
1257     /* Run the state-machine
1258
1259        TODO: when the multi interface is used, this _really_ should be using
1260        the smtp_multi_statemach function but we have no general support for
1261        non-blocking DONE operations, not in the multi state machine and with
1262        Curl_done() invokes on several places in the code!
1263     */
1264     result = smtp_block_statemach(conn);
1265   }
1266
1267   /* Cleanup our per-request based variables */
1268   Curl_safefree(smtp->custom);
1269
1270   /* Clear the transfer mode for the next request */
1271   smtp->transfer = FTPTRANSFER_BODY;
1272
1273   return result;
1274 }
1275
1276 /***********************************************************************
1277  *
1278  * smtp_perform()
1279  *
1280  * This is the actual DO function for SMTP. Transfer a mail, send a command
1281  * or get some data according to the options previously setup.
1282  */
1283 static CURLcode smtp_perform(struct connectdata *conn, bool *connected,
1284                              bool *dophase_done)
1285 {
1286   /* This is SMTP and no proxy */
1287   CURLcode result = CURLE_OK;
1288   struct SessionHandle *data = conn->data;
1289   struct SMTP *smtp = data->req.protop;
1290
1291   DEBUGF(infof(conn->data, "DO phase starts\n"));
1292
1293   if(data->set.opt_no_body) {
1294     /* Requested no body means no transfer */
1295     smtp->transfer = FTPTRANSFER_INFO;
1296   }
1297
1298   *dophase_done = FALSE; /* not done yet */
1299
1300   /* Store the first recipient (or NULL if not specified) */
1301   smtp->rcpt = data->set.mail_rcpt;
1302
1303   /* Start the first command in the DO phase */
1304   if(data->set.upload && data->set.mail_rcpt)
1305     /* MAIL transfer */
1306     result = smtp_perform_mail(conn);
1307   else
1308     /* SMTP based command (VRFY, EXPN, NOOP, RSET or HELP) */
1309     result = smtp_perform_command(conn);
1310
1311   if(result)
1312     return result;
1313
1314   /* Run the state-machine */
1315   result = smtp_multi_statemach(conn, dophase_done);
1316
1317   *connected = conn->bits.tcpconnect[FIRSTSOCKET];
1318
1319   if(*dophase_done)
1320     DEBUGF(infof(conn->data, "DO phase is complete\n"));
1321
1322   return result;
1323 }
1324
1325 /***********************************************************************
1326  *
1327  * smtp_do()
1328  *
1329  * This function is registered as 'curl_do' function. It decodes the path
1330  * parts etc as a wrapper to the actual DO function (smtp_perform).
1331  *
1332  * The input argument is already checked for validity.
1333  */
1334 static CURLcode smtp_do(struct connectdata *conn, bool *done)
1335 {
1336   CURLcode result = CURLE_OK;
1337
1338   *done = FALSE; /* default to false */
1339
1340   /* Parse the custom request */
1341   result = smtp_parse_custom_request(conn);
1342   if(result)
1343     return result;
1344
1345   result = smtp_regular_transfer(conn, done);
1346
1347   return result;
1348 }
1349
1350 /***********************************************************************
1351  *
1352  * smtp_disconnect()
1353  *
1354  * Disconnect from an SMTP server. Cleanup protocol-specific per-connection
1355  * resources. BLOCKING.
1356  */
1357 static CURLcode smtp_disconnect(struct connectdata *conn, bool dead_connection)
1358 {
1359   struct smtp_conn *smtpc = &conn->proto.smtpc;
1360
1361   /* We cannot send quit unconditionally. If this connection is stale or
1362      bad in any way, sending quit and waiting around here will make the
1363      disconnect wait in vain and cause more problems than we need to. */
1364
1365   /* The SMTP session may or may not have been allocated/setup at this
1366      point! */
1367   if(!dead_connection && smtpc->pp.conn && smtpc->pp.conn->bits.protoconnstart)
1368     if(!smtp_perform_quit(conn))
1369       (void)smtp_block_statemach(conn); /* ignore errors on QUIT */
1370
1371   /* Disconnect from the server */
1372   Curl_pp_disconnect(&smtpc->pp);
1373
1374   /* Cleanup the SASL module */
1375   Curl_sasl_cleanup(conn, smtpc->sasl.authused);
1376
1377   /* Cleanup our connection based variables */
1378   Curl_safefree(smtpc->domain);
1379
1380   return CURLE_OK;
1381 }
1382
1383 /* Call this when the DO phase has completed */
1384 static CURLcode smtp_dophase_done(struct connectdata *conn, bool connected)
1385 {
1386   struct SMTP *smtp = conn->data->req.protop;
1387
1388   (void)connected;
1389
1390   if(smtp->transfer != FTPTRANSFER_BODY)
1391     /* no data to transfer */
1392     Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
1393
1394   return CURLE_OK;
1395 }
1396
1397 /* Called from multi.c while DOing */
1398 static CURLcode smtp_doing(struct connectdata *conn, bool *dophase_done)
1399 {
1400   CURLcode result = smtp_multi_statemach(conn, dophase_done);
1401
1402   if(result)
1403     DEBUGF(infof(conn->data, "DO phase failed\n"));
1404   else if(*dophase_done) {
1405     result = smtp_dophase_done(conn, FALSE /* not connected */);
1406
1407     DEBUGF(infof(conn->data, "DO phase is complete\n"));
1408   }
1409
1410   return result;
1411 }
1412
1413 /***********************************************************************
1414  *
1415  * smtp_regular_transfer()
1416  *
1417  * The input argument is already checked for validity.
1418  *
1419  * Performs all commands done before a regular transfer between a local and a
1420  * remote host.
1421  */
1422 static CURLcode smtp_regular_transfer(struct connectdata *conn,
1423                                       bool *dophase_done)
1424 {
1425   CURLcode result = CURLE_OK;
1426   bool connected = FALSE;
1427   struct SessionHandle *data = conn->data;
1428
1429   /* Make sure size is unknown at this point */
1430   data->req.size = -1;
1431
1432   /* Set the progress data */
1433   Curl_pgrsSetUploadCounter(data, 0);
1434   Curl_pgrsSetDownloadCounter(data, 0);
1435   Curl_pgrsSetUploadSize(data, -1);
1436   Curl_pgrsSetDownloadSize(data, -1);
1437
1438   /* Carry out the perform */
1439   result = smtp_perform(conn, &connected, dophase_done);
1440
1441   /* Perform post DO phase operations if necessary */
1442   if(!result && *dophase_done)
1443     result = smtp_dophase_done(conn, connected);
1444
1445   return result;
1446 }
1447
1448 static CURLcode smtp_setup_connection(struct connectdata *conn)
1449 {
1450   struct SessionHandle *data = conn->data;
1451   CURLcode result;
1452
1453   if(conn->bits.httpproxy && !data->set.tunnel_thru_httpproxy) {
1454     /* Unless we have asked to tunnel SMTP operations through the proxy, we
1455        switch and use HTTP operations only */
1456 #ifndef CURL_DISABLE_HTTP
1457     if(conn->handler == &Curl_handler_smtp)
1458       conn->handler = &Curl_handler_smtp_proxy;
1459     else {
1460 #ifdef USE_SSL
1461       conn->handler = &Curl_handler_smtps_proxy;
1462 #else
1463       failf(data, "SMTPS not supported!");
1464       return CURLE_UNSUPPORTED_PROTOCOL;
1465 #endif
1466     }
1467     /* set it up as a HTTP connection instead */
1468     return conn->handler->setup_connection(conn);
1469
1470 #else
1471     failf(data, "SMTP over http proxy requires HTTP support built-in!");
1472     return CURLE_UNSUPPORTED_PROTOCOL;
1473 #endif
1474   }
1475
1476   /* Initialise the SMTP layer */
1477   result = smtp_init(conn);
1478   if(result)
1479     return result;
1480
1481   data->state.path++;   /* don't include the initial slash */
1482
1483   return CURLE_OK;
1484 }
1485
1486 /***********************************************************************
1487  *
1488  * smtp_parse_url_options()
1489  *
1490  * Parse the URL login options.
1491  */
1492 static CURLcode smtp_parse_url_options(struct connectdata *conn)
1493 {
1494   CURLcode result = CURLE_OK;
1495   struct smtp_conn *smtpc = &conn->proto.smtpc;
1496   const char *ptr = conn->options;
1497
1498   smtpc->sasl.resetprefs = TRUE;
1499
1500   while(!result && ptr && *ptr) {
1501     const char *key = ptr;
1502     const char *value;
1503
1504     while(*ptr && *ptr != '=')
1505         ptr++;
1506
1507     value = ptr + 1;
1508
1509     while(*ptr && *ptr != ';')
1510       ptr++;
1511
1512     if(strnequal(key, "AUTH=", 5))
1513       result = Curl_sasl_parse_url_auth_option(&smtpc->sasl,
1514                                                value, ptr - value);
1515     else
1516       result = CURLE_URL_MALFORMAT;
1517
1518     if(*ptr == ';')
1519       ptr++;
1520   }
1521
1522   return result;
1523 }
1524
1525 /***********************************************************************
1526  *
1527  * smtp_parse_url_path()
1528  *
1529  * Parse the URL path into separate path components.
1530  */
1531 static CURLcode smtp_parse_url_path(struct connectdata *conn)
1532 {
1533   /* The SMTP struct is already initialised in smtp_connect() */
1534   struct SessionHandle *data = conn->data;
1535   struct smtp_conn *smtpc = &conn->proto.smtpc;
1536   const char *path = data->state.path;
1537   char localhost[HOSTNAME_MAX + 1];
1538
1539   /* Calculate the path if necessary */
1540   if(!*path) {
1541     if(!Curl_gethostname(localhost, sizeof(localhost)))
1542       path = localhost;
1543     else
1544       path = "localhost";
1545   }
1546
1547   /* URL decode the path and use it as the domain in our EHLO */
1548   return Curl_urldecode(conn->data, path, 0, &smtpc->domain, NULL, TRUE);
1549 }
1550
1551 /***********************************************************************
1552  *
1553  * smtp_parse_custom_request()
1554  *
1555  * Parse the custom request.
1556  */
1557 static CURLcode smtp_parse_custom_request(struct connectdata *conn)
1558 {
1559   CURLcode result = CURLE_OK;
1560   struct SessionHandle *data = conn->data;
1561   struct SMTP *smtp = data->req.protop;
1562   const char *custom = data->set.str[STRING_CUSTOMREQUEST];
1563
1564   /* URL decode the custom request */
1565   if(custom)
1566     result = Curl_urldecode(data, custom, 0, &smtp->custom, NULL, TRUE);
1567
1568   return result;
1569 }
1570
1571 CURLcode Curl_smtp_escape_eob(struct connectdata *conn, const ssize_t nread)
1572 {
1573   /* When sending a SMTP payload we must detect CRLF. sequences making sure
1574      they are sent as CRLF.. instead, as a . on the beginning of a line will
1575      be deleted by the server when not part of an EOB terminator and a
1576      genuine CRLF.CRLF which isn't escaped will wrongly be detected as end of
1577      data by the server
1578   */
1579   ssize_t i;
1580   ssize_t si;
1581   struct SessionHandle *data = conn->data;
1582   struct SMTP *smtp = data->req.protop;
1583   char *scratch = data->state.scratch;
1584   char *newscratch = NULL;
1585   char *oldscratch = NULL;
1586   size_t eob_sent;
1587
1588   /* Do we need to allocate a scratch buffer? */
1589   if(!scratch || data->set.crlf) {
1590     oldscratch = scratch;
1591
1592     scratch = newscratch = malloc(2 * BUFSIZE);
1593     if(!newscratch) {
1594       failf(data, "Failed to alloc scratch buffer!");
1595
1596       return CURLE_OUT_OF_MEMORY;
1597     }
1598   }
1599
1600   /* Have we already sent part of the EOB? */
1601   eob_sent = smtp->eob;
1602
1603   /* This loop can be improved by some kind of Boyer-Moore style of
1604      approach but that is saved for later... */
1605   for(i = 0, si = 0; i < nread; i++) {
1606     if(SMTP_EOB[smtp->eob] == data->req.upload_fromhere[i]) {
1607       smtp->eob++;
1608
1609       /* Is the EOB potentially the terminating CRLF? */
1610       if(2 == smtp->eob || SMTP_EOB_LEN == smtp->eob)
1611         smtp->trailing_crlf = TRUE;
1612       else
1613         smtp->trailing_crlf = FALSE;
1614     }
1615     else if(smtp->eob) {
1616       /* A previous substring matched so output that first */
1617       memcpy(&scratch[si], &SMTP_EOB[eob_sent], smtp->eob - eob_sent);
1618       si += smtp->eob - eob_sent;
1619
1620       /* Then compare the first byte */
1621       if(SMTP_EOB[0] == data->req.upload_fromhere[i])
1622         smtp->eob = 1;
1623       else
1624         smtp->eob = 0;
1625
1626       eob_sent = 0;
1627
1628       /* Reset the trailing CRLF flag as there was more data */
1629       smtp->trailing_crlf = FALSE;
1630     }
1631
1632     /* Do we have a match for CRLF. as per RFC-5321, sect. 4.5.2 */
1633     if(SMTP_EOB_FIND_LEN == smtp->eob) {
1634       /* Copy the replacement data to the target buffer */
1635       memcpy(&scratch[si], &SMTP_EOB_REPL[eob_sent],
1636              SMTP_EOB_REPL_LEN - eob_sent);
1637       si += SMTP_EOB_REPL_LEN - eob_sent;
1638       smtp->eob = 0;
1639       eob_sent = 0;
1640     }
1641     else if(!smtp->eob)
1642       scratch[si++] = data->req.upload_fromhere[i];
1643   }
1644
1645   if(smtp->eob - eob_sent) {
1646     /* A substring matched before processing ended so output that now */
1647     memcpy(&scratch[si], &SMTP_EOB[eob_sent], smtp->eob - eob_sent);
1648     si += smtp->eob - eob_sent;
1649   }
1650
1651   /* Only use the new buffer if we replaced something */
1652   if(si != nread) {
1653     /* Upload from the new (replaced) buffer instead */
1654     data->req.upload_fromhere = scratch;
1655
1656     /* Save the buffer so it can be freed later */
1657     data->state.scratch = scratch;
1658
1659     /* Free the old scratch buffer */
1660     free(oldscratch);
1661
1662     /* Set the new amount too */
1663     data->req.upload_present = si;
1664   }
1665   else
1666     free(newscratch);
1667
1668   return CURLE_OK;
1669 }
1670
1671 #endif /* CURL_DISABLE_SMTP */