1 /***************************************************************************
3 * Project ___| | | | _ \| |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
8 * Copyright (C) 1998 - 2013, Daniel Stenberg, <daniel@haxx.se>, et al.
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at http://curl.haxx.se/docs/copyright.html.
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.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
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 * RFC5034 POP3 SASL Authentication Mechanism
32 ***************************************************************************/
34 #include "curl_setup.h"
36 #ifndef CURL_DISABLE_POP3
38 #ifdef HAVE_NETINET_IN_H
39 #include <netinet/in.h>
41 #ifdef HAVE_ARPA_INET_H
42 #include <arpa/inet.h>
45 #include <sys/utsname.h>
55 #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
57 #define in_addr_t unsigned long
60 #include <curl/curl.h>
68 #include "http.h" /* for HTTP proxy tunnel stuff */
72 #include "strtoofft.h"
81 #include "curl_sasl.h"
85 #define _MPRINTF_REPLACE /* use our functions only */
86 #include <curl/mprintf.h>
88 #include "curl_memory.h"
89 /* The last #include file should be: */
92 /* Local API functions */
93 static CURLcode pop3_regular_transfer(struct connectdata *conn, bool *done);
94 static CURLcode pop3_do(struct connectdata *conn, bool *done);
95 static CURLcode pop3_done(struct connectdata *conn, CURLcode status,
97 static CURLcode pop3_connect(struct connectdata *conn, bool *done);
98 static CURLcode pop3_disconnect(struct connectdata *conn, bool dead);
99 static CURLcode pop3_multi_statemach(struct connectdata *conn, bool *done);
100 static int pop3_getsock(struct connectdata *conn, curl_socket_t *socks,
102 static CURLcode pop3_doing(struct connectdata *conn, bool *dophase_done);
103 static CURLcode pop3_setup_connection(struct connectdata *conn);
104 static CURLcode pop3_parse_url_options(struct connectdata *conn);
105 static CURLcode pop3_parse_url_path(struct connectdata *conn);
106 static CURLcode pop3_parse_custom_request(struct connectdata *conn);
109 * POP3 protocol handler.
112 const struct Curl_handler Curl_handler_pop3 = {
114 pop3_setup_connection, /* setup_connection */
116 pop3_done, /* done */
117 ZERO_NULL, /* do_more */
118 pop3_connect, /* connect_it */
119 pop3_multi_statemach, /* connecting */
120 pop3_doing, /* doing */
121 pop3_getsock, /* proto_getsock */
122 pop3_getsock, /* doing_getsock */
123 ZERO_NULL, /* domore_getsock */
124 ZERO_NULL, /* perform_getsock */
125 pop3_disconnect, /* disconnect */
126 ZERO_NULL, /* readwrite */
127 PORT_POP3, /* defport */
128 CURLPROTO_POP3, /* protocol */
129 PROTOPT_CLOSEACTION | PROTOPT_NOURLQUERY /* flags */
134 * POP3S protocol handler.
137 const struct Curl_handler Curl_handler_pop3s = {
138 "POP3S", /* scheme */
139 pop3_setup_connection, /* setup_connection */
141 pop3_done, /* done */
142 ZERO_NULL, /* do_more */
143 pop3_connect, /* connect_it */
144 pop3_multi_statemach, /* connecting */
145 pop3_doing, /* doing */
146 pop3_getsock, /* proto_getsock */
147 pop3_getsock, /* doing_getsock */
148 ZERO_NULL, /* domore_getsock */
149 ZERO_NULL, /* perform_getsock */
150 pop3_disconnect, /* disconnect */
151 ZERO_NULL, /* readwrite */
152 PORT_POP3S, /* defport */
153 CURLPROTO_POP3 | CURLPROTO_POP3S, /* protocol */
154 PROTOPT_CLOSEACTION | PROTOPT_SSL
155 | PROTOPT_NOURLQUERY /* flags */
159 #ifndef CURL_DISABLE_HTTP
161 * HTTP-proxyed POP3 protocol handler.
164 static const struct Curl_handler Curl_handler_pop3_proxy = {
166 ZERO_NULL, /* setup_connection */
167 Curl_http, /* do_it */
168 Curl_http_done, /* done */
169 ZERO_NULL, /* do_more */
170 ZERO_NULL, /* connect_it */
171 ZERO_NULL, /* connecting */
172 ZERO_NULL, /* doing */
173 ZERO_NULL, /* proto_getsock */
174 ZERO_NULL, /* doing_getsock */
175 ZERO_NULL, /* domore_getsock */
176 ZERO_NULL, /* perform_getsock */
177 ZERO_NULL, /* disconnect */
178 ZERO_NULL, /* readwrite */
179 PORT_POP3, /* defport */
180 CURLPROTO_HTTP, /* protocol */
181 PROTOPT_NONE /* flags */
186 * HTTP-proxyed POP3S protocol handler.
189 static const struct Curl_handler Curl_handler_pop3s_proxy = {
190 "POP3S", /* scheme */
191 ZERO_NULL, /* setup_connection */
192 Curl_http, /* do_it */
193 Curl_http_done, /* done */
194 ZERO_NULL, /* do_more */
195 ZERO_NULL, /* connect_it */
196 ZERO_NULL, /* connecting */
197 ZERO_NULL, /* doing */
198 ZERO_NULL, /* proto_getsock */
199 ZERO_NULL, /* doing_getsock */
200 ZERO_NULL, /* domore_getsock */
201 ZERO_NULL, /* perform_getsock */
202 ZERO_NULL, /* disconnect */
203 ZERO_NULL, /* readwrite */
204 PORT_POP3S, /* defport */
205 CURLPROTO_HTTP, /* protocol */
206 PROTOPT_NONE /* flags */
212 static void pop3_to_pop3s(struct connectdata *conn)
214 conn->handler = &Curl_handler_pop3s;
217 #define pop3_to_pop3s(x) Curl_nop_stmt
220 /***********************************************************************
224 * Checks for an ending POP3 status code at the start of the given string, but
225 * also detects the APOP timestamp from the server greeting and various
226 * capabilities from the CAPA response including the supported authentication
227 * types and allowed SASL mechanisms.
229 static bool pop3_endofresp(struct connectdata *conn, char *line, size_t len,
232 struct pop3_conn *pop3c = &conn->proto.pop3c;
236 /* Do we have an error response? */
237 if(len >= 4 && !memcmp("-ERR", line, 4)) {
243 /* Are we processing servergreet responses? */
244 if(pop3c->state == POP3_SERVERGREET) {
245 /* Look for the APOP timestamp */
246 if(len >= 3 && line[len - 3] == '>') {
247 for(i = 0; i < len - 3; ++i) {
249 /* Calculate the length of the timestamp */
250 size_t timestamplen = len - 2 - i;
252 /* Allocate some memory for the timestamp */
253 pop3c->apoptimestamp = (char *)calloc(1, timestamplen + 1);
255 if(!pop3c->apoptimestamp)
258 /* Copy the timestamp */
259 memcpy(pop3c->apoptimestamp, line + i, timestamplen);
260 pop3c->apoptimestamp[timestamplen] = '\0';
266 /* Are we processing CAPA command responses? */
267 else if(pop3c->state == POP3_CAPA) {
268 /* Do we have the terminating line? */
269 if(len >= 1 && !memcmp(line, ".", 1)) {
275 /* Does the server support the STLS capability? */
276 if(len >= 4 && !memcmp(line, "STLS", 4))
277 pop3c->tls_supported = TRUE;
279 /* Does the server support clear text authentication? */
280 else if(len >= 4 && !memcmp(line, "USER", 4))
281 pop3c->authtypes |= POP3_TYPE_CLEARTEXT;
283 /* Does the server support APOP authentication? */
284 else if(len >= 4 && !memcmp(line, "APOP", 4))
285 pop3c->authtypes |= POP3_TYPE_APOP;
287 /* Does the server support SASL based authentication? */
288 else if(len >= 5 && !memcmp(line, "SASL ", 5)) {
289 pop3c->authtypes |= POP3_TYPE_SASL;
291 /* Advance past the SASL keyword */
295 /* Loop through the data line */
298 (*line == ' ' || *line == '\t' ||
299 *line == '\r' || *line == '\n')) {
308 /* Extract the word */
309 for(wordlen = 0; wordlen < len && line[wordlen] != ' ' &&
310 line[wordlen] != '\t' && line[wordlen] != '\r' &&
311 line[wordlen] != '\n';)
314 /* Test the word for a matching authentication mechanism */
315 if(wordlen == 5 && !memcmp(line, "LOGIN", 5))
316 pop3c->authmechs |= SASL_MECH_LOGIN;
317 else if(wordlen == 5 && !memcmp(line, "PLAIN", 5))
318 pop3c->authmechs |= SASL_MECH_PLAIN;
319 else if(wordlen == 8 && !memcmp(line, "CRAM-MD5", 8))
320 pop3c->authmechs |= SASL_MECH_CRAM_MD5;
321 else if(wordlen == 10 && !memcmp(line, "DIGEST-MD5", 10))
322 pop3c->authmechs |= SASL_MECH_DIGEST_MD5;
323 else if(wordlen == 6 && !memcmp(line, "GSSAPI", 6))
324 pop3c->authmechs |= SASL_MECH_GSSAPI;
325 else if(wordlen == 8 && !memcmp(line, "EXTERNAL", 8))
326 pop3c->authmechs |= SASL_MECH_EXTERNAL;
327 else if(wordlen == 4 && !memcmp(line, "NTLM", 4))
328 pop3c->authmechs |= SASL_MECH_NTLM;
338 /* Do we have a command or continuation response? */
339 if((len >= 3 && !memcmp("+OK", line, 3)) ||
340 (len >= 1 && !memcmp("+", line, 1))) {
346 return FALSE; /* Nothing for us */
349 /***********************************************************************
353 * This is the ONLY way to change POP3 state!
355 static void state(struct connectdata *conn, pop3state newstate)
357 struct pop3_conn *pop3c = &conn->proto.pop3c;
358 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
359 /* for debug purposes */
360 static const char * const names[] = {
371 "AUTH_DIGESTMD5_RESP",
373 "AUTH_NTLM_TYPE2MSG",
383 if(pop3c->state != newstate)
384 infof(conn->data, "POP3 %p state change from %s to %s\n",
385 (void *)pop3c, names[pop3c->state], names[newstate]);
388 pop3c->state = newstate;
391 /***********************************************************************
393 * pop3_perform_capa()
395 * Sends the CAPA command in order to obtain a list of server side supported
398 static CURLcode pop3_perform_capa(struct connectdata *conn)
400 CURLcode result = CURLE_OK;
401 struct pop3_conn *pop3c = &conn->proto.pop3c;
403 pop3c->authmechs = 0; /* No known authentication mechanisms yet */
404 pop3c->authused = 0; /* Clear the authentication mechanism used */
405 pop3c->tls_supported = FALSE; /* Clear the TLS capability */
407 /* Send the CAPA command */
408 result = Curl_pp_sendf(&pop3c->pp, "%s", "CAPA");
411 state(conn, POP3_CAPA);
416 /***********************************************************************
418 * pop3_perform_starttls()
420 * Sends the STLS command to start the upgrade to TLS.
422 static CURLcode pop3_perform_starttls(struct connectdata *conn)
424 CURLcode result = CURLE_OK;
426 /* Send the STLS command */
427 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "STLS");
430 state(conn, POP3_STARTTLS);
435 /***********************************************************************
437 * pop3_perform_upgrade_tls()
439 * Performs the upgrade to TLS.
441 static CURLcode pop3_perform_upgrade_tls(struct connectdata *conn)
443 CURLcode result = CURLE_OK;
444 struct pop3_conn *pop3c = &conn->proto.pop3c;
446 /* Start the SSL connection */
447 result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &pop3c->ssldone);
450 if(pop3c->state != POP3_UPGRADETLS)
451 state(conn, POP3_UPGRADETLS);
455 result = pop3_perform_capa(conn);
462 /***********************************************************************
464 * pop3_perform_user()
466 * Sends a clear text USER command to authenticate with.
468 static CURLcode pop3_perform_user(struct connectdata *conn)
470 CURLcode result = CURLE_OK;
472 /* Check we have a username and password to authenticate with and end the
473 connect phase if we don't */
474 if(!conn->bits.user_passwd) {
475 state(conn, POP3_STOP);
480 /* Send the USER command */
481 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "USER %s",
482 conn->user ? conn->user : "");
484 state(conn, POP3_USER);
489 #ifndef CURL_DISABLE_CRYPTO_AUTH
490 /***********************************************************************
492 * pop3_perform_apop()
494 * Sends an APOP command to authenticate with.
496 static CURLcode pop3_perform_apop(struct connectdata *conn)
498 CURLcode result = CURLE_OK;
499 struct pop3_conn *pop3c = &conn->proto.pop3c;
502 unsigned char digest[MD5_DIGEST_LEN];
503 char secret[2 * MD5_DIGEST_LEN + 1];
505 /* Check we have a username and password to authenticate with and end the
506 connect phase if we don't */
507 if(!conn->bits.user_passwd) {
508 state(conn, POP3_STOP);
513 /* Create the digest */
514 ctxt = Curl_MD5_init(Curl_DIGEST_MD5);
516 return CURLE_OUT_OF_MEMORY;
518 Curl_MD5_update(ctxt, (const unsigned char *) pop3c->apoptimestamp,
519 curlx_uztoui(strlen(pop3c->apoptimestamp)));
521 Curl_MD5_update(ctxt, (const unsigned char *) conn->passwd,
522 curlx_uztoui(strlen(conn->passwd)));
524 /* Finalise the digest */
525 Curl_MD5_final(ctxt, digest);
527 /* Convert the calculated 16 octet digest into a 32 byte hex string */
528 for(i = 0; i < MD5_DIGEST_LEN; i++)
529 snprintf(&secret[2 * i], 3, "%02x", digest[i]);
531 result = Curl_pp_sendf(&pop3c->pp, "APOP %s %s", conn->user, secret);
534 state(conn, POP3_APOP);
540 /***********************************************************************
542 * pop3_perform_authenticate()
544 * Sends an AUTH command allowing the client to login with the appropriate
545 * SASL authentication mechanism.
547 * Additionally, the function will perform fallback to APOP and USER commands
548 * should a common mechanism not be available between the client and server.
550 static CURLcode pop3_perform_authenticate(struct connectdata *conn)
552 CURLcode result = CURLE_OK;
553 struct SessionHandle *data = conn->data;
554 struct pop3_conn *pop3c = &conn->proto.pop3c;
555 const char *mech = NULL;
556 char *initresp = NULL;
558 pop3state state1 = POP3_STOP;
559 pop3state state2 = POP3_STOP;
561 /* Check we have a username and password to authenticate with and end the
562 connect phase if we don't */
563 if(!conn->bits.user_passwd) {
564 state(conn, POP3_STOP);
569 /* Calculate the supported authentication mechanism by decreasing order of
571 if(pop3c->authtypes & POP3_TYPE_SASL) {
572 #ifndef CURL_DISABLE_CRYPTO_AUTH
573 if((pop3c->authmechs & SASL_MECH_DIGEST_MD5) &&
574 (pop3c->prefmech & SASL_MECH_DIGEST_MD5)) {
576 state1 = POP3_AUTH_DIGESTMD5;
577 pop3c->authused = SASL_MECH_DIGEST_MD5;
579 else if((pop3c->authmechs & SASL_MECH_CRAM_MD5) &&
580 (pop3c->prefmech & SASL_MECH_CRAM_MD5)) {
582 state1 = POP3_AUTH_CRAMMD5;
583 pop3c->authused = SASL_MECH_CRAM_MD5;
588 if((pop3c->authmechs & SASL_MECH_NTLM) &&
589 (pop3c->prefmech & SASL_MECH_NTLM)) {
591 state1 = POP3_AUTH_NTLM;
592 state2 = POP3_AUTH_NTLM_TYPE2MSG;
593 pop3c->authused = SASL_MECH_NTLM;
595 if(data->set.sasl_ir)
596 result = Curl_sasl_create_ntlm_type1_message(conn->user, conn->passwd,
602 if((pop3c->authmechs & SASL_MECH_LOGIN) &&
603 (pop3c->prefmech & SASL_MECH_LOGIN)) {
605 state1 = POP3_AUTH_LOGIN;
606 state2 = POP3_AUTH_LOGIN_PASSWD;
607 pop3c->authused = SASL_MECH_LOGIN;
609 if(data->set.sasl_ir)
610 result = Curl_sasl_create_login_message(conn->data, conn->user,
613 else if((pop3c->authmechs & SASL_MECH_PLAIN) &&
614 (pop3c->prefmech & SASL_MECH_PLAIN)) {
616 state1 = POP3_AUTH_PLAIN;
617 state2 = POP3_AUTH_FINAL;
618 pop3c->authused = SASL_MECH_PLAIN;
620 if(data->set.sasl_ir)
621 result = Curl_sasl_create_plain_message(conn->data, conn->user,
622 conn->passwd, &initresp,
628 if(mech && (pop3c->preftype & POP3_TYPE_SASL)) {
629 /* Perform SASL based authentication */
631 8 + strlen(mech) + len <= 255) { /* AUTH <mech> ...<crlf> */
632 result = Curl_pp_sendf(&pop3c->pp, "AUTH %s %s", mech, initresp);
638 result = Curl_pp_sendf(&pop3c->pp, "AUTH %s", mech);
644 Curl_safefree(initresp);
646 #ifndef CURL_DISABLE_CRYPTO_AUTH
647 else if((pop3c->authtypes & POP3_TYPE_APOP) &&
648 (pop3c->preftype & POP3_TYPE_APOP))
649 /* Perform APOP authentication */
650 result = pop3_perform_apop(conn);
652 else if((pop3c->authtypes & POP3_TYPE_CLEARTEXT) &&
653 (pop3c->preftype & POP3_TYPE_CLEARTEXT))
654 /* Perform clear text authentication */
655 result = pop3_perform_user(conn);
657 /* Other mechanisms not supported */
658 infof(conn->data, "No known authentication mechanisms supported!\n");
659 result = CURLE_LOGIN_DENIED;
666 /***********************************************************************
668 * pop3_perform_command()
670 * Sends a POP3 based command.
672 static CURLcode pop3_perform_command(struct connectdata *conn)
674 CURLcode result = CURLE_OK;
675 struct SessionHandle *data = conn->data;
676 struct POP3 *pop3 = data->state.proto.pop3;
677 const char *command = NULL;
679 /* Calculate the default command */
680 if(pop3->id[0] == '\0' || conn->data->set.ftp_list_only) {
683 if(pop3->id[0] != '\0')
684 /* Message specific LIST so skip the BODY transfer */
685 pop3->transfer = FTPTRANSFER_INFO;
690 /* Send the command */
691 if(pop3->id[0] != '\0')
692 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s %s",
693 (pop3->custom && pop3->custom[0] != '\0' ?
694 pop3->custom : command), pop3->id);
696 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s",
697 (pop3->custom && pop3->custom[0] != '\0' ?
698 pop3->custom : command));
701 state(conn, POP3_COMMAND);
706 /***********************************************************************
708 * pop3_perform_quit()
710 * Performs the quit action prior to sclose() be called.
712 static CURLcode pop3_perform_quit(struct connectdata *conn)
714 CURLcode result = CURLE_OK;
716 /* Send the QUIT command */
717 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "QUIT");
720 state(conn, POP3_QUIT);
725 /* For the initial server greeting */
726 static CURLcode pop3_state_servergreet_resp(struct connectdata *conn,
730 CURLcode result = CURLE_OK;
731 struct SessionHandle *data = conn->data;
733 (void)instate; /* no use for this yet */
735 if(pop3code != '+') {
736 failf(data, "Got unexpected pop3-server response");
737 result = CURLE_FTP_WEIRD_SERVER_REPLY;
740 result = pop3_perform_capa(conn);
745 /* For CAPA responses */
746 static CURLcode pop3_state_capa_resp(struct connectdata *conn, int pop3code,
749 CURLcode result = CURLE_OK;
750 struct SessionHandle *data = conn->data;
751 struct pop3_conn *pop3c = &conn->proto.pop3c;
753 (void)instate; /* no use for this yet */
756 result = pop3_perform_user(conn);
757 else if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
758 /* We don't have a SSL/TLS connection yet, but SSL is requested */
759 if(pop3c->tls_supported)
760 /* Switch to TLS connection now */
761 result = pop3_perform_starttls(conn);
762 else if(data->set.use_ssl == CURLUSESSL_TRY)
763 /* Fallback and carry on with authentication */
764 result = pop3_perform_authenticate(conn);
766 failf(data, "STLS not supported.");
767 result = CURLE_USE_SSL_FAILED;
771 result = pop3_perform_authenticate(conn);
776 /* For STARTTLS responses */
777 static CURLcode pop3_state_starttls_resp(struct connectdata *conn,
781 CURLcode result = CURLE_OK;
782 struct SessionHandle *data = conn->data;
784 (void)instate; /* no use for this yet */
786 if(pop3code != '+') {
787 if(data->set.use_ssl != CURLUSESSL_TRY) {
788 failf(data, "STARTTLS denied. %c", pop3code);
789 result = CURLE_USE_SSL_FAILED;
792 result = pop3_perform_authenticate(conn);
795 result = pop3_perform_upgrade_tls(conn);
800 /* For AUTH PLAIN (without initial response) responses */
801 static CURLcode pop3_state_auth_plain_resp(struct connectdata *conn,
805 CURLcode result = CURLE_OK;
806 struct SessionHandle *data = conn->data;
808 char *plainauth = NULL;
810 (void)instate; /* no use for this yet */
812 if(pop3code != '+') {
813 failf(data, "Access denied. %c", pop3code);
814 result = CURLE_LOGIN_DENIED;
817 /* Create the authorisation message */
818 result = Curl_sasl_create_plain_message(data, conn->user, conn->passwd,
821 /* Send the message */
824 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", plainauth);
827 state(conn, POP3_AUTH_FINAL);
830 Curl_safefree(plainauth);
837 /* For AUTH LOGIN (without initial response) responses */
838 static CURLcode pop3_state_auth_login_resp(struct connectdata *conn,
842 CURLcode result = CURLE_OK;
843 struct SessionHandle *data = conn->data;
845 char *authuser = NULL;
847 (void)instate; /* no use for this yet */
849 if(pop3code != '+') {
850 failf(data, "Access denied: %d", pop3code);
851 result = CURLE_LOGIN_DENIED;
854 /* Create the user message */
855 result = Curl_sasl_create_login_message(data, conn->user,
861 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", authuser);
864 state(conn, POP3_AUTH_LOGIN_PASSWD);
867 Curl_safefree(authuser);
874 /* For AUTH LOGIN user entry responses */
875 static CURLcode pop3_state_auth_login_password_resp(struct connectdata *conn,
879 CURLcode result = CURLE_OK;
880 struct SessionHandle *data = conn->data;
882 char *authpasswd = NULL;
884 (void)instate; /* no use for this yet */
886 if(pop3code != '+') {
887 failf(data, "Access denied: %d", pop3code);
888 result = CURLE_LOGIN_DENIED;
891 /* Create the password message */
892 result = Curl_sasl_create_login_message(data, conn->passwd,
895 /* Send the password */
898 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", authpasswd);
901 state(conn, POP3_AUTH_FINAL);
904 Curl_safefree(authpasswd);
911 #ifndef CURL_DISABLE_CRYPTO_AUTH
912 /* For AUTH CRAM-MD5 responses */
913 static CURLcode pop3_state_auth_cram_resp(struct connectdata *conn,
917 CURLcode result = CURLE_OK;
918 struct SessionHandle *data = conn->data;
919 char *chlg64 = data->state.buffer;
921 char *rplyb64 = NULL;
923 (void)instate; /* no use for this yet */
925 if(pop3code != '+') {
926 failf(data, "Access denied: %d", pop3code);
927 return CURLE_LOGIN_DENIED;
930 /* Get the challenge */
931 for(chlg64 += 2; *chlg64 == ' ' || *chlg64 == '\t'; chlg64++)
934 /* Terminate the challenge */
936 for(len = strlen(chlg64); len--;)
937 if(chlg64[len] != '\r' && chlg64[len] != '\n' && chlg64[len] != ' ' &&
946 /* Create the response message */
947 result = Curl_sasl_create_cram_md5_message(data, chlg64, conn->user,
948 conn->passwd, &rplyb64, &len);
950 /* Send the response */
953 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", rplyb64);
956 state(conn, POP3_AUTH_FINAL);
959 Curl_safefree(rplyb64);
965 /* For AUTH DIGEST-MD5 challenge responses */
966 static CURLcode pop3_state_auth_digest_resp(struct connectdata *conn,
970 CURLcode result = CURLE_OK;
971 struct SessionHandle *data = conn->data;
972 char *chlg64 = data->state.buffer;
974 char *rplyb64 = NULL;
976 (void)instate; /* no use for this yet */
978 if(pop3code != '+') {
979 failf(data, "Access denied: %d", pop3code);
980 return CURLE_LOGIN_DENIED;
983 /* Get the challenge */
984 for(chlg64 += 2; *chlg64 == ' ' || *chlg64 == '\t'; chlg64++)
987 /* Create the response message */
988 result = Curl_sasl_create_digest_md5_message(data, chlg64, conn->user,
992 /* Send the response */
995 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", rplyb64);
998 state(conn, POP3_AUTH_DIGESTMD5_RESP);
1001 Curl_safefree(rplyb64);
1007 /* For AUTH DIGEST-MD5 challenge-response responses */
1008 static CURLcode pop3_state_auth_digest_resp_resp(struct connectdata *conn,
1012 CURLcode result = CURLE_OK;
1013 struct SessionHandle *data = conn->data;
1015 (void)instate; /* no use for this yet */
1017 if(pop3code != '+') {
1018 failf(data, "Authentication failed: %d", pop3code);
1019 result = CURLE_LOGIN_DENIED;
1022 /* Send an empty response */
1023 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "");
1026 state(conn, POP3_AUTH_FINAL);
1034 /* For AUTH NTLM (without initial response) responses */
1035 static CURLcode pop3_state_auth_ntlm_resp(struct connectdata *conn,
1039 CURLcode result = CURLE_OK;
1040 struct SessionHandle *data = conn->data;
1042 char *type1msg = NULL;
1044 (void)instate; /* no use for this yet */
1046 if(pop3code != '+') {
1047 failf(data, "Access denied: %d", pop3code);
1048 result = CURLE_LOGIN_DENIED;
1051 /* Create the type-1 message */
1052 result = Curl_sasl_create_ntlm_type1_message(conn->user, conn->passwd,
1056 /* Send the message */
1059 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", type1msg);
1062 state(conn, POP3_AUTH_NTLM_TYPE2MSG);
1065 Curl_safefree(type1msg);
1072 /* For NTLM type-2 responses (sent in reponse to our type-1 message) */
1073 static CURLcode pop3_state_auth_ntlm_type2msg_resp(struct connectdata *conn,
1077 CURLcode result = CURLE_OK;
1078 struct SessionHandle *data = conn->data;
1080 char *type3msg = NULL;
1082 (void)instate; /* no use for this yet */
1084 if(pop3code != '+') {
1085 failf(data, "Access denied: %d", pop3code);
1086 result = CURLE_LOGIN_DENIED;
1089 /* Create the type-3 message */
1090 result = Curl_sasl_create_ntlm_type3_message(data,
1091 data->state.buffer + 2,
1092 conn->user, conn->passwd,
1096 /* Send the message */
1099 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", type3msg);
1102 state(conn, POP3_AUTH_FINAL);
1105 Curl_safefree(type3msg);
1113 /* For final responses to the AUTH sequence */
1114 static CURLcode pop3_state_auth_final_resp(struct connectdata *conn,
1118 CURLcode result = CURLE_OK;
1119 struct SessionHandle *data = conn->data;
1121 (void)instate; /* no use for this yet */
1123 if(pop3code != '+') {
1124 failf(data, "Authentication failed: %d", pop3code);
1125 result = CURLE_LOGIN_DENIED;
1128 /* End of connect phase */
1129 state(conn, POP3_STOP);
1134 #ifndef CURL_DISABLE_CRYPTO_AUTH
1135 /* For APOP responses */
1136 static CURLcode pop3_state_apop_resp(struct connectdata *conn, int pop3code,
1139 CURLcode result = CURLE_OK;
1140 struct SessionHandle *data = conn->data;
1142 (void)instate; /* no use for this yet */
1144 if(pop3code != '+') {
1145 failf(data, "Authentication failed: %d", pop3code);
1146 result = CURLE_LOGIN_DENIED;
1149 /* End of connect phase */
1150 state(conn, POP3_STOP);
1156 /* For USER responses */
1157 static CURLcode pop3_state_user_resp(struct connectdata *conn, int pop3code,
1160 CURLcode result = CURLE_OK;
1161 struct SessionHandle *data = conn->data;
1163 (void)instate; /* no use for this yet */
1165 if(pop3code != '+') {
1166 failf(data, "Access denied. %c", pop3code);
1167 result = CURLE_LOGIN_DENIED;
1170 /* Send the PASS command */
1171 result = Curl_pp_sendf(&conn->proto.pop3c.pp, "PASS %s",
1172 conn->passwd ? conn->passwd : "");
1174 state(conn, POP3_PASS);
1179 /* For PASS responses */
1180 static CURLcode pop3_state_pass_resp(struct connectdata *conn, int pop3code,
1183 CURLcode result = CURLE_OK;
1184 struct SessionHandle *data = conn->data;
1186 (void)instate; /* no use for this yet */
1188 if(pop3code != '+') {
1189 failf(data, "Access denied. %c", pop3code);
1190 result = CURLE_LOGIN_DENIED;
1193 /* End of connect phase */
1194 state(conn, POP3_STOP);
1199 /* For command responses */
1200 static CURLcode pop3_state_command_resp(struct connectdata *conn,
1204 CURLcode result = CURLE_OK;
1205 struct SessionHandle *data = conn->data;
1206 struct POP3 *pop3 = data->state.proto.pop3;
1207 struct pop3_conn *pop3c = &conn->proto.pop3c;
1208 struct pingpong *pp = &pop3c->pp;
1210 (void)instate; /* no use for this yet */
1212 if(pop3code != '+') {
1213 state(conn, POP3_STOP);
1214 return CURLE_RECV_ERROR;
1217 /* This 'OK' line ends with a CR LF pair which is the two first bytes of the
1218 EOB string so count this is two matching bytes. This is necessary to make
1219 the code detect the EOB if the only data than comes now is %2e CR LF like
1220 when there is no body to return. */
1223 /* But since this initial CR LF pair is not part of the actual body, we set
1224 the strip counter here so that these bytes won't be delivered. */
1227 if(pop3->transfer == FTPTRANSFER_BODY) {
1229 Curl_setup_transfer(conn, FIRSTSOCKET, -1, FALSE, NULL, -1, NULL);
1232 /* The header "cache" contains a bunch of data that is actually body
1233 content so send it as such. Note that there may even be additional
1234 "headers" after the body */
1236 if(!data->set.opt_no_body) {
1237 result = Curl_pop3_write(conn, pp->cache, pp->cache_size);
1242 /* Free the cache */
1243 Curl_safefree(pp->cache);
1245 /* Reset the cache size */
1250 /* End of DO phase */
1251 state(conn, POP3_STOP);
1256 static CURLcode pop3_statemach_act(struct connectdata *conn)
1258 CURLcode result = CURLE_OK;
1259 curl_socket_t sock = conn->sock[FIRSTSOCKET];
1261 struct pop3_conn *pop3c = &conn->proto.pop3c;
1262 struct pingpong *pp = &pop3c->pp;
1265 /* Busy upgrading the connection; right now all I/O is SSL/TLS, not POP3 */
1266 if(pop3c->state == POP3_UPGRADETLS)
1267 return pop3_perform_upgrade_tls(conn);
1269 /* Flush any data that needs to be sent */
1271 return Curl_pp_flushsend(pp);
1273 /* Read the response from the server */
1274 result = Curl_pp_readresp(sock, pp, &pop3code, &nread);
1279 /* We have now received a full POP3 server response */
1280 switch(pop3c->state) {
1281 case POP3_SERVERGREET:
1282 result = pop3_state_servergreet_resp(conn, pop3code, pop3c->state);
1286 result = pop3_state_capa_resp(conn, pop3code, pop3c->state);
1290 result = pop3_state_starttls_resp(conn, pop3code, pop3c->state);
1293 case POP3_AUTH_PLAIN:
1294 result = pop3_state_auth_plain_resp(conn, pop3code, pop3c->state);
1297 case POP3_AUTH_LOGIN:
1298 result = pop3_state_auth_login_resp(conn, pop3code, pop3c->state);
1301 case POP3_AUTH_LOGIN_PASSWD:
1302 result = pop3_state_auth_login_password_resp(conn, pop3code,
1306 #ifndef CURL_DISABLE_CRYPTO_AUTH
1307 case POP3_AUTH_CRAMMD5:
1308 result = pop3_state_auth_cram_resp(conn, pop3code, pop3c->state);
1311 case POP3_AUTH_DIGESTMD5:
1312 result = pop3_state_auth_digest_resp(conn, pop3code, pop3c->state);
1315 case POP3_AUTH_DIGESTMD5_RESP:
1316 result = pop3_state_auth_digest_resp_resp(conn, pop3code, pop3c->state);
1321 case POP3_AUTH_NTLM:
1322 result = pop3_state_auth_ntlm_resp(conn, pop3code, pop3c->state);
1325 case POP3_AUTH_NTLM_TYPE2MSG:
1326 result = pop3_state_auth_ntlm_type2msg_resp(conn, pop3code,
1331 case POP3_AUTH_FINAL:
1332 result = pop3_state_auth_final_resp(conn, pop3code, pop3c->state);
1335 #ifndef CURL_DISABLE_CRYPTO_AUTH
1337 result = pop3_state_apop_resp(conn, pop3code, pop3c->state);
1342 result = pop3_state_user_resp(conn, pop3code, pop3c->state);
1346 result = pop3_state_pass_resp(conn, pop3code, pop3c->state);
1350 result = pop3_state_command_resp(conn, pop3code, pop3c->state);
1354 /* fallthrough, just stop! */
1356 /* internal error */
1357 state(conn, POP3_STOP);
1365 /* Called repeatedly until done from multi.c */
1366 static CURLcode pop3_multi_statemach(struct connectdata *conn, bool *done)
1368 CURLcode result = CURLE_OK;
1369 struct pop3_conn *pop3c = &conn->proto.pop3c;
1371 if((conn->handler->flags & PROTOPT_SSL) && !pop3c->ssldone)
1372 result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &pop3c->ssldone);
1374 result = Curl_pp_statemach(&pop3c->pp, FALSE);
1376 *done = (pop3c->state == POP3_STOP) ? TRUE : FALSE;
1381 static CURLcode pop3_block_statemach(struct connectdata *conn)
1383 CURLcode result = CURLE_OK;
1384 struct pop3_conn *pop3c = &conn->proto.pop3c;
1386 while(pop3c->state != POP3_STOP && !result)
1387 result = Curl_pp_statemach(&pop3c->pp, TRUE);
1392 /* Allocate and initialize the POP3 struct for the current SessionHandle if
1394 static CURLcode pop3_init(struct connectdata *conn)
1396 CURLcode result = CURLE_OK;
1397 struct SessionHandle *data = conn->data;
1398 struct POP3 *pop3 = data->state.proto.pop3;
1401 pop3 = data->state.proto.pop3 = calloc(sizeof(struct POP3), 1);
1403 result = CURLE_OUT_OF_MEMORY;
1409 /* For the POP3 "protocol connect" and "doing" phases only */
1410 static int pop3_getsock(struct connectdata *conn, curl_socket_t *socks,
1413 return Curl_pp_getsock(&conn->proto.pop3c.pp, socks, numsocks);
1416 /***********************************************************************
1420 * This function should do everything that is to be considered a part of the
1423 * The variable 'done' points to will be TRUE if the protocol-layer connect
1424 * phase is done when this function returns, or FALSE if not.
1426 static CURLcode pop3_connect(struct connectdata *conn, bool *done)
1428 CURLcode result = CURLE_OK;
1429 struct pop3_conn *pop3c = &conn->proto.pop3c;
1430 struct pingpong *pp = &pop3c->pp;
1432 *done = FALSE; /* default to not done yet */
1434 /* If there already is a protocol-specific struct allocated for this
1435 sessionhandle, deal with it */
1436 Curl_reset_reqproto(conn);
1438 /* Initialise the POP3 layer */
1439 result = pop3_init(conn);
1443 /* We always support persistent connections in POP3 */
1444 conn->bits.close = FALSE;
1446 /* Set the default response time-out */
1447 pp->response_time = RESP_TIMEOUT;
1448 pp->statemach_act = pop3_statemach_act;
1449 pp->endofresp = pop3_endofresp;
1452 /* Set the default preferred authentication type and mechanism */
1453 pop3c->preftype = POP3_TYPE_ANY;
1454 pop3c->prefmech = SASL_AUTH_ANY;
1456 /* Initialise the pingpong layer */
1459 /* Parse the URL options */
1460 result = pop3_parse_url_options(conn);
1464 /* Start off waiting for the server greeting response */
1465 state(conn, POP3_SERVERGREET);
1467 result = pop3_multi_statemach(conn, done);
1472 /***********************************************************************
1476 * The DONE function. This does what needs to be done after a single DO has
1479 * Input argument is already checked for validity.
1481 static CURLcode pop3_done(struct connectdata *conn, CURLcode status,
1484 CURLcode result = CURLE_OK;
1485 struct SessionHandle *data = conn->data;
1486 struct POP3 *pop3 = data->state.proto.pop3;
1491 /* When the easy handle is removed from the multi interface while libcurl
1492 is still trying to resolve the host name, the POP3 struct is not yet
1493 initialized. However, the removal action calls Curl_done() which in
1494 turn calls this function, so we simply return success. */
1498 conn->bits.close = TRUE; /* marked for closure */
1499 result = status; /* use the already set error code */
1502 /* Cleanup our per-request based variables */
1503 Curl_safefree(pop3->id);
1504 Curl_safefree(pop3->custom);
1506 /* Clear the transfer mode for the next request */
1507 pop3->transfer = FTPTRANSFER_BODY;
1512 /***********************************************************************
1516 * This is the actual DO function for POP3. Get a message/listing according to
1517 * the options previously setup.
1519 static CURLcode pop3_perform(struct connectdata *conn, bool *connected,
1522 /* This is POP3 and no proxy */
1523 CURLcode result = CURLE_OK;
1525 DEBUGF(infof(conn->data, "DO phase starts\n"));
1527 if(conn->data->set.opt_no_body) {
1528 /* Requested no body means no transfer */
1529 struct POP3 *pop3 = conn->data->state.proto.pop3;
1530 pop3->transfer = FTPTRANSFER_INFO;
1533 *dophase_done = FALSE; /* not done yet */
1535 /* Start the first command in the DO phase */
1536 result = pop3_perform_command(conn);
1540 /* Run the state-machine */
1541 result = pop3_multi_statemach(conn, dophase_done);
1543 *connected = conn->bits.tcpconnect[FIRSTSOCKET];
1546 DEBUGF(infof(conn->data, "DO phase is complete\n"));
1551 /***********************************************************************
1555 * This function is registered as 'curl_do' function. It decodes the path
1556 * parts etc as a wrapper to the actual DO function (pop3_perform).
1558 * The input argument is already checked for validity.
1560 static CURLcode pop3_do(struct connectdata *conn, bool *done)
1562 CURLcode result = CURLE_OK;
1564 *done = FALSE; /* default to false */
1566 /* Since connections can be re-used between SessionHandles, there might be a
1567 connection already existing but on a fresh SessionHandle struct. As such
1568 we make sure we have a good POP3 struct to play with. For new connections
1569 the POP3 struct is allocated and setup in the pop3_connect() function. */
1570 Curl_reset_reqproto(conn);
1571 result = pop3_init(conn);
1575 /* Parse the URL path */
1576 result = pop3_parse_url_path(conn);
1580 /* Parse the custom request */
1581 result = pop3_parse_custom_request(conn);
1585 result = pop3_regular_transfer(conn, done);
1590 /***********************************************************************
1594 * Disconnect from an POP3 server. Cleanup protocol-specific per-connection
1595 * resources. BLOCKING.
1597 static CURLcode pop3_disconnect(struct connectdata *conn,
1598 bool dead_connection)
1600 struct pop3_conn *pop3c = &conn->proto.pop3c;
1602 /* We cannot send quit unconditionally. If this connection is stale or
1603 bad in any way, sending quit and waiting around here will make the
1604 disconnect wait in vain and cause more problems than we need to. */
1606 /* The POP3 session may or may not have been allocated/setup at this
1608 if(!dead_connection && pop3c->pp.conn)
1609 if(!pop3_perform_quit(conn))
1610 (void)pop3_block_statemach(conn); /* ignore errors on QUIT */
1612 /* Disconnect from the server */
1613 Curl_pp_disconnect(&pop3c->pp);
1615 /* Cleanup the SASL module */
1616 Curl_sasl_cleanup(conn, pop3c->authused);
1618 /* Cleanup our connection based variables */
1619 Curl_safefree(pop3c->apoptimestamp);
1624 /* Call this when the DO phase has completed */
1625 static CURLcode pop3_dophase_done(struct connectdata *conn, bool connected)
1633 /* Called from multi.c while DOing */
1634 static CURLcode pop3_doing(struct connectdata *conn, bool *dophase_done)
1636 CURLcode result = pop3_multi_statemach(conn, dophase_done);
1639 DEBUGF(infof(conn->data, "DO phase failed\n"));
1640 else if(*dophase_done) {
1641 result = pop3_dophase_done(conn, FALSE /* not connected */);
1643 DEBUGF(infof(conn->data, "DO phase is complete\n"));
1649 /***********************************************************************
1651 * pop3_regular_transfer()
1653 * The input argument is already checked for validity.
1655 * Performs all commands done before a regular transfer between a local and a
1658 static CURLcode pop3_regular_transfer(struct connectdata *conn,
1661 CURLcode result = CURLE_OK;
1662 bool connected = FALSE;
1663 struct SessionHandle *data = conn->data;
1665 /* Make sure size is unknown at this point */
1666 data->req.size = -1;
1668 /* Set the progress data */
1669 Curl_pgrsSetUploadCounter(data, 0);
1670 Curl_pgrsSetDownloadCounter(data, 0);
1671 Curl_pgrsSetUploadSize(data, 0);
1672 Curl_pgrsSetDownloadSize(data, 0);
1674 /* Carry out the perform */
1675 result = pop3_perform(conn, &connected, dophase_done);
1677 /* Perform post DO phase operations if necessary */
1678 if(!result && *dophase_done)
1679 result = pop3_dophase_done(conn, connected);
1684 static CURLcode pop3_setup_connection(struct connectdata *conn)
1686 struct SessionHandle *data = conn->data;
1688 if(conn->bits.httpproxy && !data->set.tunnel_thru_httpproxy) {
1689 /* Unless we have asked to tunnel POP3 operations through the proxy, we
1690 switch and use HTTP operations only */
1691 #ifndef CURL_DISABLE_HTTP
1692 if(conn->handler == &Curl_handler_pop3)
1693 conn->handler = &Curl_handler_pop3_proxy;
1696 conn->handler = &Curl_handler_pop3s_proxy;
1698 failf(data, "POP3S not supported!");
1699 return CURLE_UNSUPPORTED_PROTOCOL;
1703 /* We explicitly mark this connection as persistent here as we're doing
1704 POP3 over HTTP and thus we accidentally avoid setting this value
1706 conn->bits.close = FALSE;
1708 failf(data, "POP3 over http proxy requires HTTP support built-in!");
1709 return CURLE_UNSUPPORTED_PROTOCOL;
1713 data->state.path++; /* don't include the initial slash */
1718 /***********************************************************************
1720 * pop3_parse_url_options()
1722 * Parse the URL login options.
1724 static CURLcode pop3_parse_url_options(struct connectdata *conn)
1726 CURLcode result = CURLE_OK;
1727 struct pop3_conn *pop3c = &conn->proto.pop3c;
1728 const char *options = conn->options;
1729 const char *ptr = options;
1732 const char *key = ptr;
1734 while(*ptr && *ptr != '=')
1737 if(strnequal(key, "AUTH", 4)) {
1738 const char *value = ptr + 1;
1740 if(strequal(value, "*")) {
1741 pop3c->preftype = POP3_TYPE_ANY;
1742 pop3c->prefmech = SASL_AUTH_ANY;
1744 else if(strequal(value, "+APOP")) {
1745 pop3c->preftype = POP3_TYPE_APOP;
1746 pop3c->prefmech = SASL_AUTH_NONE;
1748 else if(strequal(value, "LOGIN")) {
1749 pop3c->preftype = POP3_TYPE_SASL;
1750 pop3c->prefmech = SASL_MECH_LOGIN;
1752 else if(strequal(value, "PLAIN")) {
1753 pop3c->preftype = POP3_TYPE_SASL;
1754 pop3c->prefmech = SASL_MECH_PLAIN;
1756 else if(strequal(value, "CRAM-MD5")) {
1757 pop3c->preftype = POP3_TYPE_SASL;
1758 pop3c->prefmech = SASL_MECH_CRAM_MD5;
1760 else if(strequal(value, "DIGEST-MD5")) {
1761 pop3c->preftype = POP3_TYPE_SASL;
1762 pop3c->prefmech = SASL_MECH_DIGEST_MD5;
1764 else if(strequal(value, "GSSAPI")) {
1765 pop3c->preftype = POP3_TYPE_SASL;
1766 pop3c->prefmech = SASL_MECH_GSSAPI;
1768 else if(strequal(value, "NTLM")) {
1769 pop3c->preftype = POP3_TYPE_SASL;
1770 pop3c->prefmech = SASL_MECH_NTLM;
1773 pop3c->preftype = POP3_TYPE_NONE;
1774 pop3c->prefmech = SASL_AUTH_NONE;
1778 result = CURLE_URL_MALFORMAT;
1784 /***********************************************************************
1786 * pop3_parse_url_path()
1788 * Parse the URL path into separate path components.
1790 static CURLcode pop3_parse_url_path(struct connectdata *conn)
1792 /* The POP3 struct is already initialised in pop3_connect() */
1793 struct SessionHandle *data = conn->data;
1794 struct POP3 *pop3 = data->state.proto.pop3;
1795 const char *path = data->state.path;
1797 /* URL decode the path for the message ID */
1798 return Curl_urldecode(data, path, 0, &pop3->id, NULL, TRUE);
1801 /***********************************************************************
1803 * pop3_parse_custom_request()
1805 * Parse the custom request.
1807 static CURLcode pop3_parse_custom_request(struct connectdata *conn)
1809 CURLcode result = CURLE_OK;
1810 struct SessionHandle *data = conn->data;
1811 struct POP3 *pop3 = data->state.proto.pop3;
1812 const char *custom = data->set.str[STRING_CUSTOMREQUEST];
1814 /* URL decode the custom request */
1816 result = Curl_urldecode(data, custom, 0, &pop3->custom, NULL, TRUE);
1821 /***********************************************************************
1825 * This function scans the body after the end-of-body and writes everything
1826 * until the end is found.
1828 CURLcode Curl_pop3_write(struct connectdata *conn, char *str, size_t nread)
1830 /* This code could be made into a special function in the handler struct */
1831 CURLcode result = CURLE_OK;
1832 struct SessionHandle *data = conn->data;
1833 struct SingleRequest *k = &data->req;
1835 struct pop3_conn *pop3c = &conn->proto.pop3c;
1836 bool strip_dot = FALSE;
1840 /* Search through the buffer looking for the end-of-body marker which is
1841 5 bytes (0d 0a 2e 0d 0a). Note that a line starting with a dot matches
1842 the eob so the server will have prefixed it with an extra dot which we
1843 need to strip out. Additionally the marker could of course be spread out
1844 over 5 different data chunks. */
1845 for(i = 0; i < nread; i++) {
1846 size_t prev = pop3c->eob;
1850 if(pop3c->eob == 0) {
1854 /* Write out the body part that didn't match */
1855 result = Curl_client_write(conn, CLIENTWRITE_BODY, &str[last],
1864 else if(pop3c->eob == 3)
1867 /* If the character match wasn't at position 0 or 3 then restart the
1873 if(pop3c->eob == 1 || pop3c->eob == 4)
1876 /* If the character match wasn't at position 1 or 4 then start the
1884 else if(pop3c->eob == 3) {
1885 /* We have an extra dot after the CRLF which we need to strip off */
1890 /* If the character match wasn't at position 2 then start the search
1900 /* Did we have a partial match which has subsequently failed? */
1901 if(prev && prev >= pop3c->eob) {
1902 /* Strip can only be non-zero for the very first mismatch after CRLF
1903 and then both prev and strip are equal and nothing will be output
1905 while(prev && pop3c->strip) {
1911 /* If the partial match was the CRLF and dot then only write the CRLF
1912 as the server would have inserted the dot */
1913 result = Curl_client_write(conn, CLIENTWRITE_BODY, (char*)POP3_EOB,
1914 strip_dot ? prev - 1 : prev);
1925 if(pop3c->eob == POP3_EOB_LEN) {
1926 /* We have a full match so the transfer is done, however we must transfer
1927 the CRLF at the start of the EOB as this is considered to be part of the
1928 message as per RFC-1939, sect. 3 */
1929 result = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)POP3_EOB, 2);
1931 k->keepon &= ~KEEP_RECV;
1938 /* While EOB is matching nothing should be output */
1942 result = Curl_client_write(conn, CLIENTWRITE_BODY, &str[last],
1949 #endif /* CURL_DISABLE_POP3 */