lib/pop3.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2016, 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.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  * RFC1734 POP3 Authentication
  22  * RFC1939 POP3 protocol
  23  * RFC2195 CRAM-MD5 authentication
  24  * RFC2384 POP URL Scheme
  25  * RFC2449 POP3 Extension Mechanism
  26  * RFC2595 Using TLS with IMAP, POP3 and ACAP
  27  * RFC2831 DIGEST-MD5 authentication
  28  * RFC4422 Simple Authentication and Security Layer (SASL)
  29  * RFC4616 PLAIN authentication
  30  * RFC4752 The Kerberos V5 ("GSSAPI") SASL Mechanism
  31  * RFC5034 POP3 SASL Authentication Mechanism
  32  * RFC6749 OAuth 2.0 Authorization Framework
  33  * Draft   LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
  34  *
  35  ***************************************************************************/
  36
  37 #include "curl_setup.h"
  38
  39 #ifndef CURL_DISABLE_POP3
  40
  41 #ifdef HAVE_NETINET_IN_H
  42 #include <netinet/in.h>
  43 #endif
  44 #ifdef HAVE_ARPA_INET_H
  45 #include <arpa/inet.h>
  46 #endif
  47 #ifdef HAVE_UTSNAME_H
  48 #include <sys/utsname.h>
  49 #endif
  50 #ifdef HAVE_NETDB_H
  51 #include <netdb.h>
  52 #endif
  53 #ifdef __VMS
  54 #include <in.h>
  55 #include <inet.h>
  56 #endif
  57
  58 #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
  59 #undef in_addr_t
  60 #define in_addr_t unsigned long
  61 #endif
  62
  63 #include <curl/curl.h>
  64 #include "urldata.h"
  65 #include "sendf.h"
  66 #include "hostip.h"
  67 #include "progress.h"
  68 #include "transfer.h"
  69 #include "escape.h"
  70 #include "http.h" /* for HTTP proxy tunnel stuff */
  71 #include "socks.h"
  72 #include "pop3.h"
  73
  74 #include "strtoofft.h"
  75 #include "strequal.h"
  76 #include "vtls/vtls.h"
  77 #include "connect.h"
  78 #include "strerror.h"
  79 #include "select.h"
  80 #include "multiif.h"
  81 #include "url.h"
  82 #include "rawstr.h"
  83 #include "curl_sasl.h"
  84 #include "curl_md5.h"
  85 #include "warnless.h"
  86 /* The last 3 #include files should be in this order */
  87 #include "curl_printf.h"
  88 #include "curl_memory.h"
  89 #include "memdebug.h"
  90
  91 /* Local API functions */
  92 static CURLcode pop3_regular_transfer(struct connectdata *conn, bool *done);
  93 static CURLcode pop3_do(struct connectdata *conn, bool *done);
  94 static CURLcode pop3_done(struct connectdata *conn, CURLcode status,
  95                           bool premature);
  96 static CURLcode pop3_connect(struct connectdata *conn, bool *done);
  97 static CURLcode pop3_disconnect(struct connectdata *conn, bool dead);
  98 static CURLcode pop3_multi_statemach(struct connectdata *conn, bool *done);
  99 static int pop3_getsock(struct connectdata *conn, curl_socket_t *socks,
 100                         int numsocks);
 101 static CURLcode pop3_doing(struct connectdata *conn, bool *dophase_done);
 102 static CURLcode pop3_setup_connection(struct connectdata *conn);
 103 static CURLcode pop3_parse_url_options(struct connectdata *conn);
 104 static CURLcode pop3_parse_url_path(struct connectdata *conn);
 105 static CURLcode pop3_parse_custom_request(struct connectdata *conn);
 106 static CURLcode pop3_perform_auth(struct connectdata *conn, const char *mech,
 107                                   const char *initresp);
 108 static CURLcode pop3_continue_auth(struct connectdata *conn, const char *resp);
 109 static void pop3_get_message(char *buffer, char** outptr);
 110
 111 /*
 112  * POP3 protocol handler.
 113  */
 114
 115 const struct Curl_handler Curl_handler_pop3 = {
 116   "POP3",                           /* scheme */
 117   pop3_setup_connection,            /* setup_connection */
 118   pop3_do,                          /* do_it */
 119   pop3_done,                        /* done */
 120   ZERO_NULL,                        /* do_more */
 121   pop3_connect,                     /* connect_it */
 122   pop3_multi_statemach,             /* connecting */
 123   pop3_doing,                       /* doing */
 124   pop3_getsock,                     /* proto_getsock */
 125   pop3_getsock,                     /* doing_getsock */
 126   ZERO_NULL,                        /* domore_getsock */
 127   ZERO_NULL,                        /* perform_getsock */
 128   pop3_disconnect,                  /* disconnect */
 129   ZERO_NULL,                        /* readwrite */
 130   PORT_POP3,                        /* defport */
 131   CURLPROTO_POP3,                   /* protocol */
 132   PROTOPT_CLOSEACTION | PROTOPT_NOURLQUERY /* flags */
 133 };
 134
 135 #ifdef USE_SSL
 136 /*
 137  * POP3S protocol handler.
 138  */
 139
 140 const struct Curl_handler Curl_handler_pop3s = {
 141   "POP3S",                          /* scheme */
 142   pop3_setup_connection,            /* setup_connection */
 143   pop3_do,                          /* do_it */
 144   pop3_done,                        /* done */
 145   ZERO_NULL,                        /* do_more */
 146   pop3_connect,                     /* connect_it */
 147   pop3_multi_statemach,             /* connecting */
 148   pop3_doing,                       /* doing */
 149   pop3_getsock,                     /* proto_getsock */
 150   pop3_getsock,                     /* doing_getsock */
 151   ZERO_NULL,                        /* domore_getsock */
 152   ZERO_NULL,                        /* perform_getsock */
 153   pop3_disconnect,                  /* disconnect */
 154   ZERO_NULL,                        /* readwrite */
 155   PORT_POP3S,                       /* defport */
 156   CURLPROTO_POP3S,                  /* protocol */
 157   PROTOPT_CLOSEACTION | PROTOPT_SSL
 158   | PROTOPT_NOURLQUERY              /* flags */
 159 };
 160 #endif
 161
 162 #ifndef CURL_DISABLE_HTTP
 163 /*
 164  * HTTP-proxyed POP3 protocol handler.
 165  */
 166
 167 static const struct Curl_handler Curl_handler_pop3_proxy = {
 168   "POP3",                               /* scheme */
 169   Curl_http_setup_conn,                 /* setup_connection */
 170   Curl_http,                            /* do_it */
 171   Curl_http_done,                       /* done */
 172   ZERO_NULL,                            /* do_more */
 173   ZERO_NULL,                            /* connect_it */
 174   ZERO_NULL,                            /* connecting */
 175   ZERO_NULL,                            /* doing */
 176   ZERO_NULL,                            /* proto_getsock */
 177   ZERO_NULL,                            /* doing_getsock */
 178   ZERO_NULL,                            /* domore_getsock */
 179   ZERO_NULL,                            /* perform_getsock */
 180   ZERO_NULL,                            /* disconnect */
 181   ZERO_NULL,                            /* readwrite */
 182   PORT_POP3,                            /* defport */
 183   CURLPROTO_HTTP,                       /* protocol */
 184   PROTOPT_NONE                          /* flags */
 185 };
 186
 187 #ifdef USE_SSL
 188 /*
 189  * HTTP-proxyed POP3S protocol handler.
 190  */
 191
 192 static const struct Curl_handler Curl_handler_pop3s_proxy = {
 193   "POP3S",                              /* scheme */
 194   Curl_http_setup_conn,                 /* setup_connection */
 195   Curl_http,                            /* do_it */
 196   Curl_http_done,                       /* done */
 197   ZERO_NULL,                            /* do_more */
 198   ZERO_NULL,                            /* connect_it */
 199   ZERO_NULL,                            /* connecting */
 200   ZERO_NULL,                            /* doing */
 201   ZERO_NULL,                            /* proto_getsock */
 202   ZERO_NULL,                            /* doing_getsock */
 203   ZERO_NULL,                            /* domore_getsock */
 204   ZERO_NULL,                            /* perform_getsock */
 205   ZERO_NULL,                            /* disconnect */
 206   ZERO_NULL,                            /* readwrite */
 207   PORT_POP3S,                           /* defport */
 208   CURLPROTO_HTTP,                       /* protocol */
 209   PROTOPT_NONE                          /* flags */
 210 };
 211 #endif
 212 #endif
 213
 214 /* SASL parameters for the pop3 protocol */
 215 static const struct SASLproto saslpop3 = {
 216   "pop",                      /* The service name */
 217   '*',                        /* Code received when continuation is expected */
 218   '+',                        /* Code to receive upon authentication success */
 219   255 - 8,                    /* Maximum initial response length (no max) */
 220   pop3_perform_auth,          /* Send authentication command */
 221   pop3_continue_auth,         /* Send authentication continuation */
 222   pop3_get_message            /* Get SASL response message */
 223 };
 224
 225 #ifdef USE_SSL
 226 static void pop3_to_pop3s(struct connectdata *conn)
 227 {
 228   /* Change the connection handler */
 229   conn->handler = &Curl_handler_pop3s;
 230
 231   /* Set the connection's upgraded to TLS flag */
 232   conn->tls_upgraded = TRUE;
 233 }
 234 #else
 235 #define pop3_to_pop3s(x) Curl_nop_stmt
 236 #endif
 237
 238 /***********************************************************************
 239  *
 240  * pop3_endofresp()
 241  *
 242  * Checks for an ending POP3 status code at the start of the given string, but
 243  * also detects the APOP timestamp from the server greeting and various
 244  * capabilities from the CAPA response including the supported authentication
 245  * types and allowed SASL mechanisms.
 246  */
 247 static bool pop3_endofresp(struct connectdata *conn, char *line, size_t len,
 248                            int *resp)
 249 {
 250   struct pop3_conn *pop3c = &conn->proto.pop3c;
 251
 252   /* Do we have an error response? */
 253   if(len >= 4 && !memcmp("-ERR", line, 4)) {
 254     *resp = '-';
 255
 256     return TRUE;
 257   }
 258
 259   /* Are we processing CAPA command responses? */
 260   if(pop3c->state == POP3_CAPA) {
 261     /* Do we have the terminating line? */
 262     if(len >= 1 && !memcmp(line, ".", 1))
 263       /* Treat the response as a success */
 264       *resp = '+';
 265     else
 266       /* Treat the response as an untagged continuation */
 267       *resp = '*';
 268
 269     return TRUE;
 270   }
 271
 272   /* Do we have a success response? */
 273   if(len >= 3 && !memcmp("+OK", line, 3)) {
 274     *resp = '+';
 275
 276     return TRUE;
 277   }
 278
 279   /* Do we have a continuation response? */
 280   if(len >= 1 && !memcmp("+", line, 1)) {
 281     *resp = '*';
 282
 283     return TRUE;
 284   }
 285
 286   return FALSE; /* Nothing for us */
 287 }
 288
 289 /***********************************************************************
 290  *
 291  * pop3_get_message()
 292  *
 293  * Gets the authentication message from the response buffer.
 294  */
 295 static void pop3_get_message(char *buffer, char** outptr)
 296 {
 297   size_t len = 0;
 298   char* message = NULL;
 299
 300   /* Find the start of the message */
 301   for(message = buffer + 2; *message == ' ' || *message == '\t'; message++)
 302     ;
 303
 304   /* Find the end of the message */
 305   for(len = strlen(message); len--;)
 306     if(message[len] != '\r' && message[len] != '\n' && message[len] != ' ' &&
 307         message[len] != '\t')
 308       break;
 309
 310   /* Terminate the message */
 311   if(++len) {
 312     message[len] = '\0';
 313   }
 314
 315   *outptr = message;
 316 }
 317
 318 /***********************************************************************
 319  *
 320  * state()
 321  *
 322  * This is the ONLY way to change POP3 state!
 323  */
 324 static void state(struct connectdata *conn, pop3state newstate)
 325 {
 326   struct pop3_conn *pop3c = &conn->proto.pop3c;
 327 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
 328   /* for debug purposes */
 329   static const char * const names[] = {
 330     "STOP",
 331     "SERVERGREET",
 332     "CAPA",
 333     "STARTTLS",
 334     "UPGRADETLS",
 335     "AUTH",
 336     "APOP",
 337     "USER",
 338     "PASS",
 339     "COMMAND",
 340     "QUIT",
 341     /* LAST */
 342   };
 343
 344   if(pop3c->state != newstate)
 345     infof(conn->data, "POP3 %p state change from %s to %s\n",
 346           (void *)pop3c, names[pop3c->state], names[newstate]);
 347 #endif
 348
 349   pop3c->state = newstate;
 350 }
 351
 352 /***********************************************************************
 353  *
 354  * pop3_perform_capa()
 355  *
 356  * Sends the CAPA command in order to obtain a list of server side supported
 357  * capabilities.
 358  */
 359 static CURLcode pop3_perform_capa(struct connectdata *conn)
 360 {
 361   CURLcode result = CURLE_OK;
 362   struct pop3_conn *pop3c = &conn->proto.pop3c;
 363
 364   pop3c->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanisms yet */
 365   pop3c->sasl.authused = SASL_AUTH_NONE;  /* Clear the auth. mechanism used */
 366   pop3c->tls_supported = FALSE;           /* Clear the TLS capability */
 367
 368   /* Send the CAPA command */
 369   result = Curl_pp_sendf(&pop3c->pp, "%s", "CAPA");
 370
 371   if(!result)
 372     state(conn, POP3_CAPA);
 373
 374   return result;
 375 }
 376
 377 /***********************************************************************
 378  *
 379  * pop3_perform_starttls()
 380  *
 381  * Sends the STLS command to start the upgrade to TLS.
 382  */
 383 static CURLcode pop3_perform_starttls(struct connectdata *conn)
 384 {
 385   CURLcode result = CURLE_OK;
 386
 387   /* Send the STLS command */
 388   result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "STLS");
 389
 390   if(!result)
 391     state(conn, POP3_STARTTLS);
 392
 393   return result;
 394 }
 395
 396 /***********************************************************************
 397  *
 398  * pop3_perform_upgrade_tls()
 399  *
 400  * Performs the upgrade to TLS.
 401  */
 402 static CURLcode pop3_perform_upgrade_tls(struct connectdata *conn)
 403 {
 404   CURLcode result = CURLE_OK;
 405   struct pop3_conn *pop3c = &conn->proto.pop3c;
 406
 407   /* Start the SSL connection */
 408   result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &pop3c->ssldone);
 409
 410   if(!result) {
 411     if(pop3c->state != POP3_UPGRADETLS)
 412       state(conn, POP3_UPGRADETLS);
 413
 414     if(pop3c->ssldone) {
 415       pop3_to_pop3s(conn);
 416       result = pop3_perform_capa(conn);
 417     }
 418   }
 419
 420   return result;
 421 }
 422
 423 /***********************************************************************
 424  *
 425  * pop3_perform_user()
 426  *
 427  * Sends a clear text USER command to authenticate with.
 428  */
 429 static CURLcode pop3_perform_user(struct connectdata *conn)
 430 {
 431   CURLcode result = CURLE_OK;
 432
 433   /* Check we have a username and password to authenticate with and end the
 434      connect phase if we don't */
 435   if(!conn->bits.user_passwd) {
 436     state(conn, POP3_STOP);
 437
 438     return result;
 439   }
 440
 441   /* Send the USER command */
 442   result = Curl_pp_sendf(&conn->proto.pop3c.pp, "USER %s",
 443                          conn->user ? conn->user : "");
 444   if(!result)
 445     state(conn, POP3_USER);
 446
 447   return result;
 448 }
 449
 450 #ifndef CURL_DISABLE_CRYPTO_AUTH
 451 /***********************************************************************
 452  *
 453  * pop3_perform_apop()
 454  *
 455  * Sends an APOP command to authenticate with.
 456  */
 457 static CURLcode pop3_perform_apop(struct connectdata *conn)
 458 {
 459   CURLcode result = CURLE_OK;
 460   struct pop3_conn *pop3c = &conn->proto.pop3c;
 461   size_t i;
 462   MD5_context *ctxt;
 463   unsigned char digest[MD5_DIGEST_LEN];
 464   char secret[2 * MD5_DIGEST_LEN + 1];
 465
 466   /* Check we have a username and password to authenticate with and end the
 467      connect phase if we don't */
 468   if(!conn->bits.user_passwd) {
 469     state(conn, POP3_STOP);
 470
 471     return result;
 472   }
 473
 474   /* Create the digest */
 475   ctxt = Curl_MD5_init(Curl_DIGEST_MD5);
 476   if(!ctxt)
 477     return CURLE_OUT_OF_MEMORY;
 478
 479   Curl_MD5_update(ctxt, (const unsigned char *) pop3c->apoptimestamp,
 480                   curlx_uztoui(strlen(pop3c->apoptimestamp)));
 481
 482   Curl_MD5_update(ctxt, (const unsigned char *) conn->passwd,
 483                   curlx_uztoui(strlen(conn->passwd)));
 484
 485   /* Finalise the digest */
 486   Curl_MD5_final(ctxt, digest);
 487
 488   /* Convert the calculated 16 octet digest into a 32 byte hex string */
 489   for(i = 0; i < MD5_DIGEST_LEN; i++)
 490     snprintf(&secret[2 * i], 3, "%02x", digest[i]);
 491
 492   result = Curl_pp_sendf(&pop3c->pp, "APOP %s %s", conn->user, secret);
 493
 494   if(!result)
 495     state(conn, POP3_APOP);
 496
 497   return result;
 498 }
 499 #endif
 500
 501 /***********************************************************************
 502  *
 503  * pop3_perform_auth()
 504  *
 505  * Sends an AUTH command allowing the client to login with the given SASL
 506  * authentication mechanism.
 507  */
 508 static CURLcode pop3_perform_auth(struct connectdata *conn,
 509                                   const char *mech,
 510                                   const char *initresp)
 511 {
 512   CURLcode result = CURLE_OK;
 513   struct pop3_conn *pop3c = &conn->proto.pop3c;
 514
 515   if(initresp) {                                  /* AUTH <mech> ...<crlf> */
 516     /* Send the AUTH command with the initial response */
 517     result = Curl_pp_sendf(&pop3c->pp, "AUTH %s %s", mech, initresp);
 518   }
 519   else {
 520     /* Send the AUTH command */
 521     result = Curl_pp_sendf(&pop3c->pp, "AUTH %s", mech);
 522   }
 523
 524   return result;
 525 }
 526
 527 /***********************************************************************
 528  *
 529  * pop3_continue_auth()
 530  *
 531  * Sends SASL continuation data or cancellation.
 532  */
 533 static CURLcode pop3_continue_auth(struct connectdata *conn,
 534                                    const char *resp)
 535 {
 536   struct pop3_conn *pop3c = &conn->proto.pop3c;
 537
 538   return Curl_pp_sendf(&pop3c->pp, "%s", resp);
 539 }
 540
 541 /***********************************************************************
 542  *
 543  * pop3_perform_authentication()
 544  *
 545  * Initiates the authentication sequence, with the appropriate SASL
 546  * authentication mechanism, falling back to APOP and clear text should a
 547  * common mechanism not be available between the client and server.
 548  */
 549 static CURLcode pop3_perform_authentication(struct connectdata *conn)
 550 {
 551   CURLcode result = CURLE_OK;
 552   struct pop3_conn *pop3c = &conn->proto.pop3c;
 553   saslprogress progress = SASL_IDLE;
 554
 555   /* Check we have enough data to authenticate with and end the
 556      connect phase if we don't */
 557   if(!Curl_sasl_can_authenticate(&pop3c->sasl, conn)) {
 558     state(conn, POP3_STOP);
 559     return result;
 560   }
 561
 562   if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_SASL) {
 563     /* Calculate the SASL login details */
 564     result = Curl_sasl_start(&pop3c->sasl, conn, FALSE, &progress);
 565
 566     if(!result)
 567       if(progress == SASL_INPROGRESS)
 568         state(conn, POP3_AUTH);
 569   }
 570
 571   if(!result && progress == SASL_IDLE) {
 572 #ifndef CURL_DISABLE_CRYPTO_AUTH
 573     if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_APOP)
 574       /* Perform APOP authentication */
 575       result = pop3_perform_apop(conn);
 576     else
 577 #endif
 578     if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_CLEARTEXT)
 579       /* Perform clear text authentication */
 580       result = pop3_perform_user(conn);
 581     else {
 582       /* Other mechanisms not supported */
 583       infof(conn->data, "No known authentication mechanisms supported!\n");
 584       result = CURLE_LOGIN_DENIED;
 585     }
 586   }
 587
 588   return result;
 589 }
 590
 591 /***********************************************************************
 592  *
 593  * pop3_perform_command()
 594  *
 595  * Sends a POP3 based command.
 596  */
 597 static CURLcode pop3_perform_command(struct connectdata *conn)
 598 {
 599   CURLcode result = CURLE_OK;
 600   struct Curl_easy *data = conn->data;
 601   struct POP3 *pop3 = data->req.protop;
 602   const char *command = NULL;
 603
 604   /* Calculate the default command */
 605   if(pop3->id[0] == '\0' || conn->data->set.ftp_list_only) {
 606     command = "LIST";
 607
 608     if(pop3->id[0] != '\0')
 609       /* Message specific LIST so skip the BODY transfer */
 610       pop3->transfer = FTPTRANSFER_INFO;
 611   }
 612   else
 613     command = "RETR";
 614
 615   /* Send the command */
 616   if(pop3->id[0] != '\0')
 617     result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s %s",
 618                            (pop3->custom && pop3->custom[0] != '\0' ?
 619                             pop3->custom : command), pop3->id);
 620   else
 621     result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s",
 622                            (pop3->custom && pop3->custom[0] != '\0' ?
 623                             pop3->custom : command));
 624
 625   if(!result)
 626     state(conn, POP3_COMMAND);
 627
 628   return result;
 629 }
 630
 631 /***********************************************************************
 632  *
 633  * pop3_perform_quit()
 634  *
 635  * Performs the quit action prior to sclose() be called.
 636  */
 637 static CURLcode pop3_perform_quit(struct connectdata *conn)
 638 {
 639   CURLcode result = CURLE_OK;
 640
 641   /* Send the QUIT command */
 642   result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "QUIT");
 643
 644   if(!result)
 645     state(conn, POP3_QUIT);
 646
 647   return result;
 648 }
 649
 650 /* For the initial server greeting */
 651 static CURLcode pop3_state_servergreet_resp(struct connectdata *conn,
 652                                             int pop3code,
 653                                             pop3state instate)
 654 {
 655   CURLcode result = CURLE_OK;
 656   struct Curl_easy *data = conn->data;
 657   struct pop3_conn *pop3c = &conn->proto.pop3c;
 658   const char *line = data->state.buffer;
 659   size_t len = strlen(line);
 660   size_t i;
 661
 662   (void)instate; /* no use for this yet */
 663
 664   if(pop3code != '+') {
 665     failf(data, "Got unexpected pop3-server response");
 666     result = CURLE_FTP_WEIRD_SERVER_REPLY;
 667   }
 668   else {
 669     /* Does the server support APOP authentication? */
 670     if(len >= 4 && line[len - 2] == '>') {
 671       /* Look for the APOP timestamp */
 672       for(i = 3; i < len - 2; ++i) {
 673         if(line[i] == '<') {
 674           /* Calculate the length of the timestamp */
 675           size_t timestamplen = len - 1 - i;
 676           if(!timestamplen)
 677             break;
 678
 679           /* Allocate some memory for the timestamp */
 680           pop3c->apoptimestamp = (char *)calloc(1, timestamplen + 1);
 681
 682           if(!pop3c->apoptimestamp)
 683             break;
 684
 685           /* Copy the timestamp */
 686           memcpy(pop3c->apoptimestamp, line + i, timestamplen);
 687           pop3c->apoptimestamp[timestamplen] = '\0';
 688
 689           /* Store the APOP capability */
 690           pop3c->authtypes |= POP3_TYPE_APOP;
 691           break;
 692         }
 693       }
 694     }
 695
 696     result = pop3_perform_capa(conn);
 697   }
 698
 699   return result;
 700 }
 701
 702 /* For CAPA responses */
 703 static CURLcode pop3_state_capa_resp(struct connectdata *conn, int pop3code,
 704                                      pop3state instate)
 705 {
 706   CURLcode result = CURLE_OK;
 707   struct Curl_easy *data = conn->data;
 708   struct pop3_conn *pop3c = &conn->proto.pop3c;
 709   const char *line = data->state.buffer;
 710   size_t len = strlen(line);
 711   size_t wordlen;
 712
 713   (void)instate; /* no use for this yet */
 714
 715   /* Do we have a untagged continuation response? */
 716   if(pop3code == '*') {
 717     /* Does the server support the STLS capability? */
 718     if(len >= 4 && !memcmp(line, "STLS", 4))
 719       pop3c->tls_supported = TRUE;
 720
 721     /* Does the server support clear text authentication? */
 722     else if(len >= 4 && !memcmp(line, "USER", 4))
 723       pop3c->authtypes |= POP3_TYPE_CLEARTEXT;
 724
 725     /* Does the server support SASL based authentication? */
 726     else if(len >= 5 && !memcmp(line, "SASL ", 5)) {
 727       pop3c->authtypes |= POP3_TYPE_SASL;
 728
 729       /* Advance past the SASL keyword */
 730       line += 5;
 731       len -= 5;
 732
 733       /* Loop through the data line */
 734       for(;;) {
 735         size_t llen;
 736         unsigned int mechbit;
 737
 738         while(len &&
 739               (*line == ' ' || *line == '\t' ||
 740                *line == '\r' || *line == '\n')) {
 741
 742           line++;
 743           len--;
 744         }
 745
 746         if(!len)
 747           break;
 748
 749         /* Extract the word */
 750         for(wordlen = 0; wordlen < len && line[wordlen] != ' ' &&
 751               line[wordlen] != '\t' && line[wordlen] != '\r' &&
 752               line[wordlen] != '\n';)
 753           wordlen++;
 754
 755         /* Test the word for a matching authentication mechanism */
 756         mechbit = Curl_sasl_decode_mech(line, wordlen, &llen);
 757         if(mechbit && llen == wordlen)
 758           pop3c->sasl.authmechs |= mechbit;
 759
 760         line += wordlen;
 761         len -= wordlen;
 762       }
 763     }
 764   }
 765   else if(pop3code == '+') {
 766     if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
 767       /* We don't have a SSL/TLS connection yet, but SSL is requested */
 768       if(pop3c->tls_supported)
 769         /* Switch to TLS connection now */
 770         result = pop3_perform_starttls(conn);
 771       else if(data->set.use_ssl == CURLUSESSL_TRY)
 772         /* Fallback and carry on with authentication */
 773         result = pop3_perform_authentication(conn);
 774       else {
 775         failf(data, "STLS not supported.");
 776         result = CURLE_USE_SSL_FAILED;
 777       }
 778     }
 779     else
 780       result = pop3_perform_authentication(conn);
 781   }
 782   else {
 783     /* Clear text is supported when CAPA isn't recognised */
 784     pop3c->authtypes |= POP3_TYPE_CLEARTEXT;
 785
 786     result = pop3_perform_authentication(conn);
 787   }
 788
 789   return result;
 790 }
 791
 792 /* For STARTTLS responses */
 793 static CURLcode pop3_state_starttls_resp(struct connectdata *conn,
 794                                          int pop3code,
 795                                          pop3state instate)
 796 {
 797   CURLcode result = CURLE_OK;
 798   struct Curl_easy *data = conn->data;
 799
 800   (void)instate; /* no use for this yet */
 801
 802   if(pop3code != '+') {
 803     if(data->set.use_ssl != CURLUSESSL_TRY) {
 804       failf(data, "STARTTLS denied. %c", pop3code);
 805       result = CURLE_USE_SSL_FAILED;
 806     }
 807     else
 808       result = pop3_perform_authentication(conn);
 809   }
 810   else
 811     result = pop3_perform_upgrade_tls(conn);
 812
 813   return result;
 814 }
 815
 816 /* For SASL authentication responses */
 817 static CURLcode pop3_state_auth_resp(struct connectdata *conn,
 818                                      int pop3code,
 819                                      pop3state instate)
 820 {
 821   CURLcode result = CURLE_OK;
 822   struct Curl_easy *data = conn->data;
 823   struct pop3_conn *pop3c = &conn->proto.pop3c;
 824   saslprogress progress;
 825
 826   (void)instate; /* no use for this yet */
 827
 828   result = Curl_sasl_continue(&pop3c->sasl, conn, pop3code, &progress);
 829   if(!result)
 830     switch(progress) {
 831     case SASL_DONE:
 832       state(conn, POP3_STOP);  /* Authenticated */
 833       break;
 834     case SASL_IDLE:            /* No mechanism left after cancellation */
 835 #ifndef CURL_DISABLE_CRYPTO_AUTH
 836       if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_APOP)
 837         /* Perform APOP authentication */
 838         result = pop3_perform_apop(conn);
 839       else
 840 #endif
 841       if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_CLEARTEXT)
 842         /* Perform clear text authentication */
 843         result = pop3_perform_user(conn);
 844       else {
 845         failf(data, "Authentication cancelled");
 846         result = CURLE_LOGIN_DENIED;
 847       }
 848       break;
 849     default:
 850       break;
 851     }
 852
 853   return result;
 854 }
 855
 856 #ifndef CURL_DISABLE_CRYPTO_AUTH
 857 /* For APOP responses */
 858 static CURLcode pop3_state_apop_resp(struct connectdata *conn, int pop3code,
 859                                      pop3state instate)
 860 {
 861   CURLcode result = CURLE_OK;
 862   struct Curl_easy *data = conn->data;
 863
 864   (void)instate; /* no use for this yet */
 865
 866   if(pop3code != '+') {
 867     failf(data, "Authentication failed: %d", pop3code);
 868     result = CURLE_LOGIN_DENIED;
 869   }
 870   else
 871     /* End of connect phase */
 872     state(conn, POP3_STOP);
 873
 874   return result;
 875 }
 876 #endif
 877
 878 /* For USER responses */
 879 static CURLcode pop3_state_user_resp(struct connectdata *conn, int pop3code,
 880                                      pop3state instate)
 881 {
 882   CURLcode result = CURLE_OK;
 883   struct Curl_easy *data = conn->data;
 884
 885   (void)instate; /* no use for this yet */
 886
 887   if(pop3code != '+') {
 888     failf(data, "Access denied. %c", pop3code);
 889     result = CURLE_LOGIN_DENIED;
 890   }
 891   else
 892     /* Send the PASS command */
 893     result = Curl_pp_sendf(&conn->proto.pop3c.pp, "PASS %s",
 894                            conn->passwd ? conn->passwd : "");
 895   if(!result)
 896     state(conn, POP3_PASS);
 897
 898   return result;
 899 }
 900
 901 /* For PASS responses */
 902 static CURLcode pop3_state_pass_resp(struct connectdata *conn, int pop3code,
 903                                      pop3state instate)
 904 {
 905   CURLcode result = CURLE_OK;
 906   struct Curl_easy *data = conn->data;
 907
 908   (void)instate; /* no use for this yet */
 909
 910   if(pop3code != '+') {
 911     failf(data, "Access denied. %c", pop3code);
 912     result = CURLE_LOGIN_DENIED;
 913   }
 914   else
 915     /* End of connect phase */
 916     state(conn, POP3_STOP);
 917
 918   return result;
 919 }
 920
 921 /* For command responses */
 922 static CURLcode pop3_state_command_resp(struct connectdata *conn,
 923                                         int pop3code,
 924                                         pop3state instate)
 925 {
 926   CURLcode result = CURLE_OK;
 927   struct Curl_easy *data = conn->data;
 928   struct POP3 *pop3 = data->req.protop;
 929   struct pop3_conn *pop3c = &conn->proto.pop3c;
 930   struct pingpong *pp = &pop3c->pp;
 931
 932   (void)instate; /* no use for this yet */
 933
 934   if(pop3code != '+') {
 935     state(conn, POP3_STOP);
 936     return CURLE_RECV_ERROR;
 937   }
 938
 939   /* This 'OK' line ends with a CR LF pair which is the two first bytes of the
 940      EOB string so count this is two matching bytes. This is necessary to make
 941      the code detect the EOB if the only data than comes now is %2e CR LF like
 942      when there is no body to return. */
 943   pop3c->eob = 2;
 944
 945   /* But since this initial CR LF pair is not part of the actual body, we set
 946      the strip counter here so that these bytes won't be delivered. */
 947   pop3c->strip = 2;
 948
 949   if(pop3->transfer == FTPTRANSFER_BODY) {
 950     /* POP3 download */
 951     Curl_setup_transfer(conn, FIRSTSOCKET, -1, FALSE, NULL, -1, NULL);
 952
 953     if(pp->cache) {
 954       /* The header "cache" contains a bunch of data that is actually body
 955          content so send it as such. Note that there may even be additional
 956          "headers" after the body */
 957
 958       if(!data->set.opt_no_body) {
 959         result = Curl_pop3_write(conn, pp->cache, pp->cache_size);
 960         if(result)
 961           return result;
 962       }
 963
 964       /* Free the cache */
 965       Curl_safefree(pp->cache);
 966
 967       /* Reset the cache size */
 968       pp->cache_size = 0;
 969     }
 970   }
 971
 972   /* End of DO phase */
 973   state(conn, POP3_STOP);
 974
 975   return result;
 976 }
 977
 978 static CURLcode pop3_statemach_act(struct connectdata *conn)
 979 {
 980   CURLcode result = CURLE_OK;
 981   curl_socket_t sock = conn->sock[FIRSTSOCKET];
 982   int pop3code;
 983   struct pop3_conn *pop3c = &conn->proto.pop3c;
 984   struct pingpong *pp = &pop3c->pp;
 985   size_t nread = 0;
 986
 987   /* Busy upgrading the connection; right now all I/O is SSL/TLS, not POP3 */
 988   if(pop3c->state == POP3_UPGRADETLS)
 989     return pop3_perform_upgrade_tls(conn);
 990
 991   /* Flush any data that needs to be sent */
 992   if(pp->sendleft)
 993     return Curl_pp_flushsend(pp);
 994
 995  do {
 996     /* Read the response from the server */
 997     result = Curl_pp_readresp(sock, pp, &pop3code, &nread);
 998     if(result)
 999       return result;
1000
1001     if(!pop3code)
1002       break;
1003
1004     /* We have now received a full POP3 server response */
1005     switch(pop3c->state) {
1006     case POP3_SERVERGREET:
1007       result = pop3_state_servergreet_resp(conn, pop3code, pop3c->state);
1008       break;
1009
1010     case POP3_CAPA:
1011       result = pop3_state_capa_resp(conn, pop3code, pop3c->state);
1012       break;
1013
1014     case POP3_STARTTLS:
1015       result = pop3_state_starttls_resp(conn, pop3code, pop3c->state);
1016       break;
1017
1018     case POP3_AUTH:
1019       result = pop3_state_auth_resp(conn, pop3code, pop3c->state);
1020       break;
1021
1022 #ifndef CURL_DISABLE_CRYPTO_AUTH
1023     case POP3_APOP:
1024       result = pop3_state_apop_resp(conn, pop3code, pop3c->state);
1025       break;
1026 #endif
1027
1028     case POP3_USER:
1029       result = pop3_state_user_resp(conn, pop3code, pop3c->state);
1030       break;
1031
1032     case POP3_PASS:
1033       result = pop3_state_pass_resp(conn, pop3code, pop3c->state);
1034       break;
1035
1036     case POP3_COMMAND:
1037       result = pop3_state_command_resp(conn, pop3code, pop3c->state);
1038       break;
1039
1040     case POP3_QUIT:
1041       /* fallthrough, just stop! */
1042     default:
1043       /* internal error */
1044       state(conn, POP3_STOP);
1045       break;
1046     }
1047   } while(!result && pop3c->state != POP3_STOP && Curl_pp_moredata(pp));
1048
1049   return result;
1050 }
1051
1052 /* Called repeatedly until done from multi.c */
1053 static CURLcode pop3_multi_statemach(struct connectdata *conn, bool *done)
1054 {
1055   CURLcode result = CURLE_OK;
1056   struct pop3_conn *pop3c = &conn->proto.pop3c;
1057
1058   if((conn->handler->flags & PROTOPT_SSL) && !pop3c->ssldone) {
1059     result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &pop3c->ssldone);
1060     if(result || !pop3c->ssldone)
1061       return result;
1062   }
1063
1064   result = Curl_pp_statemach(&pop3c->pp, FALSE);
1065   *done = (pop3c->state == POP3_STOP) ? TRUE : FALSE;
1066
1067   return result;
1068 }
1069
1070 static CURLcode pop3_block_statemach(struct connectdata *conn)
1071 {
1072   CURLcode result = CURLE_OK;
1073   struct pop3_conn *pop3c = &conn->proto.pop3c;
1074
1075   while(pop3c->state != POP3_STOP && !result)
1076     result = Curl_pp_statemach(&pop3c->pp, TRUE);
1077
1078   return result;
1079 }
1080
1081 /* Allocate and initialize the POP3 struct for the current Curl_easy if
1082    required */
1083 static CURLcode pop3_init(struct connectdata *conn)
1084 {
1085   CURLcode result = CURLE_OK;
1086   struct Curl_easy *data = conn->data;
1087   struct POP3 *pop3;
1088
1089   pop3 = data->req.protop = calloc(sizeof(struct POP3), 1);
1090   if(!pop3)
1091     result = CURLE_OUT_OF_MEMORY;
1092
1093   return result;
1094 }
1095
1096 /* For the POP3 "protocol connect" and "doing" phases only */
1097 static int pop3_getsock(struct connectdata *conn, curl_socket_t *socks,
1098                         int numsocks)
1099 {
1100   return Curl_pp_getsock(&conn->proto.pop3c.pp, socks, numsocks);
1101 }
1102
1103 /***********************************************************************
1104  *
1105  * pop3_connect()
1106  *
1107  * This function should do everything that is to be considered a part of the
1108  * connection phase.
1109  *
1110  * The variable 'done' points to will be TRUE if the protocol-layer connect
1111  * phase is done when this function returns, or FALSE if not.
1112  */
1113 static CURLcode pop3_connect(struct connectdata *conn, bool *done)
1114 {
1115   CURLcode result = CURLE_OK;
1116   struct pop3_conn *pop3c = &conn->proto.pop3c;
1117   struct pingpong *pp = &pop3c->pp;
1118
1119   *done = FALSE; /* default to not done yet */
1120
1121   /* We always support persistent connections in POP3 */
1122   connkeep(conn, "POP3 default");
1123
1124   /* Set the default response time-out */
1125   pp->response_time = RESP_TIMEOUT;
1126   pp->statemach_act = pop3_statemach_act;
1127   pp->endofresp = pop3_endofresp;
1128   pp->conn = conn;
1129
1130   /* Set the default preferred authentication type and mechanism */
1131   pop3c->preftype = POP3_TYPE_ANY;
1132   Curl_sasl_init(&pop3c->sasl, &saslpop3);
1133
1134   /* Initialise the pingpong layer */
1135   Curl_pp_init(pp);
1136
1137   /* Parse the URL options */
1138   result = pop3_parse_url_options(conn);
1139   if(result)
1140     return result;
1141
1142   /* Start off waiting for the server greeting response */
1143   state(conn, POP3_SERVERGREET);
1144
1145   result = pop3_multi_statemach(conn, done);
1146
1147   return result;
1148 }
1149
1150 /***********************************************************************
1151  *
1152  * pop3_done()
1153  *
1154  * The DONE function. This does what needs to be done after a single DO has
1155  * performed.
1156  *
1157  * Input argument is already checked for validity.
1158  */
1159 static CURLcode pop3_done(struct connectdata *conn, CURLcode status,
1160                           bool premature)
1161 {
1162   CURLcode result = CURLE_OK;
1163   struct Curl_easy *data = conn->data;
1164   struct POP3 *pop3 = data->req.protop;
1165
1166   (void)premature;
1167
1168   if(!pop3)
1169     return CURLE_OK;
1170
1171   if(status) {
1172     connclose(conn, "POP3 done with bad status");
1173     result = status;         /* use the already set error code */
1174   }
1175
1176   /* Cleanup our per-request based variables */
1177   Curl_safefree(pop3->id);
1178   Curl_safefree(pop3->custom);
1179
1180   /* Clear the transfer mode for the next request */
1181   pop3->transfer = FTPTRANSFER_BODY;
1182
1183   return result;
1184 }
1185
1186 /***********************************************************************
1187  *
1188  * pop3_perform()
1189  *
1190  * This is the actual DO function for POP3. Get a message/listing according to
1191  * the options previously setup.
1192  */
1193 static CURLcode pop3_perform(struct connectdata *conn, bool *connected,
1194                              bool *dophase_done)
1195 {
1196   /* This is POP3 and no proxy */
1197   CURLcode result = CURLE_OK;
1198   struct POP3 *pop3 = conn->data->req.protop;
1199
1200   DEBUGF(infof(conn->data, "DO phase starts\n"));
1201
1202   if(conn->data->set.opt_no_body) {
1203     /* Requested no body means no transfer */
1204     pop3->transfer = FTPTRANSFER_INFO;
1205   }
1206
1207   *dophase_done = FALSE; /* not done yet */
1208
1209   /* Start the first command in the DO phase */
1210   result = pop3_perform_command(conn);
1211   if(result)
1212     return result;
1213
1214   /* Run the state-machine */
1215   result = pop3_multi_statemach(conn, dophase_done);
1216
1217   *connected = conn->bits.tcpconnect[FIRSTSOCKET];
1218
1219   if(*dophase_done)
1220     DEBUGF(infof(conn->data, "DO phase is complete\n"));
1221
1222   return result;
1223 }
1224
1225 /***********************************************************************
1226  *
1227  * pop3_do()
1228  *
1229  * This function is registered as 'curl_do' function. It decodes the path
1230  * parts etc as a wrapper to the actual DO function (pop3_perform).
1231  *
1232  * The input argument is already checked for validity.
1233  */
1234 static CURLcode pop3_do(struct connectdata *conn, bool *done)
1235 {
1236   CURLcode result = CURLE_OK;
1237
1238   *done = FALSE; /* default to false */
1239
1240   /* Parse the URL path */
1241   result = pop3_parse_url_path(conn);
1242   if(result)
1243     return result;
1244
1245   /* Parse the custom request */
1246   result = pop3_parse_custom_request(conn);
1247   if(result)
1248     return result;
1249
1250   result = pop3_regular_transfer(conn, done);
1251
1252   return result;
1253 }
1254
1255 /***********************************************************************
1256  *
1257  * pop3_disconnect()
1258  *
1259  * Disconnect from an POP3 server. Cleanup protocol-specific per-connection
1260  * resources. BLOCKING.
1261  */
1262 static CURLcode pop3_disconnect(struct connectdata *conn, bool dead_connection)
1263 {
1264   struct pop3_conn *pop3c = &conn->proto.pop3c;
1265
1266   /* We cannot send quit unconditionally. If this connection is stale or
1267      bad in any way, sending quit and waiting around here will make the
1268      disconnect wait in vain and cause more problems than we need to. */
1269
1270   /* The POP3 session may or may not have been allocated/setup at this
1271      point! */
1272   if(!dead_connection && pop3c->pp.conn && pop3c->pp.conn->bits.protoconnstart)
1273     if(!pop3_perform_quit(conn))
1274       (void)pop3_block_statemach(conn); /* ignore errors on QUIT */
1275
1276   /* Disconnect from the server */
1277   Curl_pp_disconnect(&pop3c->pp);
1278
1279   /* Cleanup the SASL module */
1280   Curl_sasl_cleanup(conn, pop3c->sasl.authused);
1281
1282   /* Cleanup our connection based variables */
1283   Curl_safefree(pop3c->apoptimestamp);
1284
1285   return CURLE_OK;
1286 }
1287
1288 /* Call this when the DO phase has completed */
1289 static CURLcode pop3_dophase_done(struct connectdata *conn, bool connected)
1290 {
1291   (void)conn;
1292   (void)connected;
1293
1294   return CURLE_OK;
1295 }
1296
1297 /* Called from multi.c while DOing */
1298 static CURLcode pop3_doing(struct connectdata *conn, bool *dophase_done)
1299 {
1300   CURLcode result = pop3_multi_statemach(conn, dophase_done);
1301
1302   if(result)
1303     DEBUGF(infof(conn->data, "DO phase failed\n"));
1304   else if(*dophase_done) {
1305     result = pop3_dophase_done(conn, FALSE /* not connected */);
1306
1307     DEBUGF(infof(conn->data, "DO phase is complete\n"));
1308   }
1309
1310   return result;
1311 }
1312
1313 /***********************************************************************
1314  *
1315  * pop3_regular_transfer()
1316  *
1317  * The input argument is already checked for validity.
1318  *
1319  * Performs all commands done before a regular transfer between a local and a
1320  * remote host.
1321  */
1322 static CURLcode pop3_regular_transfer(struct connectdata *conn,
1323                                       bool *dophase_done)
1324 {
1325   CURLcode result = CURLE_OK;
1326   bool connected = FALSE;
1327   struct Curl_easy *data = conn->data;
1328
1329   /* Make sure size is unknown at this point */
1330   data->req.size = -1;
1331
1332   /* Set the progress data */
1333   Curl_pgrsSetUploadCounter(data, 0);
1334   Curl_pgrsSetDownloadCounter(data, 0);
1335   Curl_pgrsSetUploadSize(data, -1);
1336   Curl_pgrsSetDownloadSize(data, -1);
1337
1338   /* Carry out the perform */
1339   result = pop3_perform(conn, &connected, dophase_done);
1340
1341   /* Perform post DO phase operations if necessary */
1342   if(!result && *dophase_done)
1343     result = pop3_dophase_done(conn, connected);
1344
1345   return result;
1346 }
1347
1348 static CURLcode pop3_setup_connection(struct connectdata *conn)
1349 {
1350   struct Curl_easy *data = conn->data;
1351
1352   /* Initialise the POP3 layer */
1353   CURLcode result = pop3_init(conn);
1354   if(result)
1355     return result;
1356
1357   /* Clear the TLS upgraded flag */
1358   conn->tls_upgraded = FALSE;
1359
1360   /* Set up the proxy if necessary */
1361   if(conn->bits.httpproxy && !data->set.tunnel_thru_httpproxy) {
1362     /* Unless we have asked to tunnel POP3 operations through the proxy, we
1363        switch and use HTTP operations only */
1364 #ifndef CURL_DISABLE_HTTP
1365     if(conn->handler == &Curl_handler_pop3)
1366       conn->handler = &Curl_handler_pop3_proxy;
1367     else {
1368 #ifdef USE_SSL
1369       conn->handler = &Curl_handler_pop3s_proxy;
1370 #else
1371       failf(data, "POP3S not supported!");
1372       return CURLE_UNSUPPORTED_PROTOCOL;
1373 #endif
1374     }
1375
1376     /* set it up as an HTTP connection instead */
1377     return conn->handler->setup_connection(conn);
1378 #else
1379     failf(data, "POP3 over http proxy requires HTTP support built-in!");
1380     return CURLE_UNSUPPORTED_PROTOCOL;
1381 #endif
1382   }
1383
1384   data->state.path++;   /* don't include the initial slash */
1385
1386   return CURLE_OK;
1387 }
1388
1389 /***********************************************************************
1390  *
1391  * pop3_parse_url_options()
1392  *
1393  * Parse the URL login options.
1394  */
1395 static CURLcode pop3_parse_url_options(struct connectdata *conn)
1396 {
1397   CURLcode result = CURLE_OK;
1398   struct pop3_conn *pop3c = &conn->proto.pop3c;
1399   const char *ptr = conn->options;
1400
1401   pop3c->sasl.resetprefs = TRUE;
1402
1403   while(!result && ptr && *ptr) {
1404     const char *key = ptr;
1405     const char *value;
1406
1407     while(*ptr && *ptr != '=')
1408         ptr++;
1409
1410     value = ptr + 1;
1411
1412     while(*ptr && *ptr != ';')
1413       ptr++;
1414
1415     if(strnequal(key, "AUTH=", 5)) {
1416       result = Curl_sasl_parse_url_auth_option(&pop3c->sasl,
1417                                                value, ptr - value);
1418
1419       if(result && strnequal(value, "+APOP", ptr - value)) {
1420         pop3c->preftype = POP3_TYPE_APOP;
1421         pop3c->sasl.prefmech = SASL_AUTH_NONE;
1422         result = CURLE_OK;
1423       }
1424     }
1425     else
1426       result = CURLE_URL_MALFORMAT;
1427
1428     if(*ptr == ';')
1429       ptr++;
1430   }
1431
1432   if(pop3c->preftype != POP3_TYPE_APOP)
1433     switch(pop3c->sasl.prefmech) {
1434     case SASL_AUTH_NONE:
1435       pop3c->preftype = POP3_TYPE_NONE;
1436       break;
1437     case SASL_AUTH_DEFAULT:
1438       pop3c->preftype = POP3_TYPE_ANY;
1439       break;
1440     default:
1441       pop3c->preftype = POP3_TYPE_SASL;
1442       break;
1443     }
1444
1445   return result;
1446 }
1447
1448 /***********************************************************************
1449  *
1450  * pop3_parse_url_path()
1451  *
1452  * Parse the URL path into separate path components.
1453  */
1454 static CURLcode pop3_parse_url_path(struct connectdata *conn)
1455 {
1456   /* The POP3 struct is already initialised in pop3_connect() */
1457   struct Curl_easy *data = conn->data;
1458   struct POP3 *pop3 = data->req.protop;
1459   const char *path = data->state.path;
1460
1461   /* URL decode the path for the message ID */
1462   return Curl_urldecode(data, path, 0, &pop3->id, NULL, TRUE);
1463 }
1464
1465 /***********************************************************************
1466  *
1467  * pop3_parse_custom_request()
1468  *
1469  * Parse the custom request.
1470  */
1471 static CURLcode pop3_parse_custom_request(struct connectdata *conn)
1472 {
1473   CURLcode result = CURLE_OK;
1474   struct Curl_easy *data = conn->data;
1475   struct POP3 *pop3 = data->req.protop;
1476   const char *custom = data->set.str[STRING_CUSTOMREQUEST];
1477
1478   /* URL decode the custom request */
1479   if(custom)
1480     result = Curl_urldecode(data, custom, 0, &pop3->custom, NULL, TRUE);
1481
1482   return result;
1483 }
1484
1485 /***********************************************************************
1486  *
1487  * Curl_pop3_write()
1488  *
1489  * This function scans the body after the end-of-body and writes everything
1490  * until the end is found.
1491  */
1492 CURLcode Curl_pop3_write(struct connectdata *conn, char *str, size_t nread)
1493 {
1494   /* This code could be made into a special function in the handler struct */
1495   CURLcode result = CURLE_OK;
1496   struct Curl_easy *data = conn->data;
1497   struct SingleRequest *k = &data->req;
1498
1499   struct pop3_conn *pop3c = &conn->proto.pop3c;
1500   bool strip_dot = FALSE;
1501   size_t last = 0;
1502   size_t i;
1503
1504   /* Search through the buffer looking for the end-of-body marker which is
1505      5 bytes (0d 0a 2e 0d 0a). Note that a line starting with a dot matches
1506      the eob so the server will have prefixed it with an extra dot which we
1507      need to strip out. Additionally the marker could of course be spread out
1508      over 5 different data chunks. */
1509   for(i = 0; i < nread; i++) {
1510     size_t prev = pop3c->eob;
1511
1512     switch(str[i]) {
1513     case 0x0d:
1514       if(pop3c->eob == 0) {
1515         pop3c->eob++;
1516
1517         if(i) {
1518           /* Write out the body part that didn't match */
1519           result = Curl_client_write(conn, CLIENTWRITE_BODY, &str[last],
1520                                      i - last);
1521
1522           if(result)
1523             return result;
1524
1525           last = i;
1526         }
1527       }
1528       else if(pop3c->eob == 3)
1529         pop3c->eob++;
1530       else
1531         /* If the character match wasn't at position 0 or 3 then restart the
1532            pattern matching */
1533         pop3c->eob = 1;
1534       break;
1535
1536     case 0x0a:
1537       if(pop3c->eob == 1 || pop3c->eob == 4)
1538         pop3c->eob++;
1539       else
1540         /* If the character match wasn't at position 1 or 4 then start the
1541            search again */
1542         pop3c->eob = 0;
1543       break;
1544
1545     case 0x2e:
1546       if(pop3c->eob == 2)
1547         pop3c->eob++;
1548       else if(pop3c->eob == 3) {
1549         /* We have an extra dot after the CRLF which we need to strip off */
1550         strip_dot = TRUE;
1551         pop3c->eob = 0;
1552       }
1553       else
1554         /* If the character match wasn't at position 2 then start the search
1555            again */
1556         pop3c->eob = 0;
1557       break;
1558
1559     default:
1560       pop3c->eob = 0;
1561       break;
1562     }
1563
1564     /* Did we have a partial match which has subsequently failed? */
1565     if(prev && prev >= pop3c->eob) {
1566       /* Strip can only be non-zero for the very first mismatch after CRLF
1567          and then both prev and strip are equal and nothing will be output
1568          below */
1569       while(prev && pop3c->strip) {
1570         prev--;
1571         pop3c->strip--;
1572       }
1573
1574       if(prev) {
1575         /* If the partial match was the CRLF and dot then only write the CRLF
1576            as the server would have inserted the dot */
1577         result = Curl_client_write(conn, CLIENTWRITE_BODY, (char*)POP3_EOB,
1578                                    strip_dot ? prev - 1 : prev);
1579
1580         if(result)
1581           return result;
1582
1583         last = i;
1584         strip_dot = FALSE;
1585       }
1586     }
1587   }
1588
1589   if(pop3c->eob == POP3_EOB_LEN) {
1590     /* We have a full match so the transfer is done, however we must transfer
1591     the CRLF at the start of the EOB as this is considered to be part of the
1592     message as per RFC-1939, sect. 3 */
1593     result = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)POP3_EOB, 2);
1594
1595     k->keepon &= ~KEEP_RECV;
1596     pop3c->eob = 0;
1597
1598     return result;
1599   }
1600
1601   if(pop3c->eob)
1602     /* While EOB is matching nothing should be output */
1603     return CURLE_OK;
1604
1605   if(nread - last) {
1606     result = Curl_client_write(conn, CLIENTWRITE_BODY, &str[last],
1607                                nread - last);
1608   }
1609
1610   return result;
1611 }
1612
1613 #endif /* CURL_DISABLE_POP3 */