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