2009-12-13 00:54:01 +03:00
|
|
|
/***************************************************************************
|
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2019-01-20 23:59:04 +03:00
|
|
|
* Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
|
2009-12-13 00:54:01 +03:00
|
|
|
*
|
|
|
|
* This software is licensed as described in the file COPYING, which
|
|
|
|
* you should have received as part of this distribution. The terms
|
2016-02-03 02:19:02 +03:00
|
|
|
* are also available at https://curl.haxx.se/docs/copyright.html.
|
2009-12-13 00:54:01 +03:00
|
|
|
*
|
|
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
|
|
* copies of the Software, and permit persons to whom the Software is
|
|
|
|
* furnished to do so, under the terms of the COPYING file.
|
|
|
|
*
|
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
|
|
|
*
|
2012-05-31 23:45:53 +04:00
|
|
|
* RFC1734 POP3 Authentication
|
2009-12-13 00:54:01 +03:00
|
|
|
* RFC1939 POP3 protocol
|
2012-06-03 22:13:16 +04:00
|
|
|
* RFC2195 CRAM-MD5 authentication
|
2009-12-13 00:54:01 +03:00
|
|
|
* RFC2384 POP URL Scheme
|
2012-06-09 14:48:44 +04:00
|
|
|
* RFC2449 POP3 Extension Mechanism
|
2009-12-13 00:54:01 +03:00
|
|
|
* RFC2595 Using TLS with IMAP, POP3 and ACAP
|
2012-06-05 00:50:16 +04:00
|
|
|
* RFC2831 DIGEST-MD5 authentication
|
2013-01-22 22:37:12 +04:00
|
|
|
* RFC4422 Simple Authentication and Security Layer (SASL)
|
2012-05-31 23:45:53 +04:00
|
|
|
* RFC4616 PLAIN authentication
|
2014-08-10 02:38:08 +04:00
|
|
|
* RFC4752 The Kerberos V5 ("GSSAPI") SASL Mechanism
|
2013-02-16 14:18:01 +04:00
|
|
|
* RFC5034 POP3 SASL Authentication Mechanism
|
2013-09-21 00:56:34 +04:00
|
|
|
* RFC6749 OAuth 2.0 Authorization Framework
|
2019-04-11 03:19:15 +03:00
|
|
|
* RFC8314 Use of TLS for Email Submission and Access
|
2013-10-26 17:35:27 +04:00
|
|
|
* Draft LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
|
2009-12-13 00:54:01 +03:00
|
|
|
*
|
|
|
|
***************************************************************************/
|
|
|
|
|
2013-01-06 22:06:49 +04:00
|
|
|
#include "curl_setup.h"
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
#ifndef CURL_DISABLE_POP3
|
|
|
|
|
|
|
|
#ifdef HAVE_NETINET_IN_H
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ARPA_INET_H
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_UTSNAME_H
|
|
|
|
#include <sys/utsname.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_NETDB_H
|
|
|
|
#include <netdb.h>
|
|
|
|
#endif
|
2009-12-30 20:59:56 +03:00
|
|
|
#ifdef __VMS
|
2009-12-13 00:54:01 +03:00
|
|
|
#include <in.h>
|
|
|
|
#include <inet.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (defined(NETWARE) && defined(__NOVELL_LIBC__))
|
|
|
|
#undef in_addr_t
|
|
|
|
#define in_addr_t unsigned long
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <curl/curl.h>
|
2013-01-04 05:50:28 +04:00
|
|
|
#include "urldata.h"
|
|
|
|
#include "sendf.h"
|
|
|
|
#include "hostip.h"
|
|
|
|
#include "progress.h"
|
|
|
|
#include "transfer.h"
|
|
|
|
#include "escape.h"
|
|
|
|
#include "http.h" /* for HTTP proxy tunnel stuff */
|
|
|
|
#include "socks.h"
|
|
|
|
#include "pop3.h"
|
|
|
|
#include "strtoofft.h"
|
2016-09-30 18:15:05 +03:00
|
|
|
#include "strcase.h"
|
2013-12-18 02:32:47 +04:00
|
|
|
#include "vtls/vtls.h"
|
2013-01-04 05:50:28 +04:00
|
|
|
#include "connect.h"
|
|
|
|
#include "strerror.h"
|
|
|
|
#include "select.h"
|
|
|
|
#include "multiif.h"
|
|
|
|
#include "url.h"
|
2012-05-27 22:09:38 +04:00
|
|
|
#include "curl_sasl.h"
|
2012-06-09 16:49:37 +04:00
|
|
|
#include "curl_md5.h"
|
2013-01-04 05:50:28 +04:00
|
|
|
#include "warnless.h"
|
2016-04-29 16:46:40 +03:00
|
|
|
/* The last 3 #include files should be in this order */
|
2015-03-03 14:36:18 +03:00
|
|
|
#include "curl_printf.h"
|
2009-12-13 00:54:01 +03:00
|
|
|
#include "curl_memory.h"
|
2013-01-04 05:50:28 +04:00
|
|
|
#include "memdebug.h"
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
/* Local API functions */
|
|
|
|
static CURLcode pop3_regular_transfer(struct connectdata *conn, bool *done);
|
|
|
|
static CURLcode pop3_do(struct connectdata *conn, bool *done);
|
2012-12-29 00:30:04 +04:00
|
|
|
static CURLcode pop3_done(struct connectdata *conn, CURLcode status,
|
|
|
|
bool premature);
|
2009-12-13 00:54:01 +03:00
|
|
|
static CURLcode pop3_connect(struct connectdata *conn, bool *done);
|
2011-04-20 17:17:42 +04:00
|
|
|
static CURLcode pop3_disconnect(struct connectdata *conn, bool dead);
|
2009-12-13 00:54:01 +03:00
|
|
|
static CURLcode pop3_multi_statemach(struct connectdata *conn, bool *done);
|
2013-01-19 13:49:17 +04:00
|
|
|
static int pop3_getsock(struct connectdata *conn, curl_socket_t *socks,
|
2009-12-13 00:54:01 +03:00
|
|
|
int numsocks);
|
2012-12-29 00:30:04 +04:00
|
|
|
static CURLcode pop3_doing(struct connectdata *conn, bool *dophase_done);
|
|
|
|
static CURLcode pop3_setup_connection(struct connectdata *conn);
|
2013-04-13 19:09:28 +04:00
|
|
|
static CURLcode pop3_parse_url_options(struct connectdata *conn);
|
2013-04-12 23:16:57 +04:00
|
|
|
static CURLcode pop3_parse_url_path(struct connectdata *conn);
|
|
|
|
static CURLcode pop3_parse_custom_request(struct connectdata *conn);
|
2015-01-20 19:33:05 +03:00
|
|
|
static CURLcode pop3_perform_auth(struct connectdata *conn, const char *mech,
|
|
|
|
const char *initresp);
|
|
|
|
static CURLcode pop3_continue_auth(struct connectdata *conn, const char *resp);
|
2016-11-23 10:30:18 +03:00
|
|
|
static void pop3_get_message(char *buffer, char **outptr);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* POP3 protocol handler.
|
|
|
|
*/
|
|
|
|
|
|
|
|
const struct Curl_handler Curl_handler_pop3 = {
|
|
|
|
"POP3", /* scheme */
|
|
|
|
pop3_setup_connection, /* setup_connection */
|
|
|
|
pop3_do, /* do_it */
|
|
|
|
pop3_done, /* done */
|
|
|
|
ZERO_NULL, /* do_more */
|
|
|
|
pop3_connect, /* connect_it */
|
|
|
|
pop3_multi_statemach, /* connecting */
|
|
|
|
pop3_doing, /* doing */
|
|
|
|
pop3_getsock, /* proto_getsock */
|
|
|
|
pop3_getsock, /* doing_getsock */
|
2011-10-22 01:36:54 +04:00
|
|
|
ZERO_NULL, /* domore_getsock */
|
2009-12-13 00:54:01 +03:00
|
|
|
ZERO_NULL, /* perform_getsock */
|
|
|
|
pop3_disconnect, /* disconnect */
|
2011-05-05 18:27:03 +04:00
|
|
|
ZERO_NULL, /* readwrite */
|
2017-05-31 14:09:56 +03:00
|
|
|
ZERO_NULL, /* connection_check */
|
2009-12-13 00:54:01 +03:00
|
|
|
PORT_POP3, /* defport */
|
2011-03-15 00:52:14 +03:00
|
|
|
CURLPROTO_POP3, /* protocol */
|
2017-02-10 12:50:19 +03:00
|
|
|
PROTOPT_CLOSEACTION | PROTOPT_NOURLQUERY | /* flags */
|
|
|
|
PROTOPT_URLOPTIONS
|
2009-12-13 00:54:01 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef USE_SSL
|
|
|
|
/*
|
|
|
|
* POP3S protocol handler.
|
|
|
|
*/
|
|
|
|
|
|
|
|
const struct Curl_handler Curl_handler_pop3s = {
|
|
|
|
"POP3S", /* scheme */
|
|
|
|
pop3_setup_connection, /* setup_connection */
|
|
|
|
pop3_do, /* do_it */
|
|
|
|
pop3_done, /* done */
|
|
|
|
ZERO_NULL, /* do_more */
|
|
|
|
pop3_connect, /* connect_it */
|
|
|
|
pop3_multi_statemach, /* connecting */
|
|
|
|
pop3_doing, /* doing */
|
|
|
|
pop3_getsock, /* proto_getsock */
|
|
|
|
pop3_getsock, /* doing_getsock */
|
2011-10-22 01:36:54 +04:00
|
|
|
ZERO_NULL, /* domore_getsock */
|
2009-12-13 00:54:01 +03:00
|
|
|
ZERO_NULL, /* perform_getsock */
|
|
|
|
pop3_disconnect, /* disconnect */
|
2011-05-05 18:27:03 +04:00
|
|
|
ZERO_NULL, /* readwrite */
|
2017-05-31 14:09:56 +03:00
|
|
|
ZERO_NULL, /* connection_check */
|
2009-12-13 00:54:01 +03:00
|
|
|
PORT_POP3S, /* defport */
|
2014-04-20 21:37:54 +04:00
|
|
|
CURLPROTO_POP3S, /* protocol */
|
2011-11-25 02:28:54 +04:00
|
|
|
PROTOPT_CLOSEACTION | PROTOPT_SSL
|
2017-02-10 12:50:19 +03:00
|
|
|
| PROTOPT_NOURLQUERY | PROTOPT_URLOPTIONS /* flags */
|
2009-12-13 00:54:01 +03:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2015-01-20 19:33:05 +03:00
|
|
|
/* SASL parameters for the pop3 protocol */
|
|
|
|
static const struct SASLproto saslpop3 = {
|
|
|
|
"pop", /* The service name */
|
2015-11-20 10:01:01 +03:00
|
|
|
'*', /* Code received when continuation is expected */
|
2015-01-20 19:33:05 +03:00
|
|
|
'+', /* Code to receive upon authentication success */
|
|
|
|
255 - 8, /* Maximum initial response length (no max) */
|
|
|
|
pop3_perform_auth, /* Send authentication command */
|
|
|
|
pop3_continue_auth, /* Send authentication continuation */
|
|
|
|
pop3_get_message /* Get SASL response message */
|
|
|
|
};
|
|
|
|
|
2013-02-12 03:13:50 +04:00
|
|
|
#ifdef USE_SSL
|
|
|
|
static void pop3_to_pop3s(struct connectdata *conn)
|
|
|
|
{
|
2016-03-05 23:10:11 +03:00
|
|
|
/* Change the connection handler */
|
2013-02-12 03:13:50 +04:00
|
|
|
conn->handler = &Curl_handler_pop3s;
|
2016-03-05 23:10:11 +03:00
|
|
|
|
|
|
|
/* Set the connection's upgraded to TLS flag */
|
|
|
|
conn->tls_upgraded = TRUE;
|
2013-02-12 03:13:50 +04:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define pop3_to_pop3s(x) Curl_nop_stmt
|
|
|
|
#endif
|
|
|
|
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_endofresp()
|
|
|
|
*
|
|
|
|
* Checks for an ending POP3 status code at the start of the given string, but
|
|
|
|
* also detects the APOP timestamp from the server greeting and various
|
|
|
|
* capabilities from the CAPA response including the supported authentication
|
|
|
|
* types and allowed SASL mechanisms.
|
|
|
|
*/
|
2013-02-12 22:08:48 +04:00
|
|
|
static bool pop3_endofresp(struct connectdata *conn, char *line, size_t len,
|
|
|
|
int *resp)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2012-05-27 22:09:38 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2012-06-03 20:06:48 +04:00
|
|
|
/* Do we have an error response? */
|
|
|
|
if(len >= 4 && !memcmp("-ERR", line, 4)) {
|
|
|
|
*resp = '-';
|
2012-05-27 13:54:13 +04:00
|
|
|
|
2013-02-09 19:23:30 +04:00
|
|
|
return TRUE;
|
2012-06-03 20:06:48 +04:00
|
|
|
}
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2012-06-09 16:49:37 +04:00
|
|
|
/* Are we processing CAPA command responses? */
|
2013-12-20 11:07:07 +04:00
|
|
|
if(pop3c->state == POP3_CAPA) {
|
2013-02-09 03:07:20 +04:00
|
|
|
/* Do we have the terminating line? */
|
2019-01-20 23:59:04 +03:00
|
|
|
if(len >= 1 && line[0] == '.')
|
2015-11-20 09:41:53 +03:00
|
|
|
/* Treat the response as a success */
|
2012-06-04 22:09:45 +04:00
|
|
|
*resp = '+';
|
2013-12-20 11:12:12 +04:00
|
|
|
else
|
2015-11-20 09:41:53 +03:00
|
|
|
/* Treat the response as an untagged continuation */
|
2013-12-20 11:12:12 +04:00
|
|
|
*resp = '*';
|
2012-06-04 22:09:45 +04:00
|
|
|
|
2013-12-20 11:12:12 +04:00
|
|
|
return TRUE;
|
2012-05-27 22:09:38 +04:00
|
|
|
}
|
|
|
|
|
2015-11-20 10:01:01 +03:00
|
|
|
/* Do we have a success response? */
|
|
|
|
if(len >= 3 && !memcmp("+OK", line, 3)) {
|
2013-02-13 03:00:34 +04:00
|
|
|
*resp = '+';
|
2012-06-03 20:06:48 +04:00
|
|
|
|
2013-02-13 03:00:34 +04:00
|
|
|
return TRUE;
|
|
|
|
}
|
2012-06-03 20:06:48 +04:00
|
|
|
|
2015-11-20 10:01:01 +03:00
|
|
|
/* Do we have a continuation response? */
|
2019-01-20 23:59:04 +03:00
|
|
|
if(len >= 1 && line[0] == '+') {
|
2015-11-20 10:01:01 +03:00
|
|
|
*resp = '*';
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2013-02-13 03:00:34 +04:00
|
|
|
return FALSE; /* Nothing for us */
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
|
|
|
|
2013-10-27 13:00:41 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_get_message()
|
|
|
|
*
|
|
|
|
* Gets the authentication message from the response buffer.
|
|
|
|
*/
|
2016-11-23 09:53:24 +03:00
|
|
|
static void pop3_get_message(char *buffer, char **outptr)
|
2013-10-27 13:00:41 +04:00
|
|
|
{
|
2017-12-01 02:45:46 +03:00
|
|
|
size_t len = strlen(buffer);
|
2016-11-23 09:53:24 +03:00
|
|
|
char *message = NULL;
|
2013-10-27 13:00:41 +04:00
|
|
|
|
2017-12-01 02:45:46 +03:00
|
|
|
if(len > 2) {
|
|
|
|
/* Find the start of the message */
|
2018-01-13 08:35:12 +03:00
|
|
|
len -= 2;
|
|
|
|
for(message = buffer + 2; *message == ' ' || *message == '\t';
|
|
|
|
message++, len--)
|
2017-12-01 02:45:46 +03:00
|
|
|
;
|
2013-10-27 13:00:41 +04:00
|
|
|
|
2017-12-01 02:45:46 +03:00
|
|
|
/* Find the end of the message */
|
2018-01-13 08:35:12 +03:00
|
|
|
for(; len--;)
|
2017-12-01 02:45:46 +03:00
|
|
|
if(message[len] != '\r' && message[len] != '\n' && message[len] != ' ' &&
|
|
|
|
message[len] != '\t')
|
|
|
|
break;
|
2013-10-27 13:00:41 +04:00
|
|
|
|
2017-12-01 02:45:46 +03:00
|
|
|
/* Terminate the message */
|
|
|
|
if(++len) {
|
|
|
|
message[len] = '\0';
|
|
|
|
}
|
2013-10-27 13:00:41 +04:00
|
|
|
}
|
2017-12-01 02:45:46 +03:00
|
|
|
else
|
|
|
|
/* junk input => zero length output */
|
|
|
|
message = &buffer[len];
|
2013-10-27 13:00:41 +04:00
|
|
|
|
|
|
|
*outptr = message;
|
|
|
|
}
|
|
|
|
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* state()
|
|
|
|
*
|
|
|
|
* This is the ONLY way to change POP3 state!
|
|
|
|
*/
|
2012-05-27 13:54:13 +04:00
|
|
|
static void state(struct connectdata *conn, pop3state newstate)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2012-12-29 00:30:04 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2009-12-13 00:54:01 +03:00
|
|
|
#if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
|
|
|
|
/* for debug purposes */
|
2012-06-05 01:15:51 +04:00
|
|
|
static const char * const names[] = {
|
2009-12-13 00:54:01 +03:00
|
|
|
"STOP",
|
|
|
|
"SERVERGREET",
|
2013-02-11 01:18:30 +04:00
|
|
|
"CAPA",
|
2012-05-28 23:21:52 +04:00
|
|
|
"STARTTLS",
|
2013-01-08 15:31:48 +04:00
|
|
|
"UPGRADETLS",
|
2015-01-20 19:33:05 +03:00
|
|
|
"AUTH",
|
2012-06-09 16:49:37 +04:00
|
|
|
"APOP",
|
2009-12-13 00:54:01 +03:00
|
|
|
"USER",
|
|
|
|
"PASS",
|
2012-04-03 02:24:00 +04:00
|
|
|
"COMMAND",
|
2009-12-13 00:54:01 +03:00
|
|
|
"QUIT",
|
|
|
|
/* LAST */
|
|
|
|
};
|
2012-12-29 00:30:04 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
if(pop3c->state != newstate)
|
|
|
|
infof(conn->data, "POP3 %p state change from %s to %s\n",
|
2013-07-23 17:59:07 +04:00
|
|
|
(void *)pop3c, names[pop3c->state], names[newstate]);
|
2009-12-13 00:54:01 +03:00
|
|
|
#endif
|
2012-12-29 00:30:04 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
pop3c->state = newstate;
|
|
|
|
}
|
|
|
|
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2013-04-14 12:53:07 +04:00
|
|
|
* pop3_perform_capa()
|
2013-04-14 12:47:32 +04:00
|
|
|
*
|
|
|
|
* Sends the CAPA command in order to obtain a list of server side supported
|
|
|
|
* capabilities.
|
|
|
|
*/
|
2013-04-14 12:53:07 +04:00
|
|
|
static CURLcode pop3_perform_capa(struct connectdata *conn)
|
2012-05-27 22:09:38 +04:00
|
|
|
{
|
2012-06-03 01:11:37 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2012-05-27 22:09:38 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
|
2015-01-20 16:14:26 +03:00
|
|
|
pop3c->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanisms yet */
|
|
|
|
pop3c->sasl.authused = SASL_AUTH_NONE; /* Clear the auth. mechanism used */
|
|
|
|
pop3c->tls_supported = FALSE; /* Clear the TLS capability */
|
2012-06-03 01:11:37 +04:00
|
|
|
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Send the CAPA command */
|
2013-07-24 19:05:02 +04:00
|
|
|
result = Curl_pp_sendf(&pop3c->pp, "%s", "CAPA");
|
2012-05-27 22:09:38 +04:00
|
|
|
|
2013-03-03 17:36:12 +04:00
|
|
|
if(!result)
|
|
|
|
state(conn, POP3_CAPA);
|
2012-05-27 22:09:38 +04:00
|
|
|
|
2013-03-03 17:36:12 +04:00
|
|
|
return result;
|
2012-05-27 22:09:38 +04:00
|
|
|
}
|
|
|
|
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2013-04-14 12:53:07 +04:00
|
|
|
* pop3_perform_starttls()
|
2013-04-14 12:47:32 +04:00
|
|
|
*
|
|
|
|
* Sends the STLS command to start the upgrade to TLS.
|
|
|
|
*/
|
2013-04-14 12:53:07 +04:00
|
|
|
static CURLcode pop3_perform_starttls(struct connectdata *conn)
|
2013-02-12 02:41:08 +04:00
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
|
|
|
|
/* Send the STLS command */
|
2013-07-24 19:05:02 +04:00
|
|
|
result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "STLS");
|
2013-02-12 02:41:08 +04:00
|
|
|
|
|
|
|
if(!result)
|
|
|
|
state(conn, POP3_STARTTLS);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2013-04-14 12:53:07 +04:00
|
|
|
* pop3_perform_upgrade_tls()
|
2013-04-14 12:47:32 +04:00
|
|
|
*
|
|
|
|
* Performs the upgrade to TLS.
|
|
|
|
*/
|
2013-04-14 12:53:07 +04:00
|
|
|
static CURLcode pop3_perform_upgrade_tls(struct connectdata *conn)
|
2013-02-12 03:13:50 +04:00
|
|
|
{
|
2013-02-17 03:37:50 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2013-02-12 03:13:50 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
|
2013-02-14 00:12:21 +04:00
|
|
|
/* Start the SSL connection */
|
2013-02-12 03:13:50 +04:00
|
|
|
result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &pop3c->ssldone);
|
|
|
|
|
|
|
|
if(!result) {
|
|
|
|
if(pop3c->state != POP3_UPGRADETLS)
|
|
|
|
state(conn, POP3_UPGRADETLS);
|
|
|
|
|
|
|
|
if(pop3c->ssldone) {
|
|
|
|
pop3_to_pop3s(conn);
|
2013-04-14 12:53:07 +04:00
|
|
|
result = pop3_perform_capa(conn);
|
2013-02-12 03:13:50 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2013-02-12 02:41:08 +04:00
|
|
|
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2013-04-14 12:53:07 +04:00
|
|
|
* pop3_perform_user()
|
2013-04-14 12:47:32 +04:00
|
|
|
*
|
|
|
|
* Sends a clear text USER command to authenticate with.
|
|
|
|
*/
|
2013-04-14 12:53:07 +04:00
|
|
|
static CURLcode pop3_perform_user(struct connectdata *conn)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2013-02-10 19:45:01 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-02-10 19:45:01 +04:00
|
|
|
/* Check we have a username and password to authenticate with and end the
|
|
|
|
connect phase if we don't */
|
|
|
|
if(!conn->bits.user_passwd) {
|
|
|
|
state(conn, POP3_STOP);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Send the USER command */
|
2009-12-13 00:54:01 +03:00
|
|
|
result = Curl_pp_sendf(&conn->proto.pop3c.pp, "USER %s",
|
2013-02-23 20:27:17 +04:00
|
|
|
conn->user ? conn->user : "");
|
2013-03-03 17:36:12 +04:00
|
|
|
if(!result)
|
|
|
|
state(conn, POP3_USER);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-03-03 17:36:12 +04:00
|
|
|
return result;
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
|
|
|
|
2012-12-05 22:31:40 +04:00
|
|
|
#ifndef CURL_DISABLE_CRYPTO_AUTH
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2013-04-14 12:53:07 +04:00
|
|
|
* pop3_perform_apop()
|
2013-04-14 12:47:32 +04:00
|
|
|
*
|
|
|
|
* Sends an APOP command to authenticate with.
|
|
|
|
*/
|
2013-04-14 12:53:07 +04:00
|
|
|
static CURLcode pop3_perform_apop(struct connectdata *conn)
|
2012-06-09 16:49:37 +04:00
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
size_t i;
|
|
|
|
MD5_context *ctxt;
|
|
|
|
unsigned char digest[MD5_DIGEST_LEN];
|
|
|
|
char secret[2 * MD5_DIGEST_LEN + 1];
|
|
|
|
|
2013-02-10 19:45:01 +04:00
|
|
|
/* Check we have a username and password to authenticate with and end the
|
|
|
|
connect phase if we don't */
|
|
|
|
if(!conn->bits.user_passwd) {
|
|
|
|
state(conn, POP3_STOP);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create the digest */
|
2012-06-09 16:49:37 +04:00
|
|
|
ctxt = Curl_MD5_init(Curl_DIGEST_MD5);
|
|
|
|
if(!ctxt)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
Curl_MD5_update(ctxt, (const unsigned char *) pop3c->apoptimestamp,
|
|
|
|
curlx_uztoui(strlen(pop3c->apoptimestamp)));
|
|
|
|
|
|
|
|
Curl_MD5_update(ctxt, (const unsigned char *) conn->passwd,
|
|
|
|
curlx_uztoui(strlen(conn->passwd)));
|
|
|
|
|
|
|
|
/* Finalise the digest */
|
|
|
|
Curl_MD5_final(ctxt, digest);
|
|
|
|
|
|
|
|
/* Convert the calculated 16 octet digest into a 32 byte hex string */
|
|
|
|
for(i = 0; i < MD5_DIGEST_LEN; i++)
|
2018-11-22 11:01:24 +03:00
|
|
|
msnprintf(&secret[2 * i], 3, "%02x", digest[i]);
|
2012-06-09 16:49:37 +04:00
|
|
|
|
|
|
|
result = Curl_pp_sendf(&pop3c->pp, "APOP %s %s", conn->user, secret);
|
|
|
|
|
|
|
|
if(!result)
|
|
|
|
state(conn, POP3_APOP);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2012-12-05 22:31:40 +04:00
|
|
|
#endif
|
2012-06-09 16:49:37 +04:00
|
|
|
|
2013-12-18 11:05:11 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_perform_auth()
|
|
|
|
*
|
|
|
|
* Sends an AUTH command allowing the client to login with the given SASL
|
|
|
|
* authentication mechanism.
|
|
|
|
*/
|
|
|
|
static CURLcode pop3_perform_auth(struct connectdata *conn,
|
|
|
|
const char *mech,
|
2015-01-20 19:33:05 +03:00
|
|
|
const char *initresp)
|
2013-12-18 11:05:11 +04:00
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
|
2015-01-20 19:33:05 +03:00
|
|
|
if(initresp) { /* AUTH <mech> ...<crlf> */
|
2013-12-18 11:05:11 +04:00
|
|
|
/* Send the AUTH command with the initial response */
|
|
|
|
result = Curl_pp_sendf(&pop3c->pp, "AUTH %s %s", mech, initresp);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Send the AUTH command */
|
|
|
|
result = Curl_pp_sendf(&pop3c->pp, "AUTH %s", mech);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-01-20 19:33:05 +03:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_continue_auth()
|
|
|
|
*
|
|
|
|
* Sends SASL continuation data or cancellation.
|
|
|
|
*/
|
|
|
|
static CURLcode pop3_continue_auth(struct connectdata *conn,
|
|
|
|
const char *resp)
|
|
|
|
{
|
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
|
|
|
|
return Curl_pp_sendf(&pop3c->pp, "%s", resp);
|
|
|
|
}
|
|
|
|
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2013-12-18 02:48:09 +04:00
|
|
|
* pop3_perform_authentication()
|
2013-04-14 12:47:32 +04:00
|
|
|
*
|
2013-12-18 02:48:09 +04:00
|
|
|
* Initiates the authentication sequence, with the appropriate SASL
|
|
|
|
* authentication mechanism, falling back to APOP and clear text should a
|
|
|
|
* common mechanism not be available between the client and server.
|
2013-04-14 12:47:32 +04:00
|
|
|
*/
|
2013-12-18 02:48:09 +04:00
|
|
|
static CURLcode pop3_perform_authentication(struct connectdata *conn)
|
2012-05-31 23:45:53 +04:00
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2015-01-20 19:33:05 +03:00
|
|
|
saslprogress progress = SASL_IDLE;
|
2012-05-31 23:45:53 +04:00
|
|
|
|
2015-01-27 19:24:55 +03:00
|
|
|
/* Check we have enough data to authenticate with and end the
|
2013-02-10 19:45:01 +04:00
|
|
|
connect phase if we don't */
|
2015-01-27 19:24:55 +03:00
|
|
|
if(!Curl_sasl_can_authenticate(&pop3c->sasl, conn)) {
|
2013-02-10 19:45:01 +04:00
|
|
|
state(conn, POP3_STOP);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-01-20 19:33:05 +03:00
|
|
|
if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_SASL) {
|
|
|
|
/* Calculate the SASL login details */
|
|
|
|
result = Curl_sasl_start(&pop3c->sasl, conn, FALSE, &progress);
|
2012-05-31 23:45:53 +04:00
|
|
|
|
2015-01-20 19:33:05 +03:00
|
|
|
if(!result)
|
|
|
|
if(progress == SASL_INPROGRESS)
|
|
|
|
state(conn, POP3_AUTH);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!result && progress == SASL_IDLE) {
|
2013-02-04 01:43:08 +04:00
|
|
|
#ifndef CURL_DISABLE_CRYPTO_AUTH
|
2015-01-20 19:33:05 +03:00
|
|
|
if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_APOP)
|
2013-04-28 15:57:42 +04:00
|
|
|
/* Perform APOP authentication */
|
|
|
|
result = pop3_perform_apop(conn);
|
2015-01-20 19:33:05 +03:00
|
|
|
else
|
2013-02-04 01:43:08 +04:00
|
|
|
#endif
|
2015-01-20 19:33:05 +03:00
|
|
|
if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_CLEARTEXT)
|
2013-04-28 15:57:42 +04:00
|
|
|
/* Perform clear text authentication */
|
|
|
|
result = pop3_perform_user(conn);
|
|
|
|
else {
|
|
|
|
/* Other mechanisms not supported */
|
|
|
|
infof(conn->data, "No known authentication mechanisms supported!\n");
|
|
|
|
result = CURLE_LOGIN_DENIED;
|
|
|
|
}
|
2013-02-04 01:43:08 +04:00
|
|
|
}
|
2012-05-31 23:45:53 +04:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-04-14 12:47:32 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2013-04-14 12:53:07 +04:00
|
|
|
* pop3_perform_command()
|
2013-04-14 12:47:32 +04:00
|
|
|
*
|
|
|
|
* Sends a POP3 based command.
|
|
|
|
*/
|
2013-04-14 12:53:07 +04:00
|
|
|
static CURLcode pop3_perform_command(struct connectdata *conn)
|
2013-04-14 12:35:35 +04:00
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-08-05 12:32:08 +04:00
|
|
|
struct POP3 *pop3 = data->req.protop;
|
2013-04-14 12:35:35 +04:00
|
|
|
const char *command = NULL;
|
|
|
|
|
|
|
|
/* Calculate the default command */
|
|
|
|
if(pop3->id[0] == '\0' || conn->data->set.ftp_list_only) {
|
|
|
|
command = "LIST";
|
|
|
|
|
|
|
|
if(pop3->id[0] != '\0')
|
|
|
|
/* Message specific LIST so skip the BODY transfer */
|
|
|
|
pop3->transfer = FTPTRANSFER_INFO;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
command = "RETR";
|
|
|
|
|
|
|
|
/* Send the command */
|
|
|
|
if(pop3->id[0] != '\0')
|
|
|
|
result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s %s",
|
|
|
|
(pop3->custom && pop3->custom[0] != '\0' ?
|
|
|
|
pop3->custom : command), pop3->id);
|
|
|
|
else
|
2013-07-24 19:05:02 +04:00
|
|
|
result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s",
|
2013-04-14 12:35:35 +04:00
|
|
|
(pop3->custom && pop3->custom[0] != '\0' ?
|
|
|
|
pop3->custom : command));
|
|
|
|
|
|
|
|
if(!result)
|
|
|
|
state(conn, POP3_COMMAND);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-04-14 12:37:19 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2013-04-14 12:53:07 +04:00
|
|
|
* pop3_perform_quit()
|
2013-04-14 12:37:19 +04:00
|
|
|
*
|
|
|
|
* Performs the quit action prior to sclose() be called.
|
|
|
|
*/
|
2013-04-14 12:53:07 +04:00
|
|
|
static CURLcode pop3_perform_quit(struct connectdata *conn)
|
2013-04-14 12:37:19 +04:00
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
|
|
|
|
/* Send the QUIT command */
|
2013-07-24 19:05:02 +04:00
|
|
|
result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "QUIT");
|
2013-04-14 12:37:19 +04:00
|
|
|
|
|
|
|
if(!result)
|
|
|
|
state(conn, POP3_QUIT);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-05-27 13:54:13 +04:00
|
|
|
/* For the initial server greeting */
|
2012-03-24 15:55:34 +04:00
|
|
|
static CURLcode pop3_state_servergreet_resp(struct connectdata *conn,
|
|
|
|
int pop3code,
|
|
|
|
pop3state instate)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-12-20 11:07:07 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
const char *line = data->state.buffer;
|
|
|
|
size_t len = strlen(line);
|
2012-03-24 15:55:34 +04:00
|
|
|
|
|
|
|
(void)instate; /* no use for this yet */
|
|
|
|
|
2012-05-28 23:59:10 +04:00
|
|
|
if(pop3code != '+') {
|
2012-03-24 15:55:34 +04:00
|
|
|
failf(data, "Got unexpected pop3-server response");
|
2016-08-22 22:37:03 +03:00
|
|
|
result = CURLE_WEIRD_SERVER_REPLY;
|
2012-03-24 15:55:34 +04:00
|
|
|
}
|
2013-12-20 11:07:07 +04:00
|
|
|
else {
|
2013-12-24 20:32:48 +04:00
|
|
|
/* Does the server support APOP authentication? */
|
2013-12-21 00:17:59 +04:00
|
|
|
if(len >= 4 && line[len - 2] == '>') {
|
2013-12-24 20:32:48 +04:00
|
|
|
/* Look for the APOP timestamp */
|
2018-06-02 23:52:56 +03:00
|
|
|
size_t i;
|
2013-12-21 00:17:59 +04:00
|
|
|
for(i = 3; i < len - 2; ++i) {
|
2013-12-20 11:07:07 +04:00
|
|
|
if(line[i] == '<') {
|
|
|
|
/* Calculate the length of the timestamp */
|
2013-12-21 00:17:59 +04:00
|
|
|
size_t timestamplen = len - 1 - i;
|
2018-11-15 19:00:16 +03:00
|
|
|
char *at;
|
2013-12-20 16:46:18 +04:00
|
|
|
if(!timestamplen)
|
|
|
|
break;
|
2013-12-20 11:07:07 +04:00
|
|
|
|
|
|
|
/* Allocate some memory for the timestamp */
|
|
|
|
pop3c->apoptimestamp = (char *)calloc(1, timestamplen + 1);
|
|
|
|
|
|
|
|
if(!pop3c->apoptimestamp)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Copy the timestamp */
|
|
|
|
memcpy(pop3c->apoptimestamp, line + i, timestamplen);
|
|
|
|
pop3c->apoptimestamp[timestamplen] = '\0';
|
2013-12-24 20:32:48 +04:00
|
|
|
|
2018-11-15 19:00:16 +03:00
|
|
|
/* If the timestamp does not contain '@' it is not (as required by
|
|
|
|
RFC-1939) conformant to the RFC-822 message id syntax, and we
|
|
|
|
therefore do not use APOP authentication. */
|
|
|
|
at = strchr(pop3c->apoptimestamp, '@');
|
|
|
|
if(!at)
|
|
|
|
Curl_safefree(pop3c->apoptimestamp);
|
|
|
|
else
|
|
|
|
/* Store the APOP capability */
|
|
|
|
pop3c->authtypes |= POP3_TYPE_APOP;
|
2013-12-20 11:07:07 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-15 23:10:25 +04:00
|
|
|
result = pop3_perform_capa(conn);
|
2013-12-20 11:07:07 +04:00
|
|
|
}
|
2012-03-24 15:55:34 +04:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-02-12 02:41:08 +04:00
|
|
|
/* For CAPA responses */
|
|
|
|
static CURLcode pop3_state_capa_resp(struct connectdata *conn, int pop3code,
|
|
|
|
pop3state instate)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-02-12 02:41:08 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2013-12-20 11:12:12 +04:00
|
|
|
const char *line = data->state.buffer;
|
|
|
|
size_t len = strlen(line);
|
2013-02-12 02:41:08 +04:00
|
|
|
|
|
|
|
(void)instate; /* no use for this yet */
|
|
|
|
|
2015-11-20 09:41:53 +03:00
|
|
|
/* Do we have a untagged continuation response? */
|
2013-12-20 11:12:12 +04:00
|
|
|
if(pop3code == '*') {
|
|
|
|
/* Does the server support the STLS capability? */
|
|
|
|
if(len >= 4 && !memcmp(line, "STLS", 4))
|
|
|
|
pop3c->tls_supported = TRUE;
|
|
|
|
|
|
|
|
/* Does the server support clear text authentication? */
|
|
|
|
else if(len >= 4 && !memcmp(line, "USER", 4))
|
|
|
|
pop3c->authtypes |= POP3_TYPE_CLEARTEXT;
|
|
|
|
|
|
|
|
/* Does the server support SASL based authentication? */
|
|
|
|
else if(len >= 5 && !memcmp(line, "SASL ", 5)) {
|
|
|
|
pop3c->authtypes |= POP3_TYPE_SASL;
|
|
|
|
|
|
|
|
/* Advance past the SASL keyword */
|
|
|
|
line += 5;
|
|
|
|
len -= 5;
|
|
|
|
|
|
|
|
/* Loop through the data line */
|
|
|
|
for(;;) {
|
2015-01-20 17:27:25 +03:00
|
|
|
size_t llen;
|
2018-06-02 23:52:56 +03:00
|
|
|
size_t wordlen;
|
2015-01-20 17:27:25 +03:00
|
|
|
unsigned int mechbit;
|
|
|
|
|
2013-12-20 11:12:12 +04:00
|
|
|
while(len &&
|
|
|
|
(*line == ' ' || *line == '\t' ||
|
|
|
|
*line == '\r' || *line == '\n')) {
|
|
|
|
|
|
|
|
line++;
|
|
|
|
len--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!len)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Extract the word */
|
|
|
|
for(wordlen = 0; wordlen < len && line[wordlen] != ' ' &&
|
|
|
|
line[wordlen] != '\t' && line[wordlen] != '\r' &&
|
|
|
|
line[wordlen] != '\n';)
|
|
|
|
wordlen++;
|
|
|
|
|
|
|
|
/* Test the word for a matching authentication mechanism */
|
2016-03-19 20:15:53 +03:00
|
|
|
mechbit = Curl_sasl_decode_mech(line, wordlen, &llen);
|
|
|
|
if(mechbit && llen == wordlen)
|
2015-01-20 17:27:25 +03:00
|
|
|
pop3c->sasl.authmechs |= mechbit;
|
2013-12-20 11:12:12 +04:00
|
|
|
|
|
|
|
line += wordlen;
|
|
|
|
len -= wordlen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(pop3code == '+') {
|
|
|
|
if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
|
|
|
|
/* We don't have a SSL/TLS connection yet, but SSL is requested */
|
|
|
|
if(pop3c->tls_supported)
|
|
|
|
/* Switch to TLS connection now */
|
|
|
|
result = pop3_perform_starttls(conn);
|
|
|
|
else if(data->set.use_ssl == CURLUSESSL_TRY)
|
|
|
|
/* Fallback and carry on with authentication */
|
|
|
|
result = pop3_perform_authentication(conn);
|
|
|
|
else {
|
|
|
|
failf(data, "STLS not supported.");
|
|
|
|
result = CURLE_USE_SSL_FAILED;
|
|
|
|
}
|
2013-02-12 02:41:08 +04:00
|
|
|
}
|
2013-12-20 11:12:12 +04:00
|
|
|
else
|
|
|
|
result = pop3_perform_authentication(conn);
|
2013-02-12 02:41:08 +04:00
|
|
|
}
|
2013-12-25 02:35:55 +04:00
|
|
|
else {
|
|
|
|
/* Clear text is supported when CAPA isn't recognised */
|
|
|
|
pop3c->authtypes |= POP3_TYPE_CLEARTEXT;
|
|
|
|
|
|
|
|
result = pop3_perform_authentication(conn);
|
|
|
|
}
|
2013-02-12 02:41:08 +04:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-05-27 13:54:13 +04:00
|
|
|
/* For STARTTLS responses */
|
2009-12-13 00:54:01 +03:00
|
|
|
static CURLcode pop3_state_starttls_resp(struct connectdata *conn,
|
|
|
|
int pop3code,
|
|
|
|
pop3state instate)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2012-03-24 15:55:34 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
(void)instate; /* no use for this yet */
|
|
|
|
|
2012-05-28 23:59:10 +04:00
|
|
|
if(pop3code != '+') {
|
2012-01-04 03:17:08 +04:00
|
|
|
if(data->set.use_ssl != CURLUSESSL_TRY) {
|
2017-01-12 10:22:41 +03:00
|
|
|
failf(data, "STARTTLS denied");
|
2012-01-04 03:17:08 +04:00
|
|
|
result = CURLE_USE_SSL_FAILED;
|
|
|
|
}
|
|
|
|
else
|
2013-12-18 02:48:09 +04:00
|
|
|
result = pop3_perform_authentication(conn);
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
2013-01-25 00:24:39 +04:00
|
|
|
else
|
2013-04-14 12:53:07 +04:00
|
|
|
result = pop3_perform_upgrade_tls(conn);
|
2012-03-24 15:55:34 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-01-20 19:33:05 +03:00
|
|
|
/* For SASL authentication responses */
|
|
|
|
static CURLcode pop3_state_auth_resp(struct connectdata *conn,
|
|
|
|
int pop3code,
|
|
|
|
pop3state instate)
|
2013-10-27 13:10:38 +04:00
|
|
|
{
|
2013-12-19 00:44:20 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-12-19 00:44:20 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2015-01-20 19:33:05 +03:00
|
|
|
saslprogress progress;
|
2013-10-27 13:10:38 +04:00
|
|
|
|
|
|
|
(void)instate; /* no use for this yet */
|
|
|
|
|
2015-01-20 19:33:05 +03:00
|
|
|
result = Curl_sasl_continue(&pop3c->sasl, conn, pop3code, &progress);
|
|
|
|
if(!result)
|
|
|
|
switch(progress) {
|
|
|
|
case SASL_DONE:
|
|
|
|
state(conn, POP3_STOP); /* Authenticated */
|
|
|
|
break;
|
|
|
|
case SASL_IDLE: /* No mechanism left after cancellation */
|
2013-12-19 00:44:20 +04:00
|
|
|
#ifndef CURL_DISABLE_CRYPTO_AUTH
|
2015-01-20 19:33:05 +03:00
|
|
|
if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_APOP)
|
|
|
|
/* Perform APOP authentication */
|
|
|
|
result = pop3_perform_apop(conn);
|
|
|
|
else
|
2013-12-19 00:44:20 +04:00
|
|
|
#endif
|
2015-01-20 19:33:05 +03:00
|
|
|
if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_CLEARTEXT)
|
|
|
|
/* Perform clear text authentication */
|
|
|
|
result = pop3_perform_user(conn);
|
|
|
|
else {
|
|
|
|
failf(data, "Authentication cancelled");
|
|
|
|
result = CURLE_LOGIN_DENIED;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2013-12-19 00:44:20 +04:00
|
|
|
}
|
2012-05-27 22:09:38 +04:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-01-20 15:09:53 +04:00
|
|
|
#ifndef CURL_DISABLE_CRYPTO_AUTH
|
2013-04-15 23:16:28 +04:00
|
|
|
/* For APOP responses */
|
2013-01-19 13:49:17 +04:00
|
|
|
static CURLcode pop3_state_apop_resp(struct connectdata *conn, int pop3code,
|
2012-06-09 16:49:37 +04:00
|
|
|
pop3state instate)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2012-06-09 16:49:37 +04:00
|
|
|
|
|
|
|
(void)instate; /* no use for this yet */
|
|
|
|
|
|
|
|
if(pop3code != '+') {
|
|
|
|
failf(data, "Authentication failed: %d", pop3code);
|
|
|
|
result = CURLE_LOGIN_DENIED;
|
|
|
|
}
|
2013-02-15 22:33:28 +04:00
|
|
|
else
|
|
|
|
/* End of connect phase */
|
|
|
|
state(conn, POP3_STOP);
|
2012-06-09 16:49:37 +04:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2013-01-20 15:09:53 +04:00
|
|
|
#endif
|
2012-06-09 16:49:37 +04:00
|
|
|
|
2012-05-27 13:54:13 +04:00
|
|
|
/* For USER responses */
|
2013-01-19 13:49:17 +04:00
|
|
|
static CURLcode pop3_state_user_resp(struct connectdata *conn, int pop3code,
|
2009-12-13 00:54:01 +03:00
|
|
|
pop3state instate)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
(void)instate; /* no use for this yet */
|
|
|
|
|
2012-05-28 23:59:10 +04:00
|
|
|
if(pop3code != '+') {
|
2009-12-13 00:54:01 +03:00
|
|
|
failf(data, "Access denied. %c", pop3code);
|
|
|
|
result = CURLE_LOGIN_DENIED;
|
|
|
|
}
|
2010-04-17 00:56:13 +04:00
|
|
|
else
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Send the PASS command */
|
2010-04-17 00:56:13 +04:00
|
|
|
result = Curl_pp_sendf(&conn->proto.pop3c.pp, "PASS %s",
|
2013-02-23 20:27:17 +04:00
|
|
|
conn->passwd ? conn->passwd : "");
|
2013-03-03 17:36:12 +04:00
|
|
|
if(!result)
|
|
|
|
state(conn, POP3_PASS);
|
2012-03-24 15:55:34 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-05-27 13:54:13 +04:00
|
|
|
/* For PASS responses */
|
2013-01-19 13:49:17 +04:00
|
|
|
static CURLcode pop3_state_pass_resp(struct connectdata *conn, int pop3code,
|
2009-12-13 00:54:01 +03:00
|
|
|
pop3state instate)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2012-03-24 16:28:11 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
(void)instate; /* no use for this yet */
|
|
|
|
|
2012-05-28 23:59:10 +04:00
|
|
|
if(pop3code != '+') {
|
2009-12-13 00:54:01 +03:00
|
|
|
failf(data, "Access denied. %c", pop3code);
|
|
|
|
result = CURLE_LOGIN_DENIED;
|
|
|
|
}
|
2013-02-15 22:33:28 +04:00
|
|
|
else
|
|
|
|
/* End of connect phase */
|
|
|
|
state(conn, POP3_STOP);
|
2012-03-24 15:55:34 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-06-05 16:49:50 +04:00
|
|
|
/* For command responses */
|
2012-04-03 02:24:00 +04:00
|
|
|
static CURLcode pop3_state_command_resp(struct connectdata *conn,
|
|
|
|
int pop3code,
|
|
|
|
pop3state instate)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-08-05 12:32:08 +04:00
|
|
|
struct POP3 *pop3 = data->req.protop;
|
2009-12-13 00:54:01 +03:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
struct pingpong *pp = &pop3c->pp;
|
|
|
|
|
|
|
|
(void)instate; /* no use for this yet */
|
|
|
|
|
2012-05-28 23:59:10 +04:00
|
|
|
if(pop3code != '+') {
|
2009-12-13 00:54:01 +03:00
|
|
|
state(conn, POP3_STOP);
|
|
|
|
return CURLE_RECV_ERROR;
|
|
|
|
}
|
|
|
|
|
2012-03-24 16:28:11 +04:00
|
|
|
/* This 'OK' line ends with a CR LF pair which is the two first bytes of the
|
|
|
|
EOB string so count this is two matching bytes. This is necessary to make
|
|
|
|
the code detect the EOB if the only data than comes now is %2e CR LF like
|
|
|
|
when there is no body to return. */
|
|
|
|
pop3c->eob = 2;
|
|
|
|
|
|
|
|
/* But since this initial CR LF pair is not part of the actual body, we set
|
|
|
|
the strip counter here so that these bytes won't be delivered. */
|
|
|
|
pop3c->strip = 2;
|
|
|
|
|
2013-03-12 17:09:03 +04:00
|
|
|
if(pop3->transfer == FTPTRANSFER_BODY) {
|
|
|
|
/* POP3 download */
|
2019-02-28 13:36:26 +03:00
|
|
|
Curl_setup_transfer(data, FIRSTSOCKET, -1, FALSE, -1);
|
2010-03-29 01:49:00 +04:00
|
|
|
|
2013-03-12 17:09:03 +04:00
|
|
|
if(pp->cache) {
|
|
|
|
/* The header "cache" contains a bunch of data that is actually body
|
|
|
|
content so send it as such. Note that there may even be additional
|
|
|
|
"headers" after the body */
|
2010-03-29 01:49:00 +04:00
|
|
|
|
2013-03-12 17:09:03 +04:00
|
|
|
if(!data->set.opt_no_body) {
|
|
|
|
result = Curl_pop3_write(conn, pp->cache, pp->cache_size);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
2010-03-29 01:49:00 +04:00
|
|
|
|
2013-03-12 17:09:03 +04:00
|
|
|
/* Free the cache */
|
|
|
|
Curl_safefree(pp->cache);
|
2012-03-24 04:09:38 +04:00
|
|
|
|
2013-03-12 17:09:03 +04:00
|
|
|
/* Reset the cache size */
|
|
|
|
pp->cache_size = 0;
|
|
|
|
}
|
2010-03-29 01:49:00 +04:00
|
|
|
}
|
|
|
|
|
2013-03-01 02:26:46 +04:00
|
|
|
/* End of DO phase */
|
2010-03-29 01:49:00 +04:00
|
|
|
state(conn, POP3_STOP);
|
2012-03-24 04:09:38 +04:00
|
|
|
|
2010-03-29 01:49:00 +04:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
static CURLcode pop3_statemach_act(struct connectdata *conn)
|
|
|
|
{
|
2013-02-17 03:37:50 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2009-12-13 00:54:01 +03:00
|
|
|
curl_socket_t sock = conn->sock[FIRSTSOCKET];
|
|
|
|
int pop3code;
|
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
struct pingpong *pp = &pop3c->pp;
|
|
|
|
size_t nread = 0;
|
|
|
|
|
2013-01-08 15:31:48 +04:00
|
|
|
/* Busy upgrading the connection; right now all I/O is SSL/TLS, not POP3 */
|
|
|
|
if(pop3c->state == POP3_UPGRADETLS)
|
2013-04-14 12:53:07 +04:00
|
|
|
return pop3_perform_upgrade_tls(conn);
|
2013-01-08 15:31:48 +04:00
|
|
|
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Flush any data that needs to be sent */
|
2009-12-13 00:54:01 +03:00
|
|
|
if(pp->sendleft)
|
|
|
|
return Curl_pp_flushsend(pp);
|
|
|
|
|
2013-12-20 11:17:17 +04:00
|
|
|
do {
|
|
|
|
/* Read the response from the server */
|
|
|
|
result = Curl_pp_readresp(sock, pp, &pop3code, &nread);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if(!pop3code)
|
|
|
|
break;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2012-06-05 01:15:51 +04:00
|
|
|
/* We have now received a full POP3 server response */
|
2009-12-13 00:54:01 +03:00
|
|
|
switch(pop3c->state) {
|
|
|
|
case POP3_SERVERGREET:
|
2012-03-24 15:55:34 +04:00
|
|
|
result = pop3_state_servergreet_resp(conn, pop3code, pop3c->state);
|
2009-12-13 00:54:01 +03:00
|
|
|
break;
|
|
|
|
|
2012-06-04 22:09:45 +04:00
|
|
|
case POP3_CAPA:
|
|
|
|
result = pop3_state_capa_resp(conn, pop3code, pop3c->state);
|
2012-05-31 23:45:53 +04:00
|
|
|
break;
|
|
|
|
|
2013-02-11 01:18:30 +04:00
|
|
|
case POP3_STARTTLS:
|
|
|
|
result = pop3_state_starttls_resp(conn, pop3code, pop3c->state);
|
|
|
|
break;
|
|
|
|
|
2015-01-20 19:33:05 +03:00
|
|
|
case POP3_AUTH:
|
|
|
|
result = pop3_state_auth_resp(conn, pop3code, pop3c->state);
|
2012-05-27 22:09:38 +04:00
|
|
|
break;
|
|
|
|
|
2013-01-20 15:09:53 +04:00
|
|
|
#ifndef CURL_DISABLE_CRYPTO_AUTH
|
2012-06-09 16:49:37 +04:00
|
|
|
case POP3_APOP:
|
|
|
|
result = pop3_state_apop_resp(conn, pop3code, pop3c->state);
|
|
|
|
break;
|
2013-01-20 15:09:53 +04:00
|
|
|
#endif
|
2012-06-09 16:49:37 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
case POP3_USER:
|
|
|
|
result = pop3_state_user_resp(conn, pop3code, pop3c->state);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case POP3_PASS:
|
|
|
|
result = pop3_state_pass_resp(conn, pop3code, pop3c->state);
|
|
|
|
break;
|
|
|
|
|
2012-04-03 02:24:00 +04:00
|
|
|
case POP3_COMMAND:
|
|
|
|
result = pop3_state_command_resp(conn, pop3code, pop3c->state);
|
2012-03-24 16:28:11 +04:00
|
|
|
break;
|
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
case POP3_QUIT:
|
|
|
|
/* fallthrough, just stop! */
|
|
|
|
default:
|
|
|
|
/* internal error */
|
|
|
|
state(conn, POP3_STOP);
|
|
|
|
break;
|
|
|
|
}
|
2013-12-20 11:17:17 +04:00
|
|
|
} while(!result && pop3c->state != POP3_STOP && Curl_pp_moredata(pp));
|
2012-03-24 15:55:34 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-01-04 05:50:28 +04:00
|
|
|
/* Called repeatedly until done from multi.c */
|
2009-12-13 00:54:01 +03:00
|
|
|
static CURLcode pop3_multi_statemach(struct connectdata *conn, bool *done)
|
|
|
|
{
|
2013-02-17 03:37:50 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2009-12-13 00:54:01 +03:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2013-01-19 01:55:19 +04:00
|
|
|
|
2013-09-10 22:40:11 +04:00
|
|
|
if((conn->handler->flags & PROTOPT_SSL) && !pop3c->ssldone) {
|
2013-01-19 01:55:19 +04:00
|
|
|
result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &pop3c->ssldone);
|
2013-09-10 22:40:11 +04:00
|
|
|
if(result || !pop3c->ssldone)
|
|
|
|
return result;
|
|
|
|
}
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2018-12-14 11:21:47 +03:00
|
|
|
result = Curl_pp_statemach(&pop3c->pp, FALSE, FALSE);
|
2011-09-05 22:46:09 +04:00
|
|
|
*done = (pop3c->state == POP3_STOP) ? TRUE : FALSE;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-12-14 11:21:47 +03:00
|
|
|
static CURLcode pop3_block_statemach(struct connectdata *conn,
|
|
|
|
bool disconnecting)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2013-02-17 03:37:50 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-03-08 02:44:10 +04:00
|
|
|
while(pop3c->state != POP3_STOP && !result)
|
2018-12-14 11:21:47 +03:00
|
|
|
result = Curl_pp_statemach(&pop3c->pp, TRUE, disconnecting);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2016-06-21 16:47:12 +03:00
|
|
|
/* Allocate and initialize the POP3 struct for the current Curl_easy if
|
2012-05-27 13:54:13 +04:00
|
|
|
required */
|
2009-12-13 00:54:01 +03:00
|
|
|
static CURLcode pop3_init(struct connectdata *conn)
|
|
|
|
{
|
2013-03-10 02:25:40 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-08-04 21:34:16 +04:00
|
|
|
struct POP3 *pop3;
|
2012-03-25 14:28:59 +04:00
|
|
|
|
2013-08-05 12:32:08 +04:00
|
|
|
pop3 = data->req.protop = calloc(sizeof(struct POP3), 1);
|
2013-08-04 21:34:16 +04:00
|
|
|
if(!pop3)
|
|
|
|
result = CURLE_OUT_OF_MEMORY;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-03-10 02:25:40 +04:00
|
|
|
return result;
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
|
|
|
|
2013-02-12 03:13:50 +04:00
|
|
|
/* For the POP3 "protocol connect" and "doing" phases only */
|
|
|
|
static int pop3_getsock(struct connectdata *conn, curl_socket_t *socks,
|
|
|
|
int numsocks)
|
|
|
|
{
|
|
|
|
return Curl_pp_getsock(&conn->proto.pop3c.pp, socks, numsocks);
|
|
|
|
}
|
|
|
|
|
2012-05-27 13:54:13 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_connect()
|
|
|
|
*
|
|
|
|
* This function should do everything that is to be considered a part of the
|
|
|
|
* connection phase.
|
2009-12-13 00:54:01 +03:00
|
|
|
*
|
|
|
|
* The variable 'done' points to will be TRUE if the protocol-layer connect
|
2013-08-10 01:39:09 +04:00
|
|
|
* phase is done when this function returns, or FALSE if not.
|
2009-12-13 00:54:01 +03:00
|
|
|
*/
|
2012-05-27 13:54:13 +04:00
|
|
|
static CURLcode pop3_connect(struct connectdata *conn, bool *done)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2013-02-17 03:37:50 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2009-12-13 00:54:01 +03:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
|
|
|
struct pingpong *pp = &pop3c->pp;
|
|
|
|
|
|
|
|
*done = FALSE; /* default to not done yet */
|
|
|
|
|
2013-02-14 00:12:21 +04:00
|
|
|
/* We always support persistent connections in POP3 */
|
2014-05-20 12:32:23 +04:00
|
|
|
connkeep(conn, "POP3 default");
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-02-14 00:12:21 +04:00
|
|
|
/* Set the default response time-out */
|
|
|
|
pp->response_time = RESP_TIMEOUT;
|
2009-12-13 00:54:01 +03:00
|
|
|
pp->statemach_act = pop3_statemach_act;
|
|
|
|
pp->endofresp = pop3_endofresp;
|
|
|
|
pp->conn = conn;
|
|
|
|
|
2013-04-13 19:09:28 +04:00
|
|
|
/* Set the default preferred authentication type and mechanism */
|
|
|
|
pop3c->preftype = POP3_TYPE_ANY;
|
2015-01-20 19:33:05 +03:00
|
|
|
Curl_sasl_init(&pop3c->sasl, &saslpop3);
|
2013-04-13 19:09:28 +04:00
|
|
|
|
2013-02-14 00:12:21 +04:00
|
|
|
/* Initialise the pingpong layer */
|
2012-12-29 00:30:04 +04:00
|
|
|
Curl_pp_init(pp);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-04-13 19:09:28 +04:00
|
|
|
/* Parse the URL options */
|
|
|
|
result = pop3_parse_url_options(conn);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
2012-12-29 00:30:04 +04:00
|
|
|
/* Start off waiting for the server greeting response */
|
2009-12-13 00:54:01 +03:00
|
|
|
state(conn, POP3_SERVERGREET);
|
|
|
|
|
2013-01-17 15:59:23 +04:00
|
|
|
result = pop3_multi_statemach(conn, done);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_done()
|
|
|
|
*
|
|
|
|
* The DONE function. This does what needs to be done after a single DO has
|
|
|
|
* performed.
|
|
|
|
*
|
|
|
|
* Input argument is already checked for validity.
|
|
|
|
*/
|
|
|
|
static CURLcode pop3_done(struct connectdata *conn, CURLcode status,
|
|
|
|
bool premature)
|
|
|
|
{
|
2013-02-17 03:37:50 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-08-05 12:32:08 +04:00
|
|
|
struct POP3 *pop3 = data->req.protop;
|
2012-03-24 16:28:11 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
(void)premature;
|
|
|
|
|
|
|
|
if(!pop3)
|
|
|
|
return CURLE_OK;
|
|
|
|
|
|
|
|
if(status) {
|
2014-05-20 12:32:23 +04:00
|
|
|
connclose(conn, "POP3 done with bad status");
|
2012-03-25 14:28:59 +04:00
|
|
|
result = status; /* use the already set error code */
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
|
|
|
|
2013-02-23 03:31:13 +04:00
|
|
|
/* Cleanup our per-request based variables */
|
2013-02-24 01:43:59 +04:00
|
|
|
Curl_safefree(pop3->id);
|
2013-02-23 20:15:38 +04:00
|
|
|
Curl_safefree(pop3->custom);
|
2011-03-18 02:28:12 +03:00
|
|
|
|
2013-02-23 15:34:52 +04:00
|
|
|
/* Clear the transfer mode for the next request */
|
2009-12-13 00:54:01 +03:00
|
|
|
pop3->transfer = FTPTRANSFER_BODY;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_perform()
|
|
|
|
*
|
2013-02-23 20:27:17 +04:00
|
|
|
* This is the actual DO function for POP3. Get a message/listing according to
|
2009-12-13 00:54:01 +03:00
|
|
|
* the options previously setup.
|
|
|
|
*/
|
2012-05-27 13:54:13 +04:00
|
|
|
static CURLcode pop3_perform(struct connectdata *conn, bool *connected,
|
|
|
|
bool *dophase_done)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2012-06-05 01:15:51 +04:00
|
|
|
/* This is POP3 and no proxy */
|
2012-03-25 14:28:59 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2013-12-05 00:10:33 +04:00
|
|
|
struct POP3 *pop3 = conn->data->req.protop;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
DEBUGF(infof(conn->data, "DO phase starts\n"));
|
|
|
|
|
|
|
|
if(conn->data->set.opt_no_body) {
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Requested no body means no transfer */
|
2009-12-13 00:54:01 +03:00
|
|
|
pop3->transfer = FTPTRANSFER_INFO;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dophase_done = FALSE; /* not done yet */
|
|
|
|
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Start the first command in the DO phase */
|
2013-04-14 12:53:07 +04:00
|
|
|
result = pop3_perform_command(conn);
|
2009-12-13 00:54:01 +03:00
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Run the state-machine */
|
2013-01-17 15:59:23 +04:00
|
|
|
result = pop3_multi_statemach(conn, dophase_done);
|
|
|
|
|
2011-08-20 01:38:45 +04:00
|
|
|
*connected = conn->bits.tcpconnect[FIRSTSOCKET];
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
if(*dophase_done)
|
|
|
|
DEBUGF(infof(conn->data, "DO phase is complete\n"));
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_do()
|
|
|
|
*
|
|
|
|
* This function is registered as 'curl_do' function. It decodes the path
|
|
|
|
* parts etc as a wrapper to the actual DO function (pop3_perform).
|
|
|
|
*
|
|
|
|
* The input argument is already checked for validity.
|
|
|
|
*/
|
|
|
|
static CURLcode pop3_do(struct connectdata *conn, bool *done)
|
|
|
|
{
|
2013-02-17 03:37:50 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
*done = FALSE; /* default to false */
|
|
|
|
|
2012-03-31 21:46:22 +04:00
|
|
|
/* Parse the URL path */
|
2013-02-17 03:37:50 +04:00
|
|
|
result = pop3_parse_url_path(conn);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2012-03-31 21:46:22 +04:00
|
|
|
/* Parse the custom request */
|
2013-02-17 03:37:50 +04:00
|
|
|
result = pop3_parse_custom_request(conn);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2012-03-31 21:46:22 +04:00
|
|
|
|
2013-02-17 03:37:50 +04:00
|
|
|
result = pop3_regular_transfer(conn, done);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-02-17 03:37:50 +04:00
|
|
|
return result;
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_disconnect()
|
|
|
|
*
|
|
|
|
* Disconnect from an POP3 server. Cleanup protocol-specific per-connection
|
|
|
|
* resources. BLOCKING.
|
|
|
|
*/
|
2013-10-18 22:28:20 +04:00
|
|
|
static CURLcode pop3_disconnect(struct connectdata *conn, bool dead_connection)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2012-06-02 14:55:58 +04:00
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
/* We cannot send quit unconditionally. If this connection is stale or
|
|
|
|
bad in any way, sending quit and waiting around here will make the
|
2013-02-24 00:02:05 +04:00
|
|
|
disconnect wait in vain and cause more problems than we need to. */
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
/* The POP3 session may or may not have been allocated/setup at this
|
|
|
|
point! */
|
2013-10-18 22:28:20 +04:00
|
|
|
if(!dead_connection && pop3c->pp.conn && pop3c->pp.conn->bits.protoconnstart)
|
2013-04-14 12:53:07 +04:00
|
|
|
if(!pop3_perform_quit(conn))
|
2018-12-14 11:21:47 +03:00
|
|
|
(void)pop3_block_statemach(conn, TRUE); /* ignore errors on QUIT */
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2012-06-09 22:21:44 +04:00
|
|
|
/* Disconnect from the server */
|
2009-12-13 00:54:01 +03:00
|
|
|
Curl_pp_disconnect(&pop3c->pp);
|
|
|
|
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Cleanup the SASL module */
|
2015-01-20 16:14:26 +03:00
|
|
|
Curl_sasl_cleanup(conn, pop3c->sasl.authused);
|
2012-06-02 14:55:58 +04:00
|
|
|
|
2012-06-09 22:21:44 +04:00
|
|
|
/* Cleanup our connection based variables */
|
|
|
|
Curl_safefree(pop3c->apoptimestamp);
|
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2012-06-05 01:15:51 +04:00
|
|
|
/* Call this when the DO phase has completed */
|
2012-05-27 13:54:13 +04:00
|
|
|
static CURLcode pop3_dophase_done(struct connectdata *conn, bool connected)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2013-03-14 00:19:43 +04:00
|
|
|
(void)conn;
|
2010-04-17 01:43:04 +04:00
|
|
|
(void)connected;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2010-04-17 01:43:04 +04:00
|
|
|
return CURLE_OK;
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
|
|
|
|
2013-01-04 05:50:28 +04:00
|
|
|
/* Called from multi.c while DOing */
|
2012-05-27 13:54:13 +04:00
|
|
|
static CURLcode pop3_doing(struct connectdata *conn, bool *dophase_done)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2012-12-30 03:26:17 +04:00
|
|
|
CURLcode result = pop3_multi_statemach(conn, dophase_done);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2012-12-30 03:26:17 +04:00
|
|
|
if(result)
|
|
|
|
DEBUGF(infof(conn->data, "DO phase failed\n"));
|
2013-03-09 03:02:20 +04:00
|
|
|
else if(*dophase_done) {
|
|
|
|
result = pop3_dophase_done(conn, FALSE /* not connected */);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-03-09 03:02:20 +04:00
|
|
|
DEBUGF(infof(conn->data, "DO phase is complete\n"));
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
2012-03-24 16:28:11 +04:00
|
|
|
|
2009-12-13 00:54:01 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_regular_transfer()
|
|
|
|
*
|
|
|
|
* The input argument is already checked for validity.
|
|
|
|
*
|
|
|
|
* Performs all commands done before a regular transfer between a local and a
|
|
|
|
* remote host.
|
|
|
|
*/
|
2012-03-24 16:28:11 +04:00
|
|
|
static CURLcode pop3_regular_transfer(struct connectdata *conn,
|
|
|
|
bool *dophase_done)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2012-03-25 14:28:59 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
bool connected = FALSE;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2012-06-05 01:15:51 +04:00
|
|
|
|
|
|
|
/* Make sure size is unknown at this point */
|
|
|
|
data->req.size = -1;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-03-09 03:25:04 +04:00
|
|
|
/* Set the progress data */
|
2009-12-13 00:54:01 +03:00
|
|
|
Curl_pgrsSetUploadCounter(data, 0);
|
|
|
|
Curl_pgrsSetDownloadCounter(data, 0);
|
2014-08-30 01:48:03 +04:00
|
|
|
Curl_pgrsSetUploadSize(data, -1);
|
|
|
|
Curl_pgrsSetDownloadSize(data, -1);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-03-09 03:25:04 +04:00
|
|
|
/* Carry out the perform */
|
2012-05-28 23:21:52 +04:00
|
|
|
result = pop3_perform(conn, &connected, dophase_done);
|
2009-12-13 00:54:01 +03:00
|
|
|
|
2013-03-09 03:25:04 +04:00
|
|
|
/* Perform post DO phase operations if necessary */
|
|
|
|
if(!result && *dophase_done)
|
2009-12-13 00:54:01 +03:00
|
|
|
result = pop3_dophase_done(conn, connected);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-03-01 01:22:49 +04:00
|
|
|
static CURLcode pop3_setup_connection(struct connectdata *conn)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2013-08-04 21:34:16 +04:00
|
|
|
/* Initialise the POP3 layer */
|
|
|
|
CURLcode result = pop3_init(conn);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
2016-03-05 23:10:11 +03:00
|
|
|
/* Clear the TLS upgraded flag */
|
|
|
|
conn->tls_upgraded = FALSE;
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2013-04-13 19:09:28 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_parse_url_options()
|
|
|
|
*
|
|
|
|
* Parse the URL login options.
|
|
|
|
*/
|
|
|
|
static CURLcode pop3_parse_url_options(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2015-01-20 17:27:25 +03:00
|
|
|
const char *ptr = conn->options;
|
|
|
|
|
|
|
|
pop3c->sasl.resetprefs = TRUE;
|
2013-04-13 19:09:28 +04:00
|
|
|
|
2015-01-20 17:27:25 +03:00
|
|
|
while(!result && ptr && *ptr) {
|
2013-04-13 19:09:28 +04:00
|
|
|
const char *key = ptr;
|
2015-01-20 17:27:25 +03:00
|
|
|
const char *value;
|
2013-04-13 19:09:28 +04:00
|
|
|
|
|
|
|
while(*ptr && *ptr != '=')
|
|
|
|
ptr++;
|
|
|
|
|
2015-01-20 17:27:25 +03:00
|
|
|
value = ptr + 1;
|
2013-04-13 19:09:28 +04:00
|
|
|
|
2015-01-20 17:27:25 +03:00
|
|
|
while(*ptr && *ptr != ';')
|
|
|
|
ptr++;
|
2013-12-22 03:34:45 +04:00
|
|
|
|
2016-09-30 18:15:05 +03:00
|
|
|
if(strncasecompare(key, "AUTH=", 5)) {
|
2015-01-20 17:27:25 +03:00
|
|
|
result = Curl_sasl_parse_url_auth_option(&pop3c->sasl,
|
|
|
|
value, ptr - value);
|
2013-12-22 03:34:45 +04:00
|
|
|
|
2016-09-30 18:15:05 +03:00
|
|
|
if(result && strncasecompare(value, "+APOP", ptr - value)) {
|
2013-04-13 19:09:28 +04:00
|
|
|
pop3c->preftype = POP3_TYPE_APOP;
|
2015-01-20 16:14:26 +03:00
|
|
|
pop3c->sasl.prefmech = SASL_AUTH_NONE;
|
2015-01-20 17:27:25 +03:00
|
|
|
result = CURLE_OK;
|
2013-04-13 19:09:28 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
result = CURLE_URL_MALFORMAT;
|
2015-01-20 17:27:25 +03:00
|
|
|
|
|
|
|
if(*ptr == ';')
|
|
|
|
ptr++;
|
2013-04-13 19:09:28 +04:00
|
|
|
}
|
|
|
|
|
2015-01-20 17:27:25 +03:00
|
|
|
if(pop3c->preftype != POP3_TYPE_APOP)
|
|
|
|
switch(pop3c->sasl.prefmech) {
|
|
|
|
case SASL_AUTH_NONE:
|
|
|
|
pop3c->preftype = POP3_TYPE_NONE;
|
|
|
|
break;
|
2015-01-27 19:24:55 +03:00
|
|
|
case SASL_AUTH_DEFAULT:
|
2015-01-20 17:27:25 +03:00
|
|
|
pop3c->preftype = POP3_TYPE_ANY;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pop3c->preftype = POP3_TYPE_SASL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-04-13 19:09:28 +04:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-04-12 23:16:57 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_parse_url_path()
|
|
|
|
*
|
|
|
|
* Parse the URL path into separate path components.
|
|
|
|
*/
|
|
|
|
static CURLcode pop3_parse_url_path(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
/* The POP3 struct is already initialised in pop3_connect() */
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-08-05 12:32:08 +04:00
|
|
|
struct POP3 *pop3 = data->req.protop;
|
2018-09-15 00:33:28 +03:00
|
|
|
const char *path = &data->state.up.path[1]; /* skip leading path */
|
2013-04-12 23:16:57 +04:00
|
|
|
|
|
|
|
/* URL decode the path for the message ID */
|
|
|
|
return Curl_urldecode(data, path, 0, &pop3->id, NULL, TRUE);
|
|
|
|
}
|
|
|
|
|
2013-04-12 23:18:37 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* pop3_parse_custom_request()
|
|
|
|
*
|
|
|
|
* Parse the custom request.
|
|
|
|
*/
|
2013-04-12 23:16:57 +04:00
|
|
|
static CURLcode pop3_parse_custom_request(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2013-08-05 12:32:08 +04:00
|
|
|
struct POP3 *pop3 = data->req.protop;
|
2013-04-12 23:16:57 +04:00
|
|
|
const char *custom = data->set.str[STRING_CUSTOMREQUEST];
|
|
|
|
|
|
|
|
/* URL decode the custom request */
|
|
|
|
if(custom)
|
|
|
|
result = Curl_urldecode(data, custom, 0, &pop3->custom, NULL, TRUE);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-04-12 23:20:27 +04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Curl_pop3_write()
|
|
|
|
*
|
|
|
|
* This function scans the body after the end-of-body and writes everything
|
|
|
|
* until the end is found.
|
|
|
|
*/
|
2012-05-28 23:21:52 +04:00
|
|
|
CURLcode Curl_pop3_write(struct connectdata *conn, char *str, size_t nread)
|
2009-12-13 00:54:01 +03:00
|
|
|
{
|
2012-02-19 02:57:13 +04:00
|
|
|
/* This code could be made into a special function in the handler struct */
|
2011-12-13 18:58:02 +04:00
|
|
|
CURLcode result = CURLE_OK;
|
2016-06-21 16:47:12 +03:00
|
|
|
struct Curl_easy *data = conn->data;
|
2009-12-13 00:54:01 +03:00
|
|
|
struct SingleRequest *k = &data->req;
|
|
|
|
|
|
|
|
struct pop3_conn *pop3c = &conn->proto.pop3c;
|
2011-11-30 22:23:09 +04:00
|
|
|
bool strip_dot = FALSE;
|
|
|
|
size_t last = 0;
|
2011-11-29 23:28:49 +04:00
|
|
|
size_t i;
|
2011-11-29 02:02:35 +04:00
|
|
|
|
2011-11-30 22:23:09 +04:00
|
|
|
/* Search through the buffer looking for the end-of-body marker which is
|
|
|
|
5 bytes (0d 0a 2e 0d 0a). Note that a line starting with a dot matches
|
|
|
|
the eob so the server will have prefixed it with an extra dot which we
|
|
|
|
need to strip out. Additionally the marker could of course be spread out
|
2013-02-24 00:02:05 +04:00
|
|
|
over 5 different data chunks. */
|
2011-11-30 22:23:09 +04:00
|
|
|
for(i = 0; i < nread; i++) {
|
2011-11-29 02:02:35 +04:00
|
|
|
size_t prev = pop3c->eob;
|
2011-11-30 22:23:09 +04:00
|
|
|
|
2011-11-29 02:02:35 +04:00
|
|
|
switch(str[i]) {
|
|
|
|
case 0x0d:
|
2011-11-30 22:23:09 +04:00
|
|
|
if(pop3c->eob == 0) {
|
|
|
|
pop3c->eob++;
|
|
|
|
|
|
|
|
if(i) {
|
|
|
|
/* Write out the body part that didn't match */
|
|
|
|
result = Curl_client_write(conn, CLIENTWRITE_BODY, &str[last],
|
|
|
|
i - last);
|
|
|
|
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
last = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(pop3c->eob == 3)
|
2011-11-29 02:02:35 +04:00
|
|
|
pop3c->eob++;
|
|
|
|
else
|
2011-11-30 22:23:09 +04:00
|
|
|
/* If the character match wasn't at position 0 or 3 then restart the
|
|
|
|
pattern matching */
|
|
|
|
pop3c->eob = 1;
|
2011-11-29 02:02:35 +04:00
|
|
|
break;
|
2011-11-30 22:23:09 +04:00
|
|
|
|
2011-11-29 02:02:35 +04:00
|
|
|
case 0x0a:
|
2011-11-30 22:23:09 +04:00
|
|
|
if(pop3c->eob == 1 || pop3c->eob == 4)
|
2011-11-29 02:02:35 +04:00
|
|
|
pop3c->eob++;
|
|
|
|
else
|
2011-11-30 22:23:09 +04:00
|
|
|
/* If the character match wasn't at position 1 or 4 then start the
|
|
|
|
search again */
|
|
|
|
pop3c->eob = 0;
|
2011-11-29 02:02:35 +04:00
|
|
|
break;
|
2011-11-30 22:23:09 +04:00
|
|
|
|
2011-11-29 02:02:35 +04:00
|
|
|
case 0x2e:
|
|
|
|
if(pop3c->eob == 2)
|
|
|
|
pop3c->eob++;
|
2011-11-30 22:23:09 +04:00
|
|
|
else if(pop3c->eob == 3) {
|
|
|
|
/* We have an extra dot after the CRLF which we need to strip off */
|
|
|
|
strip_dot = TRUE;
|
|
|
|
pop3c->eob = 0;
|
|
|
|
}
|
2011-11-29 02:02:35 +04:00
|
|
|
else
|
2011-11-30 22:23:09 +04:00
|
|
|
/* If the character match wasn't at position 2 then start the search
|
|
|
|
again */
|
|
|
|
pop3c->eob = 0;
|
2011-11-29 02:02:35 +04:00
|
|
|
break;
|
2011-11-30 22:23:09 +04:00
|
|
|
|
2011-11-29 02:02:35 +04:00
|
|
|
default:
|
2009-12-13 00:54:01 +03:00
|
|
|
pop3c->eob = 0;
|
2011-11-30 22:23:09 +04:00
|
|
|
break;
|
2011-11-29 02:02:35 +04:00
|
|
|
}
|
2011-11-29 16:43:46 +04:00
|
|
|
|
2011-11-30 22:23:09 +04:00
|
|
|
/* Did we have a partial match which has subsequently failed? */
|
|
|
|
if(prev && prev >= pop3c->eob) {
|
|
|
|
/* Strip can only be non-zero for the very first mismatch after CRLF
|
|
|
|
and then both prev and strip are equal and nothing will be output
|
2011-11-29 16:43:46 +04:00
|
|
|
below */
|
|
|
|
while(prev && pop3c->strip) {
|
|
|
|
prev--;
|
|
|
|
pop3c->strip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(prev) {
|
2011-11-30 22:23:09 +04:00
|
|
|
/* If the partial match was the CRLF and dot then only write the CRLF
|
|
|
|
as the server would have inserted the dot */
|
2016-11-23 10:30:18 +03:00
|
|
|
result = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)POP3_EOB,
|
2011-11-30 22:23:09 +04:00
|
|
|
strip_dot ? prev - 1 : prev);
|
|
|
|
|
2011-11-29 16:43:46 +04:00
|
|
|
if(result)
|
|
|
|
return result;
|
2011-11-30 22:23:09 +04:00
|
|
|
|
|
|
|
last = i;
|
|
|
|
strip_dot = FALSE;
|
2011-11-29 16:43:46 +04:00
|
|
|
}
|
2009-12-13 00:54:01 +03:00
|
|
|
}
|
|
|
|
}
|
2011-11-29 02:02:35 +04:00
|
|
|
|
2011-11-30 22:23:09 +04:00
|
|
|
if(pop3c->eob == POP3_EOB_LEN) {
|
2012-02-19 02:57:13 +04:00
|
|
|
/* We have a full match so the transfer is done, however we must transfer
|
|
|
|
the CRLF at the start of the EOB as this is considered to be part of the
|
|
|
|
message as per RFC-1939, sect. 3 */
|
2012-05-28 23:21:52 +04:00
|
|
|
result = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)POP3_EOB, 2);
|
2012-02-19 02:57:13 +04:00
|
|
|
|
2011-11-30 22:23:09 +04:00
|
|
|
k->keepon &= ~KEEP_RECV;
|
|
|
|
pop3c->eob = 0;
|
2012-02-19 02:57:13 +04:00
|
|
|
|
|
|
|
return result;
|
2011-11-29 16:43:46 +04:00
|
|
|
}
|
|
|
|
|
2011-11-30 22:23:09 +04:00
|
|
|
if(pop3c->eob)
|
|
|
|
/* While EOB is matching nothing should be output */
|
|
|
|
return CURLE_OK;
|
|
|
|
|
|
|
|
if(nread - last) {
|
|
|
|
result = Curl_client_write(conn, CLIENTWRITE_BODY, &str[last],
|
|
|
|
nread - last);
|
2011-11-29 16:43:46 +04:00
|
|
|
}
|
2009-12-13 00:54:01 +03:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CURL_DISABLE_POP3 */
|