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 */ |
1545 | |