Annotation of embedaddon/curl/lib/pop3.c, revision 1.1.1.1
1.1 misho 1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2019, 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: * RFC8314 Use of TLS for Email Submission and Access
34: * Draft LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
35: *
36: ***************************************************************************/
37:
38: #include "curl_setup.h"
39:
40: #ifndef CURL_DISABLE_POP3
41:
42: #ifdef HAVE_NETINET_IN_H
43: #include <netinet/in.h>
44: #endif
45: #ifdef HAVE_ARPA_INET_H
46: #include <arpa/inet.h>
47: #endif
48: #ifdef HAVE_UTSNAME_H
49: #include <sys/utsname.h>
50: #endif
51: #ifdef HAVE_NETDB_H
52: #include <netdb.h>
53: #endif
54: #ifdef __VMS
55: #include <in.h>
56: #include <inet.h>
57: #endif
58:
59: #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
60: #undef in_addr_t
61: #define in_addr_t unsigned long
62: #endif
63:
64: #include <curl/curl.h>
65: #include "urldata.h"
66: #include "sendf.h"
67: #include "hostip.h"
68: #include "progress.h"
69: #include "transfer.h"
70: #include "escape.h"
71: #include "http.h" /* for HTTP proxy tunnel stuff */
72: #include "socks.h"
73: #include "pop3.h"
74: #include "strtoofft.h"
75: #include "strcase.h"
76: #include "vtls/vtls.h"
77: #include "connect.h"
78: #include "strerror.h"
79: #include "select.h"
80: #include "multiif.h"
81: #include "url.h"
82: #include "curl_sasl.h"
83: #include "curl_md5.h"
84: #include "warnless.h"
85: /* The last 3 #include files should be in this order */
86: #include "curl_printf.h"
87: #include "curl_memory.h"
88: #include "memdebug.h"
89:
90: /* Local API functions */
91: static CURLcode pop3_regular_transfer(struct connectdata *conn, bool *done);
92: static CURLcode pop3_do(struct connectdata *conn, bool *done);
93: static CURLcode pop3_done(struct connectdata *conn, CURLcode status,
94: bool premature);
95: static CURLcode pop3_connect(struct connectdata *conn, bool *done);
96: static CURLcode pop3_disconnect(struct connectdata *conn, bool dead);
97: static CURLcode pop3_multi_statemach(struct connectdata *conn, bool *done);
98: static int pop3_getsock(struct connectdata *conn, curl_socket_t *socks);
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
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: */
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 && line[0] == '.')
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 && line[0] == '+') {
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: */
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: */
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: */
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: */
339: static CURLcode pop3_perform_starttls(struct connectdata *conn)
340: {
341: /* Send the STLS command */
342: CURLcode result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "STLS");
343:
344: if(!result)
345: state(conn, POP3_STARTTLS);
346:
347: return result;
348: }
349:
350: /***********************************************************************
351: *
352: * pop3_perform_upgrade_tls()
353: *
354: * Performs the upgrade to TLS.
355: */
356: static CURLcode pop3_perform_upgrade_tls(struct connectdata *conn)
357: {
358: /* Start the SSL connection */
359: struct pop3_conn *pop3c = &conn->proto.pop3c;
360: CURLcode result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET,
361: &pop3c->ssldone);
362:
363: if(!result) {
364: if(pop3c->state != POP3_UPGRADETLS)
365: state(conn, POP3_UPGRADETLS);
366:
367: if(pop3c->ssldone) {
368: pop3_to_pop3s(conn);
369: result = pop3_perform_capa(conn);
370: }
371: }
372:
373: return result;
374: }
375:
376: /***********************************************************************
377: *
378: * pop3_perform_user()
379: *
380: * Sends a clear text USER command to authenticate with.
381: */
382: static CURLcode pop3_perform_user(struct connectdata *conn)
383: {
384: CURLcode result = CURLE_OK;
385:
386: /* Check we have a username and password to authenticate with and end the
387: connect phase if we don't */
388: if(!conn->bits.user_passwd) {
389: state(conn, POP3_STOP);
390:
391: return result;
392: }
393:
394: /* Send the USER command */
395: result = Curl_pp_sendf(&conn->proto.pop3c.pp, "USER %s",
396: conn->user ? conn->user : "");
397: if(!result)
398: state(conn, POP3_USER);
399:
400: return result;
401: }
402:
403: #ifndef CURL_DISABLE_CRYPTO_AUTH
404: /***********************************************************************
405: *
406: * pop3_perform_apop()
407: *
408: * Sends an APOP command to authenticate with.
409: */
410: static CURLcode pop3_perform_apop(struct connectdata *conn)
411: {
412: CURLcode result = CURLE_OK;
413: struct pop3_conn *pop3c = &conn->proto.pop3c;
414: size_t i;
415: MD5_context *ctxt;
416: unsigned char digest[MD5_DIGEST_LEN];
417: char secret[2 * MD5_DIGEST_LEN + 1];
418:
419: /* Check we have a username and password to authenticate with and end the
420: connect phase if we don't */
421: if(!conn->bits.user_passwd) {
422: state(conn, POP3_STOP);
423:
424: return result;
425: }
426:
427: /* Create the digest */
428: ctxt = Curl_MD5_init(Curl_DIGEST_MD5);
429: if(!ctxt)
430: return CURLE_OUT_OF_MEMORY;
431:
432: Curl_MD5_update(ctxt, (const unsigned char *) pop3c->apoptimestamp,
433: curlx_uztoui(strlen(pop3c->apoptimestamp)));
434:
435: Curl_MD5_update(ctxt, (const unsigned char *) conn->passwd,
436: curlx_uztoui(strlen(conn->passwd)));
437:
438: /* Finalise the digest */
439: Curl_MD5_final(ctxt, digest);
440:
441: /* Convert the calculated 16 octet digest into a 32 byte hex string */
442: for(i = 0; i < MD5_DIGEST_LEN; i++)
443: msnprintf(&secret[2 * i], 3, "%02x", digest[i]);
444:
445: result = Curl_pp_sendf(&pop3c->pp, "APOP %s %s", conn->user, secret);
446:
447: if(!result)
448: state(conn, POP3_APOP);
449:
450: return result;
451: }
452: #endif
453:
454: /***********************************************************************
455: *
456: * pop3_perform_auth()
457: *
458: * Sends an AUTH command allowing the client to login with the given SASL
459: * authentication mechanism.
460: */
461: static CURLcode pop3_perform_auth(struct connectdata *conn,
462: const char *mech,
463: const char *initresp)
464: {
465: CURLcode result = CURLE_OK;
466: struct pop3_conn *pop3c = &conn->proto.pop3c;
467:
468: if(initresp) { /* AUTH <mech> ...<crlf> */
469: /* Send the AUTH command with the initial response */
470: result = Curl_pp_sendf(&pop3c->pp, "AUTH %s %s", mech, initresp);
471: }
472: else {
473: /* Send the AUTH command */
474: result = Curl_pp_sendf(&pop3c->pp, "AUTH %s", mech);
475: }
476:
477: return result;
478: }
479:
480: /***********************************************************************
481: *
482: * pop3_continue_auth()
483: *
484: * Sends SASL continuation data or cancellation.
485: */
486: static CURLcode pop3_continue_auth(struct connectdata *conn,
487: const char *resp)
488: {
489: struct pop3_conn *pop3c = &conn->proto.pop3c;
490:
491: return Curl_pp_sendf(&pop3c->pp, "%s", resp);
492: }
493:
494: /***********************************************************************
495: *
496: * pop3_perform_authentication()
497: *
498: * Initiates the authentication sequence, with the appropriate SASL
499: * authentication mechanism, falling back to APOP and clear text should a
500: * common mechanism not be available between the client and server.
501: */
502: static CURLcode pop3_perform_authentication(struct connectdata *conn)
503: {
504: CURLcode result = CURLE_OK;
505: struct pop3_conn *pop3c = &conn->proto.pop3c;
506: saslprogress progress = SASL_IDLE;
507:
508: /* Check we have enough data to authenticate with and end the
509: connect phase if we don't */
510: if(!Curl_sasl_can_authenticate(&pop3c->sasl, conn)) {
511: state(conn, POP3_STOP);
512: return result;
513: }
514:
515: if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_SASL) {
516: /* Calculate the SASL login details */
517: result = Curl_sasl_start(&pop3c->sasl, conn, FALSE, &progress);
518:
519: if(!result)
520: if(progress == SASL_INPROGRESS)
521: state(conn, POP3_AUTH);
522: }
523:
524: if(!result && progress == SASL_IDLE) {
525: #ifndef CURL_DISABLE_CRYPTO_AUTH
526: if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_APOP)
527: /* Perform APOP authentication */
528: result = pop3_perform_apop(conn);
529: else
530: #endif
531: if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_CLEARTEXT)
532: /* Perform clear text authentication */
533: result = pop3_perform_user(conn);
534: else {
535: /* Other mechanisms not supported */
536: infof(conn->data, "No known authentication mechanisms supported!\n");
537: result = CURLE_LOGIN_DENIED;
538: }
539: }
540:
541: return result;
542: }
543:
544: /***********************************************************************
545: *
546: * pop3_perform_command()
547: *
548: * Sends a POP3 based command.
549: */
550: static CURLcode pop3_perform_command(struct connectdata *conn)
551: {
552: CURLcode result = CURLE_OK;
553: struct Curl_easy *data = conn->data;
554: struct POP3 *pop3 = data->req.protop;
555: const char *command = NULL;
556:
557: /* Calculate the default command */
558: if(pop3->id[0] == '\0' || conn->data->set.ftp_list_only) {
559: command = "LIST";
560:
561: if(pop3->id[0] != '\0')
562: /* Message specific LIST so skip the BODY transfer */
563: pop3->transfer = FTPTRANSFER_INFO;
564: }
565: else
566: command = "RETR";
567:
568: /* Send the command */
569: if(pop3->id[0] != '\0')
570: result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s %s",
571: (pop3->custom && pop3->custom[0] != '\0' ?
572: pop3->custom : command), pop3->id);
573: else
574: result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s",
575: (pop3->custom && pop3->custom[0] != '\0' ?
576: pop3->custom : command));
577:
578: if(!result)
579: state(conn, POP3_COMMAND);
580:
581: return result;
582: }
583:
584: /***********************************************************************
585: *
586: * pop3_perform_quit()
587: *
588: * Performs the quit action prior to sclose() be called.
589: */
590: static CURLcode pop3_perform_quit(struct connectdata *conn)
591: {
592: /* Send the QUIT command */
593: CURLcode result = Curl_pp_sendf(&conn->proto.pop3c.pp, "%s", "QUIT");
594:
595: if(!result)
596: state(conn, POP3_QUIT);
597:
598: return result;
599: }
600:
601: /* For the initial server greeting */
602: static CURLcode pop3_state_servergreet_resp(struct connectdata *conn,
603: int pop3code,
604: pop3state instate)
605: {
606: CURLcode result = CURLE_OK;
607: struct Curl_easy *data = conn->data;
608: struct pop3_conn *pop3c = &conn->proto.pop3c;
609: const char *line = data->state.buffer;
610: size_t len = strlen(line);
611:
612: (void)instate; /* no use for this yet */
613:
614: if(pop3code != '+') {
615: failf(data, "Got unexpected pop3-server response");
616: result = CURLE_WEIRD_SERVER_REPLY;
617: }
618: else {
619: /* Does the server support APOP authentication? */
620: if(len >= 4 && line[len - 2] == '>') {
621: /* Look for the APOP timestamp */
622: size_t i;
623: for(i = 3; i < len - 2; ++i) {
624: if(line[i] == '<') {
625: /* Calculate the length of the timestamp */
626: size_t timestamplen = len - 1 - i;
627: char *at;
628: if(!timestamplen)
629: break;
630:
631: /* Allocate some memory for the timestamp */
632: pop3c->apoptimestamp = (char *)calloc(1, timestamplen + 1);
633:
634: if(!pop3c->apoptimestamp)
635: break;
636:
637: /* Copy the timestamp */
638: memcpy(pop3c->apoptimestamp, line + i, timestamplen);
639: pop3c->apoptimestamp[timestamplen] = '\0';
640:
641: /* If the timestamp does not contain '@' it is not (as required by
642: RFC-1939) conformant to the RFC-822 message id syntax, and we
643: therefore do not use APOP authentication. */
644: at = strchr(pop3c->apoptimestamp, '@');
645: if(!at)
646: Curl_safefree(pop3c->apoptimestamp);
647: else
648: /* Store the APOP capability */
649: pop3c->authtypes |= POP3_TYPE_APOP;
650: break;
651: }
652: }
653: }
654:
655: result = pop3_perform_capa(conn);
656: }
657:
658: return result;
659: }
660:
661: /* For CAPA responses */
662: static CURLcode pop3_state_capa_resp(struct connectdata *conn, int pop3code,
663: pop3state instate)
664: {
665: CURLcode result = CURLE_OK;
666: struct Curl_easy *data = conn->data;
667: struct pop3_conn *pop3c = &conn->proto.pop3c;
668: const char *line = data->state.buffer;
669: size_t len = strlen(line);
670:
671: (void)instate; /* no use for this yet */
672:
673: /* Do we have a untagged continuation response? */
674: if(pop3code == '*') {
675: /* Does the server support the STLS capability? */
676: if(len >= 4 && !memcmp(line, "STLS", 4))
677: pop3c->tls_supported = TRUE;
678:
679: /* Does the server support clear text authentication? */
680: else if(len >= 4 && !memcmp(line, "USER", 4))
681: pop3c->authtypes |= POP3_TYPE_CLEARTEXT;
682:
683: /* Does the server support SASL based authentication? */
684: else if(len >= 5 && !memcmp(line, "SASL ", 5)) {
685: pop3c->authtypes |= POP3_TYPE_SASL;
686:
687: /* Advance past the SASL keyword */
688: line += 5;
689: len -= 5;
690:
691: /* Loop through the data line */
692: for(;;) {
693: size_t llen;
694: size_t wordlen;
695: unsigned int mechbit;
696:
697: while(len &&
698: (*line == ' ' || *line == '\t' ||
699: *line == '\r' || *line == '\n')) {
700:
701: line++;
702: len--;
703: }
704:
705: if(!len)
706: break;
707:
708: /* Extract the word */
709: for(wordlen = 0; wordlen < len && line[wordlen] != ' ' &&
710: line[wordlen] != '\t' && line[wordlen] != '\r' &&
711: line[wordlen] != '\n';)
712: wordlen++;
713:
714: /* Test the word for a matching authentication mechanism */
715: mechbit = Curl_sasl_decode_mech(line, wordlen, &llen);
716: if(mechbit && llen == wordlen)
717: pop3c->sasl.authmechs |= mechbit;
718:
719: line += wordlen;
720: len -= wordlen;
721: }
722: }
723: }
724: else if(pop3code == '+') {
725: if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
726: /* We don't have a SSL/TLS connection yet, but SSL is requested */
727: if(pop3c->tls_supported)
728: /* Switch to TLS connection now */
729: result = pop3_perform_starttls(conn);
730: else if(data->set.use_ssl == CURLUSESSL_TRY)
731: /* Fallback and carry on with authentication */
732: result = pop3_perform_authentication(conn);
733: else {
734: failf(data, "STLS not supported.");
735: result = CURLE_USE_SSL_FAILED;
736: }
737: }
738: else
739: result = pop3_perform_authentication(conn);
740: }
741: else {
742: /* Clear text is supported when CAPA isn't recognised */
743: pop3c->authtypes |= POP3_TYPE_CLEARTEXT;
744:
745: result = pop3_perform_authentication(conn);
746: }
747:
748: return result;
749: }
750:
751: /* For STARTTLS responses */
752: static CURLcode pop3_state_starttls_resp(struct connectdata *conn,
753: int pop3code,
754: pop3state instate)
755: {
756: CURLcode result = CURLE_OK;
757: struct Curl_easy *data = conn->data;
758:
759: (void)instate; /* no use for this yet */
760:
761: if(pop3code != '+') {
762: if(data->set.use_ssl != CURLUSESSL_TRY) {
763: failf(data, "STARTTLS denied");
764: result = CURLE_USE_SSL_FAILED;
765: }
766: else
767: result = pop3_perform_authentication(conn);
768: }
769: else
770: result = pop3_perform_upgrade_tls(conn);
771:
772: return result;
773: }
774:
775: /* For SASL authentication responses */
776: static CURLcode pop3_state_auth_resp(struct connectdata *conn,
777: int pop3code,
778: pop3state instate)
779: {
780: CURLcode result = CURLE_OK;
781: struct Curl_easy *data = conn->data;
782: struct pop3_conn *pop3c = &conn->proto.pop3c;
783: saslprogress progress;
784:
785: (void)instate; /* no use for this yet */
786:
787: result = Curl_sasl_continue(&pop3c->sasl, conn, pop3code, &progress);
788: if(!result)
789: switch(progress) {
790: case SASL_DONE:
791: state(conn, POP3_STOP); /* Authenticated */
792: break;
793: case SASL_IDLE: /* No mechanism left after cancellation */
794: #ifndef CURL_DISABLE_CRYPTO_AUTH
795: if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_APOP)
796: /* Perform APOP authentication */
797: result = pop3_perform_apop(conn);
798: else
799: #endif
800: if(pop3c->authtypes & pop3c->preftype & POP3_TYPE_CLEARTEXT)
801: /* Perform clear text authentication */
802: result = pop3_perform_user(conn);
803: else {
804: failf(data, "Authentication cancelled");
805: result = CURLE_LOGIN_DENIED;
806: }
807: break;
808: default:
809: break;
810: }
811:
812: return result;
813: }
814:
815: #ifndef CURL_DISABLE_CRYPTO_AUTH
816: /* For APOP responses */
817: static CURLcode pop3_state_apop_resp(struct connectdata *conn, int pop3code,
818: pop3state instate)
819: {
820: CURLcode result = CURLE_OK;
821: struct Curl_easy *data = conn->data;
822:
823: (void)instate; /* no use for this yet */
824:
825: if(pop3code != '+') {
826: failf(data, "Authentication failed: %d", pop3code);
827: result = CURLE_LOGIN_DENIED;
828: }
829: else
830: /* End of connect phase */
831: state(conn, POP3_STOP);
832:
833: return result;
834: }
835: #endif
836:
837: /* For USER responses */
838: static CURLcode pop3_state_user_resp(struct connectdata *conn, int pop3code,
839: pop3state instate)
840: {
841: CURLcode result = CURLE_OK;
842: struct Curl_easy *data = conn->data;
843:
844: (void)instate; /* no use for this yet */
845:
846: if(pop3code != '+') {
847: failf(data, "Access denied. %c", pop3code);
848: result = CURLE_LOGIN_DENIED;
849: }
850: else
851: /* Send the PASS command */
852: result = Curl_pp_sendf(&conn->proto.pop3c.pp, "PASS %s",
853: conn->passwd ? conn->passwd : "");
854: if(!result)
855: state(conn, POP3_PASS);
856:
857: return result;
858: }
859:
860: /* For PASS responses */
861: static CURLcode pop3_state_pass_resp(struct connectdata *conn, int pop3code,
862: pop3state instate)
863: {
864: CURLcode result = CURLE_OK;
865: struct Curl_easy *data = conn->data;
866:
867: (void)instate; /* no use for this yet */
868:
869: if(pop3code != '+') {
870: failf(data, "Access denied. %c", pop3code);
871: result = CURLE_LOGIN_DENIED;
872: }
873: else
874: /* End of connect phase */
875: state(conn, POP3_STOP);
876:
877: return result;
878: }
879:
880: /* For command responses */
881: static CURLcode pop3_state_command_resp(struct connectdata *conn,
882: int pop3code,
883: pop3state instate)
884: {
885: CURLcode result = CURLE_OK;
886: struct Curl_easy *data = conn->data;
887: struct POP3 *pop3 = data->req.protop;
888: struct pop3_conn *pop3c = &conn->proto.pop3c;
889: struct pingpong *pp = &pop3c->pp;
890:
891: (void)instate; /* no use for this yet */
892:
893: if(pop3code != '+') {
894: state(conn, POP3_STOP);
895: return CURLE_RECV_ERROR;
896: }
897:
898: /* This 'OK' line ends with a CR LF pair which is the two first bytes of the
899: EOB string so count this is two matching bytes. This is necessary to make
900: the code detect the EOB if the only data than comes now is %2e CR LF like
901: when there is no body to return. */
902: pop3c->eob = 2;
903:
904: /* But since this initial CR LF pair is not part of the actual body, we set
905: the strip counter here so that these bytes won't be delivered. */
906: pop3c->strip = 2;
907:
908: if(pop3->transfer == FTPTRANSFER_BODY) {
909: /* POP3 download */
910: Curl_setup_transfer(data, FIRSTSOCKET, -1, FALSE, -1);
911:
912: if(pp->cache) {
913: /* The header "cache" contains a bunch of data that is actually body
914: content so send it as such. Note that there may even be additional
915: "headers" after the body */
916:
917: if(!data->set.opt_no_body) {
918: result = Curl_pop3_write(conn, pp->cache, pp->cache_size);
919: if(result)
920: return result;
921: }
922:
923: /* Free the cache */
924: Curl_safefree(pp->cache);
925:
926: /* Reset the cache size */
927: pp->cache_size = 0;
928: }
929: }
930:
931: /* End of DO phase */
932: state(conn, POP3_STOP);
933:
934: return result;
935: }
936:
937: static CURLcode pop3_statemach_act(struct connectdata *conn)
938: {
939: CURLcode result = CURLE_OK;
940: curl_socket_t sock = conn->sock[FIRSTSOCKET];
941: int pop3code;
942: struct pop3_conn *pop3c = &conn->proto.pop3c;
943: struct pingpong *pp = &pop3c->pp;
944: size_t nread = 0;
945:
946: /* Busy upgrading the connection; right now all I/O is SSL/TLS, not POP3 */
947: if(pop3c->state == POP3_UPGRADETLS)
948: return pop3_perform_upgrade_tls(conn);
949:
950: /* Flush any data that needs to be sent */
951: if(pp->sendleft)
952: return Curl_pp_flushsend(pp);
953:
954: do {
955: /* Read the response from the server */
956: result = Curl_pp_readresp(sock, pp, &pop3code, &nread);
957: if(result)
958: return result;
959:
960: if(!pop3code)
961: break;
962:
963: /* We have now received a full POP3 server response */
964: switch(pop3c->state) {
965: case POP3_SERVERGREET:
966: result = pop3_state_servergreet_resp(conn, pop3code, pop3c->state);
967: break;
968:
969: case POP3_CAPA:
970: result = pop3_state_capa_resp(conn, pop3code, pop3c->state);
971: break;
972:
973: case POP3_STARTTLS:
974: result = pop3_state_starttls_resp(conn, pop3code, pop3c->state);
975: break;
976:
977: case POP3_AUTH:
978: result = pop3_state_auth_resp(conn, pop3code, pop3c->state);
979: break;
980:
981: #ifndef CURL_DISABLE_CRYPTO_AUTH
982: case POP3_APOP:
983: result = pop3_state_apop_resp(conn, pop3code, pop3c->state);
984: break;
985: #endif
986:
987: case POP3_USER:
988: result = pop3_state_user_resp(conn, pop3code, pop3c->state);
989: break;
990:
991: case POP3_PASS:
992: result = pop3_state_pass_resp(conn, pop3code, pop3c->state);
993: break;
994:
995: case POP3_COMMAND:
996: result = pop3_state_command_resp(conn, pop3code, pop3c->state);
997: break;
998:
999: case POP3_QUIT:
1000: /* fallthrough, just stop! */
1001: default:
1002: /* internal error */
1003: state(conn, POP3_STOP);
1004: break;
1005: }
1006: } while(!result && pop3c->state != POP3_STOP && Curl_pp_moredata(pp));
1007:
1008: return result;
1009: }
1010:
1011: /* Called repeatedly until done from multi.c */
1012: static CURLcode pop3_multi_statemach(struct connectdata *conn, bool *done)
1013: {
1014: CURLcode result = CURLE_OK;
1015: struct pop3_conn *pop3c = &conn->proto.pop3c;
1016:
1017: if((conn->handler->flags & PROTOPT_SSL) && !pop3c->ssldone) {
1018: result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &pop3c->ssldone);
1019: if(result || !pop3c->ssldone)
1020: return result;
1021: }
1022:
1023: result = Curl_pp_statemach(&pop3c->pp, FALSE, FALSE);
1024: *done = (pop3c->state == POP3_STOP) ? TRUE : FALSE;
1025:
1026: return result;
1027: }
1028:
1029: static CURLcode pop3_block_statemach(struct connectdata *conn,
1030: bool disconnecting)
1031: {
1032: CURLcode result = CURLE_OK;
1033: struct pop3_conn *pop3c = &conn->proto.pop3c;
1034:
1035: while(pop3c->state != POP3_STOP && !result)
1036: result = Curl_pp_statemach(&pop3c->pp, TRUE, disconnecting);
1037:
1038: return result;
1039: }
1040:
1041: /* Allocate and initialize the POP3 struct for the current Curl_easy if
1042: required */
1043: static CURLcode pop3_init(struct connectdata *conn)
1044: {
1045: CURLcode result = CURLE_OK;
1046: struct Curl_easy *data = conn->data;
1047: struct POP3 *pop3;
1048:
1049: pop3 = data->req.protop = calloc(sizeof(struct POP3), 1);
1050: if(!pop3)
1051: result = CURLE_OUT_OF_MEMORY;
1052:
1053: return result;
1054: }
1055:
1056: /* For the POP3 "protocol connect" and "doing" phases only */
1057: static int pop3_getsock(struct connectdata *conn, curl_socket_t *socks)
1058: {
1059: return Curl_pp_getsock(&conn->proto.pop3c.pp, socks);
1060: }
1061:
1062: /***********************************************************************
1063: *
1064: * pop3_connect()
1065: *
1066: * This function should do everything that is to be considered a part of the
1067: * connection phase.
1068: *
1069: * The variable 'done' points to will be TRUE if the protocol-layer connect
1070: * phase is done when this function returns, or FALSE if not.
1071: */
1072: static CURLcode pop3_connect(struct connectdata *conn, bool *done)
1073: {
1074: CURLcode result = CURLE_OK;
1075: struct pop3_conn *pop3c = &conn->proto.pop3c;
1076: struct pingpong *pp = &pop3c->pp;
1077:
1078: *done = FALSE; /* default to not done yet */
1079:
1080: /* We always support persistent connections in POP3 */
1081: connkeep(conn, "POP3 default");
1082:
1083: /* Set the default response time-out */
1084: pp->response_time = RESP_TIMEOUT;
1085: pp->statemach_act = pop3_statemach_act;
1086: pp->endofresp = pop3_endofresp;
1087: pp->conn = conn;
1088:
1089: /* Set the default preferred authentication type and mechanism */
1090: pop3c->preftype = POP3_TYPE_ANY;
1091: Curl_sasl_init(&pop3c->sasl, &saslpop3);
1092:
1093: /* Initialise the pingpong layer */
1094: Curl_pp_init(pp);
1095:
1096: /* Parse the URL options */
1097: result = pop3_parse_url_options(conn);
1098: if(result)
1099: return result;
1100:
1101: /* Start off waiting for the server greeting response */
1102: state(conn, POP3_SERVERGREET);
1103:
1104: result = pop3_multi_statemach(conn, done);
1105:
1106: return result;
1107: }
1108:
1109: /***********************************************************************
1110: *
1111: * pop3_done()
1112: *
1113: * The DONE function. This does what needs to be done after a single DO has
1114: * performed.
1115: *
1116: * Input argument is already checked for validity.
1117: */
1118: static CURLcode pop3_done(struct connectdata *conn, CURLcode status,
1119: bool premature)
1120: {
1121: CURLcode result = CURLE_OK;
1122: struct Curl_easy *data = conn->data;
1123: struct POP3 *pop3 = data->req.protop;
1124:
1125: (void)premature;
1126:
1127: if(!pop3)
1128: return CURLE_OK;
1129:
1130: if(status) {
1131: connclose(conn, "POP3 done with bad status");
1132: result = status; /* use the already set error code */
1133: }
1134:
1135: /* Cleanup our per-request based variables */
1136: Curl_safefree(pop3->id);
1137: Curl_safefree(pop3->custom);
1138:
1139: /* Clear the transfer mode for the next request */
1140: pop3->transfer = FTPTRANSFER_BODY;
1141:
1142: return result;
1143: }
1144:
1145: /***********************************************************************
1146: *
1147: * pop3_perform()
1148: *
1149: * This is the actual DO function for POP3. Get a message/listing according to
1150: * the options previously setup.
1151: */
1152: static CURLcode pop3_perform(struct connectdata *conn, bool *connected,
1153: bool *dophase_done)
1154: {
1155: /* This is POP3 and no proxy */
1156: CURLcode result = CURLE_OK;
1157: struct POP3 *pop3 = conn->data->req.protop;
1158:
1159: DEBUGF(infof(conn->data, "DO phase starts\n"));
1160:
1161: if(conn->data->set.opt_no_body) {
1162: /* Requested no body means no transfer */
1163: pop3->transfer = FTPTRANSFER_INFO;
1164: }
1165:
1166: *dophase_done = FALSE; /* not done yet */
1167:
1168: /* Start the first command in the DO phase */
1169: result = pop3_perform_command(conn);
1170: if(result)
1171: return result;
1172:
1173: /* Run the state-machine */
1174: result = pop3_multi_statemach(conn, dophase_done);
1175:
1176: *connected = conn->bits.tcpconnect[FIRSTSOCKET];
1177:
1178: if(*dophase_done)
1179: DEBUGF(infof(conn->data, "DO phase is complete\n"));
1180:
1181: return result;
1182: }
1183:
1184: /***********************************************************************
1185: *
1186: * pop3_do()
1187: *
1188: * This function is registered as 'curl_do' function. It decodes the path
1189: * parts etc as a wrapper to the actual DO function (pop3_perform).
1190: *
1191: * The input argument is already checked for validity.
1192: */
1193: static CURLcode pop3_do(struct connectdata *conn, bool *done)
1194: {
1195: CURLcode result = CURLE_OK;
1196:
1197: *done = FALSE; /* default to false */
1198:
1199: /* Parse the URL path */
1200: result = pop3_parse_url_path(conn);
1201: if(result)
1202: return result;
1203:
1204: /* Parse the custom request */
1205: result = pop3_parse_custom_request(conn);
1206: if(result)
1207: return result;
1208:
1209: result = pop3_regular_transfer(conn, done);
1210:
1211: return result;
1212: }
1213:
1214: /***********************************************************************
1215: *
1216: * pop3_disconnect()
1217: *
1218: * Disconnect from an POP3 server. Cleanup protocol-specific per-connection
1219: * resources. BLOCKING.
1220: */
1221: static CURLcode pop3_disconnect(struct connectdata *conn, bool dead_connection)
1222: {
1223: struct pop3_conn *pop3c = &conn->proto.pop3c;
1224:
1225: /* We cannot send quit unconditionally. If this connection is stale or
1226: bad in any way, sending quit and waiting around here will make the
1227: disconnect wait in vain and cause more problems than we need to. */
1228:
1229: /* The POP3 session may or may not have been allocated/setup at this
1230: point! */
1231: if(!dead_connection && pop3c->pp.conn && pop3c->pp.conn->bits.protoconnstart)
1232: if(!pop3_perform_quit(conn))
1233: (void)pop3_block_statemach(conn, TRUE); /* ignore errors on QUIT */
1234:
1235: /* Disconnect from the server */
1236: Curl_pp_disconnect(&pop3c->pp);
1237:
1238: /* Cleanup the SASL module */
1239: Curl_sasl_cleanup(conn, pop3c->sasl.authused);
1240:
1241: /* Cleanup our connection based variables */
1242: Curl_safefree(pop3c->apoptimestamp);
1243:
1244: return CURLE_OK;
1245: }
1246:
1247: /* Call this when the DO phase has completed */
1248: static CURLcode pop3_dophase_done(struct connectdata *conn, bool connected)
1249: {
1250: (void)conn;
1251: (void)connected;
1252:
1253: return CURLE_OK;
1254: }
1255:
1256: /* Called from multi.c while DOing */
1257: static CURLcode pop3_doing(struct connectdata *conn, bool *dophase_done)
1258: {
1259: CURLcode result = pop3_multi_statemach(conn, dophase_done);
1260:
1261: if(result)
1262: DEBUGF(infof(conn->data, "DO phase failed\n"));
1263: else if(*dophase_done) {
1264: result = pop3_dophase_done(conn, FALSE /* not connected */);
1265:
1266: DEBUGF(infof(conn->data, "DO phase is complete\n"));
1267: }
1268:
1269: return result;
1270: }
1271:
1272: /***********************************************************************
1273: *
1274: * pop3_regular_transfer()
1275: *
1276: * The input argument is already checked for validity.
1277: *
1278: * Performs all commands done before a regular transfer between a local and a
1279: * remote host.
1280: */
1281: static CURLcode pop3_regular_transfer(struct connectdata *conn,
1282: bool *dophase_done)
1283: {
1284: CURLcode result = CURLE_OK;
1285: bool connected = FALSE;
1286: struct Curl_easy *data = conn->data;
1287:
1288: /* Make sure size is unknown at this point */
1289: data->req.size = -1;
1290:
1291: /* Set the progress data */
1292: Curl_pgrsSetUploadCounter(data, 0);
1293: Curl_pgrsSetDownloadCounter(data, 0);
1294: Curl_pgrsSetUploadSize(data, -1);
1295: Curl_pgrsSetDownloadSize(data, -1);
1296:
1297: /* Carry out the perform */
1298: result = pop3_perform(conn, &connected, dophase_done);
1299:
1300: /* Perform post DO phase operations if necessary */
1301: if(!result && *dophase_done)
1302: result = pop3_dophase_done(conn, connected);
1303:
1304: return result;
1305: }
1306:
1307: static CURLcode pop3_setup_connection(struct connectdata *conn)
1308: {
1309: /* Initialise the POP3 layer */
1310: CURLcode result = pop3_init(conn);
1311: if(result)
1312: return result;
1313:
1314: /* Clear the TLS upgraded flag */
1315: conn->tls_upgraded = FALSE;
1316:
1317: return CURLE_OK;
1318: }
1319:
1320: /***********************************************************************
1321: *
1322: * pop3_parse_url_options()
1323: *
1324: * Parse the URL login options.
1325: */
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: */
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.up.path[1]; /* skip leading 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: */
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: */
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 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pop3.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib