Debian Codegraph @

deps/curl/lib/ftp.c

raw
1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2020, Daniel Stenberg, <[email protected]>, 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 ***************************************************************************/
22
23 #include "curl_setup.h"
24
25 #ifndef CURL_DISABLE_FTP
26
27 #ifdef HAVE_NETINET_IN_H
28 #include <netinet/in.h>
29 #endif
30 #ifdef HAVE_ARPA_INET_H
31 #include <arpa/inet.h>
32 #endif
33 #ifdef HAVE_UTSNAME_H
34 #include <sys/utsname.h>
35 #endif
36 #ifdef HAVE_NETDB_H
37 #include <netdb.h>
38 #endif
39 #ifdef __VMS
40 #include <in.h>
41 #include <inet.h>
42 #endif
43
44 #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
45 #undef in_addr_t
46 #define in_addr_t unsigned long
47 #endif
48
49 #include <curl/curl.h>
50 #include "urldata.h"
51 #include "sendf.h"
52 #include "if2ip.h"
53 #include "hostip.h"
54 #include "progress.h"
55 #include "transfer.h"
56 #include "escape.h"
57 #include "http.h" /* for HTTP proxy tunnel stuff */
58 #include "ftp.h"
59 #include "fileinfo.h"
60 #include "ftplistparser.h"
61 #include "curl_range.h"
62 #include "curl_sec.h"
63 #include "strtoofft.h"
64 #include "strcase.h"
65 #include "vtls/vtls.h"
66 #include "connect.h"
67 #include "strerror.h"
68 #include "inet_ntop.h"
69 #include "inet_pton.h"
70 #include "select.h"
71 #include "parsedate.h" /* for the week day and month names */
72 #include "sockaddr.h" /* required for Curl_sockaddr_storage */
73 #include "multiif.h"
74 #include "url.h"
75 #include "strcase.h"
76 #include "speedcheck.h"
77 #include "warnless.h"
78 #include "http_proxy.h"
79 #include "non-ascii.h"
80 #include "socks.h"
81 /* The last 3 #include files should be in this order */
82 #include "curl_printf.h"
83 #include "curl_memory.h"
84 #include "memdebug.h"
85
86 #ifndef NI_MAXHOST
87 #define NI_MAXHOST 1025
88 #endif
89 #ifndef INET_ADDRSTRLEN
90 #define INET_ADDRSTRLEN 16
91 #endif
92
93 #ifdef CURL_DISABLE_VERBOSE_STRINGS
94 #define ftp_pasv_verbose(a,b,c,d) Curl_nop_stmt
95 #endif
96
97 /* Local API functions */
98 #ifndef DEBUGBUILD
99 static void _state(struct connectdata *conn,
100 ftpstate newstate);
101 #define state(x,y) _state(x,y)
102 #else
103 static void _state(struct connectdata *conn,
104 ftpstate newstate,
105 int lineno);
106 #define state(x,y) _state(x,y,__LINE__)
107 #endif
108
109 static CURLcode ftp_sendquote(struct connectdata *conn,
110 struct curl_slist *quote);
111 static CURLcode ftp_quit(struct connectdata *conn);
112 static CURLcode ftp_parse_url_path(struct connectdata *conn);
113 static CURLcode ftp_regular_transfer(struct connectdata *conn, bool *done);
114 #ifndef CURL_DISABLE_VERBOSE_STRINGS
115 static void ftp_pasv_verbose(struct connectdata *conn,
116 Curl_addrinfo *ai,
117 char *newhost, /* ascii version */
118 int port);
119 #endif
120 static CURLcode ftp_state_prepare_transfer(struct connectdata *conn);
121 static CURLcode ftp_state_mdtm(struct connectdata *conn);
122 static CURLcode ftp_state_quote(struct connectdata *conn,
123 bool init, ftpstate instate);
124 static CURLcode ftp_nb_type(struct connectdata *conn,
125 bool ascii, ftpstate newstate);
126 static int ftp_need_type(struct connectdata *conn,
127 bool ascii);
128 static CURLcode ftp_do(struct connectdata *conn, bool *done);
129 static CURLcode ftp_done(struct connectdata *conn,
130 CURLcode, bool premature);
131 static CURLcode ftp_connect(struct connectdata *conn, bool *done);
132 static CURLcode ftp_disconnect(struct connectdata *conn, bool dead_connection);
133 static CURLcode ftp_do_more(struct connectdata *conn, int *completed);
134 static CURLcode ftp_multi_statemach(struct connectdata *conn, bool *done);
135 static int ftp_getsock(struct connectdata *conn, curl_socket_t *socks);
136 static int ftp_domore_getsock(struct connectdata *conn, curl_socket_t *socks);
137 static CURLcode ftp_doing(struct connectdata *conn,
138 bool *dophase_done);
139 static CURLcode ftp_setup_connection(struct connectdata * conn);
140
141 static CURLcode init_wc_data(struct connectdata *conn);
142 static CURLcode wc_statemach(struct connectdata *conn);
143
144 static void wc_data_dtor(void *ptr);
145
146 static CURLcode ftp_state_retr(struct connectdata *conn, curl_off_t filesize);
147
148 static CURLcode ftp_readresp(curl_socket_t sockfd,
149 struct pingpong *pp,
150 int *ftpcode,
151 size_t *size);
152 static CURLcode ftp_dophase_done(struct connectdata *conn,
153 bool connected);
154
155 /* easy-to-use macro: */
156 #define PPSENDF(x,y,z) result = Curl_pp_sendf(x,y,z); \
157 if(result) \
158 return result
159
160
161 /*
162 * FTP protocol handler.
163 */
164
165 const struct Curl_handler Curl_handler_ftp = {
166 "FTP", /* scheme */
167 ftp_setup_connection, /* setup_connection */
168 ftp_do, /* do_it */
169 ftp_done, /* done */
170 ftp_do_more, /* do_more */
171 ftp_connect, /* connect_it */
172 ftp_multi_statemach, /* connecting */
173 ftp_doing, /* doing */
174 ftp_getsock, /* proto_getsock */
175 ftp_getsock, /* doing_getsock */
176 ftp_domore_getsock, /* domore_getsock */
177 ZERO_NULL, /* perform_getsock */
178 ftp_disconnect, /* disconnect */
179 ZERO_NULL, /* readwrite */
180 ZERO_NULL, /* connection_check */
181 PORT_FTP, /* defport */
182 CURLPROTO_FTP, /* protocol */
183 PROTOPT_DUAL | PROTOPT_CLOSEACTION | PROTOPT_NEEDSPWD |
184 PROTOPT_NOURLQUERY | PROTOPT_PROXY_AS_HTTP |
185 PROTOPT_WILDCARD /* flags */
186 };
187
188
189 #ifdef USE_SSL
190 /*
191 * FTPS protocol handler.
192 */
193
194 const struct Curl_handler Curl_handler_ftps = {
195 "FTPS", /* scheme */
196 ftp_setup_connection, /* setup_connection */
197 ftp_do, /* do_it */
198 ftp_done, /* done */
199 ftp_do_more, /* do_more */
200 ftp_connect, /* connect_it */
201 ftp_multi_statemach, /* connecting */
202 ftp_doing, /* doing */
203 ftp_getsock, /* proto_getsock */
204 ftp_getsock, /* doing_getsock */
205 ftp_domore_getsock, /* domore_getsock */
206 ZERO_NULL, /* perform_getsock */
207 ftp_disconnect, /* disconnect */
208 ZERO_NULL, /* readwrite */
209 ZERO_NULL, /* connection_check */
210 PORT_FTPS, /* defport */
211 CURLPROTO_FTPS, /* protocol */
212 PROTOPT_SSL | PROTOPT_DUAL | PROTOPT_CLOSEACTION |
213 PROTOPT_NEEDSPWD | PROTOPT_NOURLQUERY | PROTOPT_WILDCARD /* flags */
214 };
215 #endif
216
217 static void close_secondarysocket(struct connectdata *conn)
218 {
219 if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET]) {
220 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
221 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
222 }
223 conn->bits.tcpconnect[SECONDARYSOCKET] = FALSE;
224 }
225
226 /*
227 * NOTE: back in the old days, we added code in the FTP code that made NOBODY
228 * requests on files respond with headers passed to the client/stdout that
229 * looked like HTTP ones.
230 *
231 * This approach is not very elegant, it causes confusion and is error-prone.
232 * It is subject for removal at the next (or at least a future) soname bump.
233 * Until then you can test the effects of the removal by undefining the
234 * following define named CURL_FTP_HTTPSTYLE_HEAD.
235 */
236 #define CURL_FTP_HTTPSTYLE_HEAD 1
237
238 static void freedirs(struct ftp_conn *ftpc)
239 {
240 if(ftpc->dirs) {
241 int i;
242 for(i = 0; i < ftpc->dirdepth; i++) {
243 free(ftpc->dirs[i]);
244 ftpc->dirs[i] = NULL;
245 }
246 free(ftpc->dirs);
247 ftpc->dirs = NULL;
248 ftpc->dirdepth = 0;
249 }
250 Curl_safefree(ftpc->file);
251
252 /* no longer of any use */
253 Curl_safefree(ftpc->newhost);
254 }
255
256 /***********************************************************************
257 *
258 * AcceptServerConnect()
259 *
260 * After connection request is received from the server this function is
261 * called to accept the connection and close the listening socket
262 *
263 */
264 static CURLcode AcceptServerConnect(struct connectdata *conn)
265 {
266 struct Curl_easy *data = conn->data;
267 curl_socket_t sock = conn->sock[SECONDARYSOCKET];
268 curl_socket_t s = CURL_SOCKET_BAD;
269 #ifdef ENABLE_IPV6
270 struct Curl_sockaddr_storage add;
271 #else
272 struct sockaddr_in add;
273 #endif
274 curl_socklen_t size = (curl_socklen_t) sizeof(add);
275
276 if(0 == getsockname(sock, (struct sockaddr *) &add, &size)) {
277 size = sizeof(add);
278
279 s = accept(sock, (struct sockaddr *) &add, &size);
280 }
281 Curl_closesocket(conn, sock); /* close the first socket */
282
283 if(CURL_SOCKET_BAD == s) {
284 failf(data, "Error accept()ing server connect");
285 return CURLE_FTP_PORT_FAILED;
286 }
287 infof(data, "Connection accepted from server\n");
288 /* when this happens within the DO state it is important that we mark us as
289 not needing DO_MORE anymore */
290 conn->bits.do_more = FALSE;
291
292 conn->sock[SECONDARYSOCKET] = s;
293 (void)curlx_nonblock(s, TRUE); /* enable non-blocking */
294 conn->sock_accepted = TRUE;
295
296 if(data->set.fsockopt) {
297 int error = 0;
298
299 /* activate callback for setting socket options */
300 Curl_set_in_callback(data, true);
301 error = data->set.fsockopt(data->set.sockopt_client,
302 s,
303 CURLSOCKTYPE_ACCEPT);
304 Curl_set_in_callback(data, false);
305
306 if(error) {
307 close_secondarysocket(conn);
308 return CURLE_ABORTED_BY_CALLBACK;
309 }
310 }
311
312 return CURLE_OK;
313
314 }
315
316 /*
317 * ftp_timeleft_accept() returns the amount of milliseconds left allowed for
318 * waiting server to connect. If the value is negative, the timeout time has
319 * already elapsed.
320 *
321 * The start time is stored in progress.t_acceptdata - as set with
322 * Curl_pgrsTime(..., TIMER_STARTACCEPT);
323 *
324 */
325 static timediff_t ftp_timeleft_accept(struct Curl_easy *data)
326 {
327 timediff_t timeout_ms = DEFAULT_ACCEPT_TIMEOUT;
328 timediff_t other;
329 struct curltime now;
330
331 if(data->set.accepttimeout > 0)
332 timeout_ms = data->set.accepttimeout;
333
334 now = Curl_now();
335
336 /* check if the generic timeout possibly is set shorter */
337 other = Curl_timeleft(data, &now, FALSE);
338 if(other && (other < timeout_ms))
339 /* note that this also works fine for when other happens to be negative
340 due to it already having elapsed */
341 timeout_ms = other;
342 else {
343 /* subtract elapsed time */
344 timeout_ms -= Curl_timediff(now, data->progress.t_acceptdata);
345 if(!timeout_ms)
346 /* avoid returning 0 as that means no timeout! */
347 return -1;
348 }
349
350 return timeout_ms;
351 }
352
353
354 /***********************************************************************
355 *
356 * ReceivedServerConnect()
357 *
358 * After allowing server to connect to us from data port, this function
359 * checks both data connection for connection establishment and ctrl
360 * connection for a negative response regarding a failure in connecting
361 *
362 */
363 static CURLcode ReceivedServerConnect(struct connectdata *conn, bool *received)
364 {
365 struct Curl_easy *data = conn->data;
366 curl_socket_t ctrl_sock = conn->sock[FIRSTSOCKET];
367 curl_socket_t data_sock = conn->sock[SECONDARYSOCKET];
368 struct ftp_conn *ftpc = &conn->proto.ftpc;
369 struct pingpong *pp = &ftpc->pp;
370 int result;
371 timediff_t timeout_ms;
372 ssize_t nread;
373 int ftpcode;
374
375 *received = FALSE;
376
377 timeout_ms = ftp_timeleft_accept(data);
378 infof(data, "Checking for server connect\n");
379 if(timeout_ms < 0) {
380 /* if a timeout was already reached, bail out */
381 failf(data, "Accept timeout occurred while waiting server connect");
382 return CURLE_FTP_ACCEPT_TIMEOUT;
383 }
384
385 /* First check whether there is a cached response from server */
386 if(pp->cache_size && pp->cache && pp->cache[0] > '3') {
387 /* Data connection could not be established, let's return */
388 infof(data, "There is negative response in cache while serv connect\n");
389 Curl_GetFTPResponse(&nread, conn, &ftpcode);
390 return CURLE_FTP_ACCEPT_FAILED;
391 }
392
393 result = Curl_socket_check(ctrl_sock, data_sock, CURL_SOCKET_BAD, 0);
394
395 /* see if the connection request is already here */
396 switch(result) {
397 case -1: /* error */
398 /* let's die here */
399 failf(data, "Error while waiting for server connect");
400 return CURLE_FTP_ACCEPT_FAILED;
401 case 0: /* Server connect is not received yet */
402 break; /* loop */
403 default:
404
405 if(result & CURL_CSELECT_IN2) {
406 infof(data, "Ready to accept data connection from server\n");
407 *received = TRUE;
408 }
409 else if(result & CURL_CSELECT_IN) {
410 infof(data, "Ctrl conn has data while waiting for data conn\n");
411 Curl_GetFTPResponse(&nread, conn, &ftpcode);
412
413 if(ftpcode/100 > 3)
414 return CURLE_FTP_ACCEPT_FAILED;
415
416 return CURLE_WEIRD_SERVER_REPLY;
417 }
418
419 break;
420 } /* switch() */
421
422 return CURLE_OK;
423 }
424
425
426 /***********************************************************************
427 *
428 * InitiateTransfer()
429 *
430 * After connection from server is accepted this function is called to
431 * setup transfer parameters and initiate the data transfer.
432 *
433 */
434 static CURLcode InitiateTransfer(struct connectdata *conn)
435 {
436 struct Curl_easy *data = conn->data;
437 CURLcode result = CURLE_OK;
438
439 if(conn->bits.ftp_use_data_ssl) {
440 /* since we only have a plaintext TCP connection here, we must now
441 * do the TLS stuff */
442 infof(data, "Doing the SSL/TLS handshake on the data stream\n");
443 result = Curl_ssl_connect(conn, SECONDARYSOCKET);
444 if(result)
445 return result;
446 }
447
448 if(conn->proto.ftpc.state_saved == FTP_STOR) {
449 /* When we know we're uploading a specified file, we can get the file
450 size prior to the actual upload. */
451 Curl_pgrsSetUploadSize(data, data->state.infilesize);
452
453 /* set the SO_SNDBUF for the secondary socket for those who need it */
454 Curl_sndbufset(conn->sock[SECONDARYSOCKET]);
455
456 Curl_setup_transfer(data, -1, -1, FALSE, SECONDARYSOCKET);
457 }
458 else {
459 /* FTP download: */
460 Curl_setup_transfer(data, SECONDARYSOCKET,
461 conn->proto.ftpc.retr_size_saved, FALSE, -1);
462 }
463
464 conn->proto.ftpc.pp.pending_resp = TRUE; /* expect server response */
465 state(conn, FTP_STOP);
466
467 return CURLE_OK;
468 }
469
470 /***********************************************************************
471 *
472 * AllowServerConnect()
473 *
474 * When we've issue the PORT command, we have told the server to connect to
475 * us. This function checks whether data connection is established if so it is
476 * accepted.
477 *
478 */
479 static CURLcode AllowServerConnect(struct connectdata *conn, bool *connected)
480 {
481 struct Curl_easy *data = conn->data;
482 timediff_t timeout_ms;
483 CURLcode result = CURLE_OK;
484
485 *connected = FALSE;
486 infof(data, "Preparing for accepting server on data port\n");
487
488 /* Save the time we start accepting server connect */
489 Curl_pgrsTime(data, TIMER_STARTACCEPT);
490
491 timeout_ms = ftp_timeleft_accept(data);
492 if(timeout_ms < 0) {
493 /* if a timeout was already reached, bail out */
494 failf(data, "Accept timeout occurred while waiting server connect");
495 return CURLE_FTP_ACCEPT_TIMEOUT;
496 }
497
498 /* see if the connection request is already here */
499 result = ReceivedServerConnect(conn, connected);
500 if(result)
501 return result;
502
503 if(*connected) {
504 result = AcceptServerConnect(conn);
505 if(result)
506 return result;
507
508 result = InitiateTransfer(conn);
509 if(result)
510 return result;
511 }
512 else {
513 /* Add timeout to multi handle and break out of the loop */
514 if(*connected == FALSE) {
515 Curl_expire(data, data->set.accepttimeout > 0 ?
516 data->set.accepttimeout: DEFAULT_ACCEPT_TIMEOUT, 0);
517 }
518 }
519
520 return result;
521 }
522
523 /* macro to check for a three-digit ftp status code at the start of the
524 given string */
525 #define STATUSCODE(line) (ISDIGIT(line[0]) && ISDIGIT(line[1]) && \
526 ISDIGIT(line[2]))
527
528 /* macro to check for the last line in an FTP server response */
529 #define LASTLINE(line) (STATUSCODE(line) && (' ' == line[3]))
530
531 static bool ftp_endofresp(struct connectdata *conn, char *line, size_t len,
532 int *code)
533 {
534 (void)conn;
535
536 if((len > 3) && LASTLINE(line)) {
537 *code = curlx_sltosi(strtol(line, NULL, 10));
538 return TRUE;
539 }
540
541 return FALSE;
542 }
543
544 static CURLcode ftp_readresp(curl_socket_t sockfd,
545 struct pingpong *pp,
546 int *ftpcode, /* return the ftp-code if done */
547 size_t *size) /* size of the response */
548 {
549 struct connectdata *conn = pp->conn;
550 struct Curl_easy *data = conn->data;
551 #ifdef HAVE_GSSAPI
552 char * const buf = data->state.buffer;
553 #endif
554 int code;
555 CURLcode result = Curl_pp_readresp(sockfd, pp, &code, size);
556
557 #if defined(HAVE_GSSAPI)
558 /* handle the security-oriented responses 6xx ***/
559 switch(code) {
560 case 631:
561 code = Curl_sec_read_msg(conn, buf, PROT_SAFE);
562 break;
563 case 632:
564 code = Curl_sec_read_msg(conn, buf, PROT_PRIVATE);
565 break;
566 case 633:
567 code = Curl_sec_read_msg(conn, buf, PROT_CONFIDENTIAL);
568 break;
569 default:
570 /* normal ftp stuff we pass through! */
571 break;
572 }
573 #endif
574
575 /* store the latest code for later retrieval */
576 data->info.httpcode = code;
577
578 if(ftpcode)
579 *ftpcode = code;
580
581 if(421 == code) {
582 /* 421 means "Service not available, closing control connection." and FTP
583 * servers use it to signal that idle session timeout has been exceeded.
584 * If we ignored the response, it could end up hanging in some cases.
585 *
586 * This response code can come at any point so having it treated
587 * generically is a good idea.
588 */
589 infof(data, "We got a 421 - timeout!\n");
590 state(conn, FTP_STOP);
591 return CURLE_OPERATION_TIMEDOUT;
592 }
593
594 return result;
595 }
596
597 /* --- parse FTP server responses --- */
598
599 /*
600 * Curl_GetFTPResponse() is a BLOCKING function to read the full response
601 * from a server after a command.
602 *
603 */
604
605 CURLcode Curl_GetFTPResponse(ssize_t *nreadp, /* return number of bytes read */
606 struct connectdata *conn,
607 int *ftpcode) /* return the ftp-code */
608 {
609 /*
610 * We cannot read just one byte per read() and then go back to select() as
611 * the OpenSSL read() doesn't grok that properly.
612 *
613 * Alas, read as much as possible, split up into lines, use the ending
614 * line in a response or continue reading. */
615
616 curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
617 struct Curl_easy *data = conn->data;
618 CURLcode result = CURLE_OK;
619 struct ftp_conn *ftpc = &conn->proto.ftpc;
620 struct pingpong *pp = &ftpc->pp;
621 size_t nread;
622 int cache_skip = 0;
623 int value_to_be_ignored = 0;
624
625 if(ftpcode)
626 *ftpcode = 0; /* 0 for errors */
627 else
628 /* make the pointer point to something for the rest of this function */
629 ftpcode = &value_to_be_ignored;
630
631 *nreadp = 0;
632
633 while(!*ftpcode && !result) {
634 /* check and reset timeout value every lap */
635 time_t timeout = Curl_pp_state_timeout(pp, FALSE);
636 time_t interval_ms;
637
638 if(timeout <= 0) {
639 failf(data, "FTP response timeout");
640 return CURLE_OPERATION_TIMEDOUT; /* already too little time */
641 }
642
643 interval_ms = 1000; /* use 1 second timeout intervals */
644 if(timeout < interval_ms)
645 interval_ms = timeout;
646
647 /*
648 * Since this function is blocking, we need to wait here for input on the
649 * connection and only then we call the response reading function. We do
650 * timeout at least every second to make the timeout check run.
651 *
652 * A caution here is that the ftp_readresp() function has a cache that may
653 * contain pieces of a response from the previous invoke and we need to
654 * make sure we don't just wait for input while there is unhandled data in
655 * that cache. But also, if the cache is there, we call ftp_readresp() and
656 * the cache wasn't good enough to continue we must not just busy-loop
657 * around this function.
658 *
659 */
660
661 if(pp->cache && (cache_skip < 2)) {
662 /*
663 * There's a cache left since before. We then skipping the wait for
664 * socket action, unless this is the same cache like the previous round
665 * as then the cache was deemed not enough to act on and we then need to
666 * wait for more data anyway.
667 */
668 }
669 else if(!Curl_conn_data_pending(conn, FIRSTSOCKET)) {
670 switch(SOCKET_READABLE(sockfd, interval_ms)) {
671 case -1: /* select() error, stop reading */
672 failf(data, "FTP response aborted due to select/poll error: %d",
673 SOCKERRNO);
674 return CURLE_RECV_ERROR;
675
676 case 0: /* timeout */
677 if(Curl_pgrsUpdate(conn))
678 return CURLE_ABORTED_BY_CALLBACK;
679 continue; /* just continue in our loop for the timeout duration */
680
681 default: /* for clarity */
682 break;
683 }
684 }
685 result = ftp_readresp(sockfd, pp, ftpcode, &nread);
686 if(result)
687 break;
688
689 if(!nread && pp->cache)
690 /* bump cache skip counter as on repeated skips we must wait for more
691 data */
692 cache_skip++;
693 else
694 /* when we got data or there is no cache left, we reset the cache skip
695 counter */
696 cache_skip = 0;
697
698 *nreadp += nread;
699
700 } /* while there's buffer left and loop is requested */
701
702 pp->pending_resp = FALSE;
703
704 return result;
705 }
706
707 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
708 /* for debug purposes */
709 static const char * const ftp_state_names[]={
710 "STOP",
711 "WAIT220",
712 "AUTH",
713 "USER",
714 "PASS",
715 "ACCT",
716 "PBSZ",
717 "PROT",
718 "CCC",
719 "PWD",
720 "SYST",
721 "NAMEFMT",
722 "QUOTE",
723 "RETR_PREQUOTE",
724 "STOR_PREQUOTE",
725 "POSTQUOTE",
726 "CWD",
727 "MKD",
728 "MDTM",
729 "TYPE",
730 "LIST_TYPE",
731 "RETR_TYPE",
732 "STOR_TYPE",
733 "SIZE",
734 "RETR_SIZE",
735 "STOR_SIZE",
736 "REST",
737 "RETR_REST",
738 "PORT",
739 "PRET",
740 "PASV",
741 "LIST",
742 "RETR",
743 "STOR",
744 "QUIT"
745 };
746 #endif
747
748 /* This is the ONLY way to change FTP state! */
749 static void _state(struct connectdata *conn,
750 ftpstate newstate
751 #ifdef DEBUGBUILD
752 , int lineno
753 #endif
754 )
755 {
756 struct ftp_conn *ftpc = &conn->proto.ftpc;
757
758 #if defined(DEBUGBUILD)
759
760 #if defined(CURL_DISABLE_VERBOSE_STRINGS)
761 (void) lineno;
762 #else
763 if(ftpc->state != newstate)
764 infof(conn->data, "FTP %p (line %d) state change from %s to %s\n",
765 (void *)ftpc, lineno, ftp_state_names[ftpc->state],
766 ftp_state_names[newstate]);
767 #endif
768 #endif
769
770 ftpc->state = newstate;
771 }
772
773 static CURLcode ftp_state_user(struct connectdata *conn)
774 {
775 CURLcode result;
776 /* send USER */
777 PPSENDF(&conn->proto.ftpc.pp, "USER %s", conn->user?conn->user:"");
778
779 state(conn, FTP_USER);
780 conn->data->state.ftp_trying_alternative = FALSE;
781
782 return CURLE_OK;
783 }
784
785 static CURLcode ftp_state_pwd(struct connectdata *conn)
786 {
787 CURLcode result;
788
789 /* send PWD to discover our entry point */
790 PPSENDF(&conn->proto.ftpc.pp, "%s", "PWD");
791 state(conn, FTP_PWD);
792
793 return CURLE_OK;
794 }
795
796 /* For the FTP "protocol connect" and "doing" phases only */
797 static int ftp_getsock(struct connectdata *conn,
798 curl_socket_t *socks)
799 {
800 return Curl_pp_getsock(&conn->proto.ftpc.pp, socks);
801 }
802
803 /* For the FTP "DO_MORE" phase only */
804 static int ftp_domore_getsock(struct connectdata *conn, curl_socket_t *socks)
805 {
806 struct ftp_conn *ftpc = &conn->proto.ftpc;
807
808 /* When in DO_MORE state, we could be either waiting for us to connect to a
809 * remote site, or we could wait for that site to connect to us. Or just
810 * handle ordinary commands.
811 */
812
813 if(SOCKS_STATE(conn->cnnct.state))
814 return Curl_SOCKS_getsock(conn, socks, SECONDARYSOCKET);
815
816 if(FTP_STOP == ftpc->state) {
817 int bits = GETSOCK_READSOCK(0);
818
819 /* if stopped and still in this state, then we're also waiting for a
820 connect on the secondary connection */
821 socks[0] = conn->sock[FIRSTSOCKET];
822
823 if(!conn->data->set.ftp_use_port) {
824 int s;
825 int i;
826 /* PORT is used to tell the server to connect to us, and during that we
827 don't do happy eyeballs, but we do if we connect to the server */
828 for(s = 1, i = 0; i<2; i++) {
829 if(conn->tempsock[i] != CURL_SOCKET_BAD) {
830 socks[s] = conn->tempsock[i];
831 bits |= GETSOCK_WRITESOCK(s++);
832 }
833 }
834 }
835 else {
836 socks[1] = conn->sock[SECONDARYSOCKET];
837 bits |= GETSOCK_WRITESOCK(1) | GETSOCK_READSOCK(1);
838 }
839
840 return bits;
841 }
842 return Curl_pp_getsock(&conn->proto.ftpc.pp, socks);
843 }
844
845 /* This is called after the FTP_QUOTE state is passed.
846
847 ftp_state_cwd() sends the range of CWD commands to the server to change to
848 the correct directory. It may also need to send MKD commands to create
849 missing ones, if that option is enabled.
850 */
851 static CURLcode ftp_state_cwd(struct connectdata *conn)
852 {
853 CURLcode result = CURLE_OK;
854 struct ftp_conn *ftpc = &conn->proto.ftpc;
855
856 if(ftpc->cwddone)
857 /* already done and fine */
858 result = ftp_state_mdtm(conn);
859 else {
860 /* FTPFILE_NOCWD with full path: expect ftpc->cwddone! */
861 DEBUGASSERT((conn->data->set.ftp_filemethod != FTPFILE_NOCWD) ||
862 !(ftpc->dirdepth && ftpc->dirs[0][0] == '/'));
863
864 ftpc->count2 = 0; /* count2 counts failed CWDs */
865
866 /* count3 is set to allow a MKD to fail once. In the case when first CWD
867 fails and then MKD fails (due to another session raced it to create the
868 dir) this then allows for a second try to CWD to it */
869 ftpc->count3 = (conn->data->set.ftp_create_missing_dirs == 2)?1:0;
870
871 if(conn->bits.reuse && ftpc->entrypath &&
872 /* no need to go to entrypath when we have an absolute path */
873 !(ftpc->dirdepth && ftpc->dirs[0][0] == '/')) {
874 /* This is a re-used connection. Since we change directory to where the
875 transfer is taking place, we must first get back to the original dir
876 where we ended up after login: */
877 ftpc->cwdcount = 0; /* we count this as the first path, then we add one
878 for all upcoming ones in the ftp->dirs[] array */
879 PPSENDF(&conn->proto.ftpc.pp, "CWD %s", ftpc->entrypath);
880 state(conn, FTP_CWD);
881 }
882 else {
883 if(ftpc->dirdepth) {
884 ftpc->cwdcount = 1;
885 /* issue the first CWD, the rest is sent when the CWD responses are
886 received... */
887 PPSENDF(&conn->proto.ftpc.pp, "CWD %s", ftpc->dirs[ftpc->cwdcount -1]);
888 state(conn, FTP_CWD);
889 }
890 else {
891 /* No CWD necessary */
892 result = ftp_state_mdtm(conn);
893 }
894 }
895 }
896 return result;
897 }
898
899 typedef enum {
900 EPRT,
901 PORT,
902 DONE
903 } ftpport;
904
905 static CURLcode ftp_state_use_port(struct connectdata *conn,
906 ftpport fcmd) /* start with this */
907
908 {
909 CURLcode result = CURLE_OK;
910 struct ftp_conn *ftpc = &conn->proto.ftpc;
911 struct Curl_easy *data = conn->data;
912 curl_socket_t portsock = CURL_SOCKET_BAD;
913 char myhost[MAX_IPADR_LEN + 1] = "";
914
915 struct Curl_sockaddr_storage ss;
916 Curl_addrinfo *res, *ai;
917 curl_socklen_t sslen;
918 char hbuf[NI_MAXHOST];
919 struct sockaddr *sa = (struct sockaddr *)&ss;
920 struct sockaddr_in * const sa4 = (void *)sa;
921 #ifdef ENABLE_IPV6
922 struct sockaddr_in6 * const sa6 = (void *)sa;
923 #endif
924 static const char mode[][5] = { "EPRT", "PORT" };
925 enum resolve_t rc;
926 int error;
927 char *host = NULL;
928 char *string_ftpport = data->set.str[STRING_FTPPORT];
929 struct Curl_dns_entry *h = NULL;
930 unsigned short port_min = 0;
931 unsigned short port_max = 0;
932 unsigned short port;
933 bool possibly_non_local = TRUE;
934 char buffer[STRERROR_LEN];
935 char *addr = NULL;
936
937 /* Step 1, figure out what is requested,
938 * accepted format :
939 * (ipv4|ipv6|domain|interface)?(:port(-range)?)?
940 */
941
942 if(data->set.str[STRING_FTPPORT] &&
943 (strlen(data->set.str[STRING_FTPPORT]) > 1)) {
944
945 #ifdef ENABLE_IPV6
946 size_t addrlen = INET6_ADDRSTRLEN > strlen(string_ftpport) ?
947 INET6_ADDRSTRLEN : strlen(string_ftpport);
948 #else
949 size_t addrlen = INET_ADDRSTRLEN > strlen(string_ftpport) ?
950 INET_ADDRSTRLEN : strlen(string_ftpport);
951 #endif
952 char *ip_start = string_ftpport;
953 char *ip_end = NULL;
954 char *port_start = NULL;
955 char *port_sep = NULL;
956
957 addr = calloc(addrlen + 1, 1);
958 if(!addr)
959 return CURLE_OUT_OF_MEMORY;
960
961 #ifdef ENABLE_IPV6
962 if(*string_ftpport == '[') {
963 /* [ipv6]:port(-range) */
964 ip_start = string_ftpport + 1;
965 ip_end = strchr(string_ftpport, ']');
966 if(ip_end)
967 strncpy(addr, ip_start, ip_end - ip_start);
968 }
969 else
970 #endif
971 if(*string_ftpport == ':') {
972 /* :port */
973 ip_end = string_ftpport;
974 }
975 else {
976 ip_end = strchr(string_ftpport, ':');
977 if(ip_end) {
978 /* either ipv6 or (ipv4|domain|interface):port(-range) */
979 #ifdef ENABLE_IPV6
980 if(Curl_inet_pton(AF_INET6, string_ftpport, sa6) == 1) {
981 /* ipv6 */
982 port_min = port_max = 0;
983 strcpy(addr, string_ftpport);
984 ip_end = NULL; /* this got no port ! */
985 }
986 else
987 #endif
988 /* (ipv4|domain|interface):port(-range) */
989 strncpy(addr, string_ftpport, ip_end - ip_start);
990 }
991 else
992 /* ipv4|interface */
993 strcpy(addr, string_ftpport);
994 }
995
996 /* parse the port */
997 if(ip_end != NULL) {
998 port_start = strchr(ip_end, ':');
999 if(port_start) {
1000 port_min = curlx_ultous(strtoul(port_start + 1, NULL, 10));
1001 port_sep = strchr(port_start, '-');
1002 if(port_sep) {
1003 port_max = curlx_ultous(strtoul(port_sep + 1, NULL, 10));
1004 }
1005 else
1006 port_max = port_min;
1007 }
1008 }
1009
1010 /* correct errors like:
1011 * :1234-1230
1012 * :-4711, in this case port_min is (unsigned)-1,
1013 * therefore port_min > port_max for all cases
1014 * but port_max = (unsigned)-1
1015 */
1016 if(port_min > port_max)
1017 port_min = port_max = 0;
1018
1019
1020 if(*addr != '\0') {
1021 /* attempt to get the address of the given interface name */
1022 switch(Curl_if2ip(conn->ip_addr->ai_family,
1023 Curl_ipv6_scope(conn->ip_addr->ai_addr),
1024 conn->scope_id, addr, hbuf, sizeof(hbuf))) {
1025 case IF2IP_NOT_FOUND:
1026 /* not an interface, use the given string as host name instead */
1027 host = addr;
1028 break;
1029 case IF2IP_AF_NOT_SUPPORTED:
1030 return CURLE_FTP_PORT_FAILED;
1031 case IF2IP_FOUND:
1032 host = hbuf; /* use the hbuf for host name */
1033 }
1034 }
1035 else
1036 /* there was only a port(-range) given, default the host */
1037 host = NULL;
1038 } /* data->set.ftpport */
1039
1040 if(!host) {
1041 /* not an interface and not a host name, get default by extracting
1042 the IP from the control connection */
1043 sslen = sizeof(ss);
1044 if(getsockname(conn->sock[FIRSTSOCKET], sa, &sslen)) {
1045 failf(data, "getsockname() failed: %s",
1046 Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1047 free(addr);
1048 return CURLE_FTP_PORT_FAILED;
1049 }
1050 switch(sa->sa_family) {
1051 #ifdef ENABLE_IPV6
1052 case AF_INET6:
1053 Curl_inet_ntop(sa->sa_family, &sa6->sin6_addr, hbuf, sizeof(hbuf));
1054 break;
1055 #endif
1056 default:
1057 Curl_inet_ntop(sa->sa_family, &sa4->sin_addr, hbuf, sizeof(hbuf));
1058 break;
1059 }
1060 host = hbuf; /* use this host name */
1061 possibly_non_local = FALSE; /* we know it is local now */
1062 }
1063
1064 /* resolv ip/host to ip */
1065 rc = Curl_resolv(conn, host, 0, FALSE, &h);
1066 if(rc == CURLRESOLV_PENDING)
1067 (void)Curl_resolver_wait_resolv(conn, &h);
1068 if(h) {
1069 res = h->addr;
1070 /* when we return from this function, we can forget about this entry
1071 to we can unlock it now already */
1072 Curl_resolv_unlock(data, h);
1073 } /* (h) */
1074 else
1075 res = NULL; /* failure! */
1076
1077 if(res == NULL) {
1078 failf(data, "failed to resolve the address provided to PORT: %s", host);
1079 free(addr);
1080 return CURLE_FTP_PORT_FAILED;
1081 }
1082
1083 free(addr);
1084 host = NULL;
1085
1086 /* step 2, create a socket for the requested address */
1087
1088 portsock = CURL_SOCKET_BAD;
1089 error = 0;
1090 for(ai = res; ai; ai = ai->ai_next) {
1091 result = Curl_socket(conn, ai, NULL, &portsock);
1092 if(result) {
1093 error = SOCKERRNO;
1094 continue;
1095 }
1096 break;
1097 }
1098 if(!ai) {
1099 failf(data, "socket failure: %s",
1100 Curl_strerror(error, buffer, sizeof(buffer)));
1101 return CURLE_FTP_PORT_FAILED;
1102 }
1103
1104 /* step 3, bind to a suitable local address */
1105
1106 memcpy(sa, ai->ai_addr, ai->ai_addrlen);
1107 sslen = ai->ai_addrlen;
1108
1109 for(port = port_min; port <= port_max;) {
1110 if(sa->sa_family == AF_INET)
1111 sa4->sin_port = htons(port);
1112 #ifdef ENABLE_IPV6
1113 else
1114 sa6->sin6_port = htons(port);
1115 #endif
1116 /* Try binding the given address. */
1117 if(bind(portsock, sa, sslen) ) {
1118 /* It failed. */
1119 error = SOCKERRNO;
1120 if(possibly_non_local && (error == EADDRNOTAVAIL)) {
1121 /* The requested bind address is not local. Use the address used for
1122 * the control connection instead and restart the port loop
1123 */
1124 infof(data, "bind(port=%hu) on non-local address failed: %s\n", port,
1125 Curl_strerror(error, buffer, sizeof(buffer)));
1126
1127 sslen = sizeof(ss);
1128 if(getsockname(conn->sock[FIRSTSOCKET], sa, &sslen)) {
1129 failf(data, "getsockname() failed: %s",
1130 Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1131 Curl_closesocket(conn, portsock);
1132 return CURLE_FTP_PORT_FAILED;
1133 }
1134 port = port_min;
1135 possibly_non_local = FALSE; /* don't try this again */
1136 continue;
1137 }
1138 if(error != EADDRINUSE && error != EACCES) {
1139 failf(data, "bind(port=%hu) failed: %s", port,
1140 Curl_strerror(error, buffer, sizeof(buffer)));
1141 Curl_closesocket(conn, portsock);
1142 return CURLE_FTP_PORT_FAILED;
1143 }
1144 }
1145 else
1146 break;
1147
1148 port++;
1149 }
1150
1151 /* maybe all ports were in use already*/
1152 if(port > port_max) {
1153 failf(data, "bind() failed, we ran out of ports!");
1154 Curl_closesocket(conn, portsock);
1155 return CURLE_FTP_PORT_FAILED;
1156 }
1157
1158 /* get the name again after the bind() so that we can extract the
1159 port number it uses now */
1160 sslen = sizeof(ss);
1161 if(getsockname(portsock, (struct sockaddr *)sa, &sslen)) {
1162 failf(data, "getsockname() failed: %s",
1163 Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1164 Curl_closesocket(conn, portsock);
1165 return CURLE_FTP_PORT_FAILED;
1166 }
1167
1168 /* step 4, listen on the socket */
1169
1170 if(listen(portsock, 1)) {
1171 failf(data, "socket failure: %s",
1172 Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1173 Curl_closesocket(conn, portsock);
1174 return CURLE_FTP_PORT_FAILED;
1175 }
1176
1177 /* step 5, send the proper FTP command */
1178
1179 /* get a plain printable version of the numerical address to work with
1180 below */
1181 Curl_printable_address(ai, myhost, sizeof(myhost));
1182
1183 #ifdef ENABLE_IPV6
1184 if(!conn->bits.ftp_use_eprt && conn->bits.ipv6)
1185 /* EPRT is disabled but we are connected to a IPv6 host, so we ignore the
1186 request and enable EPRT again! */
1187 conn->bits.ftp_use_eprt = TRUE;
1188 #endif
1189
1190 for(; fcmd != DONE; fcmd++) {
1191
1192 if(!conn->bits.ftp_use_eprt && (EPRT == fcmd))
1193 /* if disabled, goto next */
1194 continue;
1195
1196 if((PORT == fcmd) && sa->sa_family != AF_INET)
1197 /* PORT is IPv4 only */
1198 continue;
1199
1200 switch(sa->sa_family) {
1201 case AF_INET:
1202 port = ntohs(sa4->sin_port);
1203 break;
1204 #ifdef ENABLE_IPV6
1205 case AF_INET6:
1206 port = ntohs(sa6->sin6_port);
1207 break;
1208 #endif
1209 default:
1210 continue; /* might as well skip this */
1211 }
1212
1213 if(EPRT == fcmd) {
1214 /*
1215 * Two fine examples from RFC2428;
1216 *
1217 * EPRT |1|132.235.1.2|6275|
1218 *
1219 * EPRT |2|1080::8:800:200C:417A|5282|
1220 */
1221
1222 result = Curl_pp_sendf(&ftpc->pp, "%s |%d|%s|%hu|", mode[fcmd],
1223 sa->sa_family == AF_INET?1:2,
1224 myhost, port);
1225 if(result) {
1226 failf(data, "Failure sending EPRT command: %s",
1227 curl_easy_strerror(result));
1228 Curl_closesocket(conn, portsock);
1229 /* don't retry using PORT */
1230 ftpc->count1 = PORT;
1231 /* bail out */
1232 state(conn, FTP_STOP);
1233 return result;
1234 }
1235 break;
1236 }
1237 if(PORT == fcmd) {
1238 /* large enough for [IP address],[num],[num] */
1239 char target[sizeof(myhost) + 20];
1240 char *source = myhost;
1241 char *dest = target;
1242
1243 /* translate x.x.x.x to x,x,x,x */
1244 while(source && *source) {
1245 if(*source == '.')
1246 *dest = ',';
1247 else
1248 *dest = *source;
1249 dest++;
1250 source++;
1251 }
1252 *dest = 0;
1253 msnprintf(dest, 20, ",%d,%d", (int)(port>>8), (int)(port&0xff));
1254
1255 result = Curl_pp_sendf(&ftpc->pp, "%s %s", mode[fcmd], target);
1256 if(result) {
1257 failf(data, "Failure sending PORT command: %s",
1258 curl_easy_strerror(result));
1259 Curl_closesocket(conn, portsock);
1260 /* bail out */
1261 state(conn, FTP_STOP);
1262 return result;
1263 }
1264 break;
1265 }
1266 }
1267
1268 /* store which command was sent */
1269 ftpc->count1 = fcmd;
1270
1271 close_secondarysocket(conn);
1272
1273 /* we set the secondary socket variable to this for now, it is only so that
1274 the cleanup function will close it in case we fail before the true
1275 secondary stuff is made */
1276 conn->sock[SECONDARYSOCKET] = portsock;
1277
1278 /* this tcpconnect assignment below is a hackish work-around to make the
1279 multi interface with active FTP work - as it will not wait for a
1280 (passive) connect in Curl_is_connected().
1281
1282 The *proper* fix is to make sure that the active connection from the
1283 server is done in a non-blocking way. Currently, it is still BLOCKING.
1284 */
1285 conn->bits.tcpconnect[SECONDARYSOCKET] = TRUE;
1286
1287 state(conn, FTP_PORT);
1288 return result;
1289 }
1290
1291 static CURLcode ftp_state_use_pasv(struct connectdata *conn)
1292 {
1293 struct ftp_conn *ftpc = &conn->proto.ftpc;
1294 CURLcode result = CURLE_OK;
1295 /*
1296 Here's the excecutive summary on what to do:
1297
1298 PASV is RFC959, expect:
1299 227 Entering Passive Mode (a1,a2,a3,a4,p1,p2)
1300
1301 LPSV is RFC1639, expect:
1302 228 Entering Long Passive Mode (4,4,a1,a2,a3,a4,2,p1,p2)
1303
1304 EPSV is RFC2428, expect:
1305 229 Entering Extended Passive Mode (|||port|)
1306
1307 */
1308
1309 static const char mode[][5] = { "EPSV", "PASV" };
1310 int modeoff;
1311
1312 #ifdef PF_INET6
1313 if(!conn->bits.ftp_use_epsv && conn->bits.ipv6)
1314 /* EPSV is disabled but we are connected to a IPv6 host, so we ignore the
1315 request and enable EPSV again! */
1316 conn->bits.ftp_use_epsv = TRUE;
1317 #endif
1318
1319 modeoff = conn->bits.ftp_use_epsv?0:1;
1320
1321 PPSENDF(&ftpc->pp, "%s", mode[modeoff]);
1322
1323 ftpc->count1 = modeoff;
1324 state(conn, FTP_PASV);
1325 infof(conn->data, "Connect data stream passively\n");
1326
1327 return result;
1328 }
1329
1330 /*
1331 * ftp_state_prepare_transfer() starts PORT, PASV or PRET etc.
1332 *
1333 * REST is the last command in the chain of commands when a "head"-like
1334 * request is made. Thus, if an actual transfer is to be made this is where we
1335 * take off for real.
1336 */
1337 static CURLcode ftp_state_prepare_transfer(struct connectdata *conn)
1338 {
1339 CURLcode result = CURLE_OK;
1340 struct FTP *ftp = conn->data->req.protop;
1341 struct Curl_easy *data = conn->data;
1342
1343 if(ftp->transfer != FTPTRANSFER_BODY) {
1344 /* doesn't transfer any data */
1345
1346 /* still possibly do PRE QUOTE jobs */
1347 state(conn, FTP_RETR_PREQUOTE);
1348 result = ftp_state_quote(conn, TRUE, FTP_RETR_PREQUOTE);
1349 }
1350 else if(data->set.ftp_use_port) {
1351 /* We have chosen to use the PORT (or similar) command */
1352 result = ftp_state_use_port(conn, EPRT);
1353 }
1354 else {
1355 /* We have chosen (this is default) to use the PASV (or similar) command */
1356 if(data->set.ftp_use_pret) {
1357 /* The user has requested that we send a PRET command
1358 to prepare the server for the upcoming PASV */
1359 if(!conn->proto.ftpc.file) {
1360 PPSENDF(&conn->proto.ftpc.pp, "PRET %s",
1361 data->set.str[STRING_CUSTOMREQUEST]?
1362 data->set.str[STRING_CUSTOMREQUEST]:
1363 (data->set.ftp_list_only?"NLST":"LIST"));
1364 }
1365 else if(data->set.upload) {
1366 PPSENDF(&conn->proto.ftpc.pp, "PRET STOR %s", conn->proto.ftpc.file);
1367 }
1368 else {
1369 PPSENDF(&conn->proto.ftpc.pp, "PRET RETR %s", conn->proto.ftpc.file);
1370 }
1371 state(conn, FTP_PRET);
1372 }
1373 else {
1374 result = ftp_state_use_pasv(conn);
1375 }
1376 }
1377 return result;
1378 }
1379
1380 static CURLcode ftp_state_rest(struct connectdata *conn)
1381 {
1382 CURLcode result = CURLE_OK;
1383 struct FTP *ftp = conn->data->req.protop;
1384 struct ftp_conn *ftpc = &conn->proto.ftpc;
1385
1386 if((ftp->transfer != FTPTRANSFER_BODY) && ftpc->file) {
1387 /* if a "head"-like request is being made (on a file) */
1388
1389 /* Determine if server can respond to REST command and therefore
1390 whether it supports range */
1391 PPSENDF(&conn->proto.ftpc.pp, "REST %d", 0);
1392
1393 state(conn, FTP_REST);
1394 }
1395 else
1396 result = ftp_state_prepare_transfer(conn);
1397
1398 return result;
1399 }
1400
1401 static CURLcode ftp_state_size(struct connectdata *conn)
1402 {
1403 CURLcode result = CURLE_OK;
1404 struct FTP *ftp = conn->data->req.protop;
1405 struct ftp_conn *ftpc = &conn->proto.ftpc;
1406
1407 if((ftp->transfer == FTPTRANSFER_INFO) && ftpc->file) {
1408 /* if a "head"-like request is being made (on a file) */
1409
1410 /* we know ftpc->file is a valid pointer to a file name */
1411 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file);
1412
1413 state(conn, FTP_SIZE);
1414 }
1415 else
1416 result = ftp_state_rest(conn);
1417
1418 return result;
1419 }
1420
1421 static CURLcode ftp_state_list(struct connectdata *conn)
1422 {
1423 CURLcode result = CURLE_OK;
1424 struct Curl_easy *data = conn->data;
1425 struct FTP *ftp = data->req.protop;
1426
1427 /* If this output is to be machine-parsed, the NLST command might be better
1428 to use, since the LIST command output is not specified or standard in any
1429 way. It has turned out that the NLST list output is not the same on all
1430 servers either... */
1431
1432 /*
1433 if FTPFILE_NOCWD was specified, we should add the path
1434 as argument for the LIST / NLST / or custom command.
1435 Whether the server will support this, is uncertain.
1436
1437 The other ftp_filemethods will CWD into dir/dir/ first and
1438 then just do LIST (in that case: nothing to do here)
1439 */
1440 char *lstArg = NULL;
1441 char *cmd;
1442
1443 if((data->set.ftp_filemethod == FTPFILE_NOCWD) && ftp->path) {
1444 /* url-decode before evaluation: e.g. paths starting/ending with %2f */
1445 const char *slashPos = NULL;
1446 char *rawPath = NULL;
1447 result = Curl_urldecode(data, ftp->path, 0, &rawPath, NULL, TRUE);
1448 if(result)
1449 return result;
1450
1451 slashPos = strrchr(rawPath, '/');
1452 if(slashPos) {
1453 /* chop off the file part if format is dir/file otherwise remove
1454 the trailing slash for dir/dir/ except for absolute path / */
1455 size_t n = slashPos - rawPath;
1456 if(n == 0)
1457 ++n;
1458
1459 lstArg = rawPath;
1460 lstArg[n] = '\0';
1461 }
1462 else
1463 free(rawPath);
1464 }
1465
1466 cmd = aprintf("%s%s%s",
1467 data->set.str[STRING_CUSTOMREQUEST]?
1468 data->set.str[STRING_CUSTOMREQUEST]:
1469 (data->set.ftp_list_only?"NLST":"LIST"),
1470 lstArg? " ": "",
1471 lstArg? lstArg: "");
1472 free(lstArg);
1473
1474 if(!cmd)
1475 return CURLE_OUT_OF_MEMORY;
1476
1477 result = Curl_pp_sendf(&conn->proto.ftpc.pp, "%s", cmd);
1478 free(cmd);
1479
1480 if(result)
1481 return result;
1482
1483 state(conn, FTP_LIST);
1484
1485 return result;
1486 }
1487
1488 static CURLcode ftp_state_retr_prequote(struct connectdata *conn)
1489 {
1490 /* We've sent the TYPE, now we must send the list of prequote strings */
1491 return ftp_state_quote(conn, TRUE, FTP_RETR_PREQUOTE);
1492 }
1493
1494 static CURLcode ftp_state_stor_prequote(struct connectdata *conn)
1495 {
1496 /* We've sent the TYPE, now we must send the list of prequote strings */
1497 return ftp_state_quote(conn, TRUE, FTP_STOR_PREQUOTE);
1498 }
1499
1500 static CURLcode ftp_state_type(struct connectdata *conn)
1501 {
1502 CURLcode result = CURLE_OK;
1503 struct FTP *ftp = conn->data->req.protop;
1504 struct Curl_easy *data = conn->data;
1505 struct ftp_conn *ftpc = &conn->proto.ftpc;
1506
1507 /* If we have selected NOBODY and HEADER, it means that we only want file
1508 information. Which in FTP can't be much more than the file size and
1509 date. */
1510 if(data->set.opt_no_body && ftpc->file &&
1511 ftp_need_type(conn, data->set.prefer_ascii)) {
1512 /* The SIZE command is _not_ RFC 959 specified, and therefore many servers
1513 may not support it! It is however the only way we have to get a file's
1514 size! */
1515
1516 ftp->transfer = FTPTRANSFER_INFO;
1517 /* this means no actual transfer will be made */
1518
1519 /* Some servers return different sizes for different modes, and thus we
1520 must set the proper type before we check the size */
1521 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_TYPE);
1522 if(result)
1523 return result;
1524 }
1525 else
1526 result = ftp_state_size(conn);
1527
1528 return result;
1529 }
1530
1531 /* This is called after the CWD commands have been done in the beginning of
1532 the DO phase */
1533 static CURLcode ftp_state_mdtm(struct connectdata *conn)
1534 {
1535 CURLcode result = CURLE_OK;
1536 struct Curl_easy *data = conn->data;
1537 struct ftp_conn *ftpc = &conn->proto.ftpc;
1538
1539 /* Requested time of file or time-depended transfer? */
1540 if((data->set.get_filetime || data->set.timecondition) && ftpc->file) {
1541
1542 /* we have requested to get the modified-time of the file, this is a white
1543 spot as the MDTM is not mentioned in RFC959 */
1544 PPSENDF(&ftpc->pp, "MDTM %s", ftpc->file);
1545
1546 state(conn, FTP_MDTM);
1547 }
1548 else
1549 result = ftp_state_type(conn);
1550
1551 return result;
1552 }
1553
1554
1555 /* This is called after the TYPE and possible quote commands have been sent */
1556 static CURLcode ftp_state_ul_setup(struct connectdata *conn,
1557 bool sizechecked)
1558 {
1559 CURLcode result = CURLE_OK;
1560 struct FTP *ftp = conn->data->req.protop;
1561 struct Curl_easy *data = conn->data;
1562 struct ftp_conn *ftpc = &conn->proto.ftpc;
1563
1564 if((data->state.resume_from && !sizechecked) ||
1565 ((data->state.resume_from > 0) && sizechecked)) {
1566 /* we're about to continue the uploading of a file */
1567 /* 1. get already existing file's size. We use the SIZE command for this
1568 which may not exist in the server! The SIZE command is not in
1569 RFC959. */
1570
1571 /* 2. This used to set REST. But since we can do append, we
1572 don't another ftp command. We just skip the source file
1573 offset and then we APPEND the rest on the file instead */
1574
1575 /* 3. pass file-size number of bytes in the source file */
1576 /* 4. lower the infilesize counter */
1577 /* => transfer as usual */
1578 int seekerr = CURL_SEEKFUNC_OK;
1579
1580 if(data->state.resume_from < 0) {
1581 /* Got no given size to start from, figure it out */
1582 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file);
1583 state(conn, FTP_STOR_SIZE);
1584 return result;
1585 }
1586
1587 /* enable append */
1588 data->set.ftp_append = TRUE;
1589
1590 /* Let's read off the proper amount of bytes from the input. */
1591 if(conn->seek_func) {
1592 Curl_set_in_callback(data, true);
1593 seekerr = conn->seek_func(conn->seek_client, data->state.resume_from,
1594 SEEK_SET);
1595 Curl_set_in_callback(data, false);
1596 }
1597
1598 if(seekerr != CURL_SEEKFUNC_OK) {
1599 curl_off_t passed = 0;
1600 if(seekerr != CURL_SEEKFUNC_CANTSEEK) {
1601 failf(data, "Could not seek stream");
1602 return CURLE_FTP_COULDNT_USE_REST;
1603 }
1604 /* seekerr == CURL_SEEKFUNC_CANTSEEK (can't seek to offset) */
1605 do {
1606 size_t readthisamountnow =
1607 (data->state.resume_from - passed > data->set.buffer_size) ?
1608 (size_t)data->set.buffer_size :
1609 curlx_sotouz(data->state.resume_from - passed);
1610
1611 size_t actuallyread =
1612 data->state.fread_func(data->state.buffer, 1, readthisamountnow,
1613 data->state.in);
1614
1615 passed += actuallyread;
1616 if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
1617 /* this checks for greater-than only to make sure that the
1618 CURL_READFUNC_ABORT return code still aborts */
1619 failf(data, "Failed to read data");
1620 return CURLE_FTP_COULDNT_USE_REST;
1621 }
1622 } while(passed < data->state.resume_from);
1623 }
1624 /* now, decrease the size of the read */
1625 if(data->state.infilesize>0) {
1626 data->state.infilesize -= data->state.resume_from;
1627
1628 if(data->state.infilesize <= 0) {
1629 infof(data, "File already completely uploaded\n");
1630
1631 /* no data to transfer */
1632 Curl_setup_transfer(data, -1, -1, FALSE, -1);
1633
1634 /* Set ->transfer so that we won't get any error in
1635 * ftp_done() because we didn't transfer anything! */
1636 ftp->transfer = FTPTRANSFER_NONE;
1637
1638 state(conn, FTP_STOP);
1639 return CURLE_OK;
1640 }
1641 }
1642 /* we've passed, proceed as normal */
1643 } /* resume_from */
1644
1645 PPSENDF(&ftpc->pp, data->set.ftp_append?"APPE %s":"STOR %s",
1646 ftpc->file);
1647
1648 state(conn, FTP_STOR);
1649
1650 return result;
1651 }
1652
1653 static CURLcode ftp_state_quote(struct connectdata *conn,
1654 bool init,
1655 ftpstate instate)
1656 {
1657 CURLcode result = CURLE_OK;
1658 struct Curl_easy *data = conn->data;
1659 struct FTP *ftp = data->req.protop;
1660 struct ftp_conn *ftpc = &conn->proto.ftpc;
1661 bool quote = FALSE;
1662 struct curl_slist *item;
1663
1664 switch(instate) {
1665 case FTP_QUOTE:
1666 default:
1667 item = data->set.quote;
1668 break;
1669 case FTP_RETR_PREQUOTE:
1670 case FTP_STOR_PREQUOTE:
1671 item = data->set.prequote;
1672 break;
1673 case FTP_POSTQUOTE:
1674 item = data->set.postquote;
1675 break;
1676 }
1677
1678 /*
1679 * This state uses:
1680 * 'count1' to iterate over the commands to send
1681 * 'count2' to store whether to allow commands to fail
1682 */
1683
1684 if(init)
1685 ftpc->count1 = 0;
1686 else
1687 ftpc->count1++;
1688
1689 if(item) {
1690 int i = 0;
1691
1692 /* Skip count1 items in the linked list */
1693 while((i< ftpc->count1) && item) {
1694 item = item->next;
1695 i++;
1696 }
1697 if(item) {
1698 char *cmd = item->data;
1699 if(cmd[0] == '*') {
1700 cmd++;
1701 ftpc->count2 = 1; /* the sent command is allowed to fail */
1702 }
1703 else
1704 ftpc->count2 = 0; /* failure means cancel operation */
1705
1706 PPSENDF(&ftpc->pp, "%s", cmd);
1707 state(conn, instate);
1708 quote = TRUE;
1709 }
1710 }
1711
1712 if(!quote) {
1713 /* No more quote to send, continue to ... */
1714 switch(instate) {
1715 case FTP_QUOTE:
1716 default:
1717 result = ftp_state_cwd(conn);
1718 break;
1719 case FTP_RETR_PREQUOTE:
1720 if(ftp->transfer != FTPTRANSFER_BODY)
1721 state(conn, FTP_STOP);
1722 else {
1723 if(ftpc->known_filesize != -1) {
1724 Curl_pgrsSetDownloadSize(data, ftpc->known_filesize);
1725 result = ftp_state_retr(conn, ftpc->known_filesize);
1726 }
1727 else {
1728 if(data->set.ignorecl) {
1729 /* This code is to support download of growing files. It prevents
1730 the state machine from requesting the file size from the
1731 server. With an unknown file size the download continues until
1732 the server terminates it, otherwise the client stops if the
1733 received byte count exceeds the reported file size. Set option
1734 CURLOPT_IGNORE_CONTENT_LENGTH to 1 to enable this behavior.*/
1735 PPSENDF(&ftpc->pp, "RETR %s", ftpc->file);
1736 state(conn, FTP_RETR);
1737 }
1738 else {
1739 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file);
1740 state(conn, FTP_RETR_SIZE);
1741 }
1742 }
1743 }
1744 break;
1745 case FTP_STOR_PREQUOTE:
1746 result = ftp_state_ul_setup(conn, FALSE);
1747 break;
1748 case FTP_POSTQUOTE:
1749 break;
1750 }
1751 }
1752
1753 return result;
1754 }
1755
1756 /* called from ftp_state_pasv_resp to switch to PASV in case of EPSV
1757 problems */
1758 static CURLcode ftp_epsv_disable(struct connectdata *conn)
1759 {
1760 CURLcode result = CURLE_OK;
1761
1762 if(conn->bits.ipv6 && !(conn->bits.tunnel_proxy || conn->bits.socksproxy)) {
1763 /* We can't disable EPSV when doing IPv6, so this is instead a fail */
1764 failf(conn->data, "Failed EPSV attempt, exiting\n");
1765 return CURLE_WEIRD_SERVER_REPLY;
1766 }
1767
1768 infof(conn->data, "Failed EPSV attempt. Disabling EPSV\n");
1769 /* disable it for next transfer */
1770 conn->bits.ftp_use_epsv = FALSE;
1771 conn->data->state.errorbuf = FALSE; /* allow error message to get
1772 rewritten */
1773 PPSENDF(&conn->proto.ftpc.pp, "%s", "PASV");
1774 conn->proto.ftpc.count1++;
1775 /* remain in/go to the FTP_PASV state */
1776 state(conn, FTP_PASV);
1777 return result;
1778 }
1779
1780
1781 static char *control_address(struct connectdata *conn)
1782 {
1783 /* Returns the control connection IP address.
1784 If a proxy tunnel is used, returns the original host name instead, because
1785 the effective control connection address is the proxy address,
1786 not the ftp host. */
1787 if(conn->bits.tunnel_proxy || conn->bits.socksproxy)
1788 return conn->host.name;
1789
1790 return conn->ip_addr_str;
1791 }
1792
1793 static CURLcode ftp_state_pasv_resp(struct connectdata *conn,
1794 int ftpcode)
1795 {
1796 struct ftp_conn *ftpc = &conn->proto.ftpc;
1797 CURLcode result;
1798 struct Curl_easy *data = conn->data;
1799 struct Curl_dns_entry *addr = NULL;
1800 enum resolve_t rc;
1801 unsigned short connectport; /* the local port connect() should use! */
1802 char *str = &data->state.buffer[4]; /* start on the first letter */
1803
1804 /* if we come here again, make sure the former name is cleared */
1805 Curl_safefree(ftpc->newhost);
1806
1807 if((ftpc->count1 == 0) &&
1808 (ftpcode == 229)) {
1809 /* positive EPSV response */
1810 char *ptr = strchr(str, '(');
1811 if(ptr) {
1812 unsigned int num;
1813 char separator[4];
1814 ptr++;
1815 if(5 == sscanf(ptr, "%c%c%c%u%c",
1816 &separator[0],
1817 &separator[1],
1818 &separator[2],
1819 &num,
1820 &separator[3])) {
1821 const char sep1 = separator[0];
1822 int i;
1823
1824 /* The four separators should be identical, or else this is an oddly
1825 formatted reply and we bail out immediately. */
1826 for(i = 1; i<4; i++) {
1827 if(separator[i] != sep1) {
1828 ptr = NULL; /* set to NULL to signal error */
1829 break;
1830 }
1831 }
1832 if(num > 0xffff) {
1833 failf(data, "Illegal port number in EPSV reply");
1834 return CURLE_FTP_WEIRD_PASV_REPLY;
1835 }
1836 if(ptr) {
1837 ftpc->newport = (unsigned short)(num & 0xffff);
1838 ftpc->newhost = strdup(control_address(conn));
1839 if(!ftpc->newhost)
1840 return CURLE_OUT_OF_MEMORY;
1841 }
1842 }
1843 else
1844 ptr = NULL;
1845 }
1846 if(!ptr) {
1847 failf(data, "Weirdly formatted EPSV reply");
1848 return CURLE_FTP_WEIRD_PASV_REPLY;
1849 }
1850 }
1851 else if((ftpc->count1 == 1) &&
1852 (ftpcode == 227)) {
1853 /* positive PASV response */
1854 unsigned int ip[4];
1855 unsigned int port[2];
1856
1857 /*
1858 * Scan for a sequence of six comma-separated numbers and use them as
1859 * IP+port indicators.
1860 *
1861 * Found reply-strings include:
1862 * "227 Entering Passive Mode (127,0,0,1,4,51)"
1863 * "227 Data transfer will passively listen to 127,0,0,1,4,51"
1864 * "227 Entering passive mode. 127,0,0,1,4,51"
1865 */
1866 while(*str) {
1867 if(6 == sscanf(str, "%u,%u,%u,%u,%u,%u",
1868 &ip[0], &ip[1], &ip[2], &ip[3],
1869 &port[0], &port[1]))
1870 break;
1871 str++;
1872 }
1873
1874 if(!*str || (ip[0] > 255) || (ip[1] > 255) || (ip[2] > 255) ||
1875 (ip[3] > 255) || (port[0] > 255) || (port[1] > 255) ) {
1876 failf(data, "Couldn't interpret the 227-response");
1877 return CURLE_FTP_WEIRD_227_FORMAT;
1878 }
1879
1880 /* we got OK from server */
1881 if(data->set.ftp_skip_ip) {
1882 /* told to ignore the remotely given IP but instead use the host we used
1883 for the control connection */
1884 infof(data, "Skip %u.%u.%u.%u for data connection, re-use %s instead\n",
1885 ip[0], ip[1], ip[2], ip[3],
1886 conn->host.name);
1887 ftpc->newhost = strdup(control_address(conn));
1888 }
1889 else
1890 ftpc->newhost = aprintf("%u.%u.%u.%u", ip[0], ip[1], ip[2], ip[3]);
1891
1892 if(!ftpc->newhost)
1893 return CURLE_OUT_OF_MEMORY;
1894
1895 ftpc->newport = (unsigned short)(((port[0]<<8) + port[1]) & 0xffff);
1896 }
1897 else if(ftpc->count1 == 0) {
1898 /* EPSV failed, move on to PASV */
1899 return ftp_epsv_disable(conn);
1900 }
1901 else {
1902 failf(data, "Bad PASV/EPSV response: %03d", ftpcode);
1903 return CURLE_FTP_WEIRD_PASV_REPLY;
1904 }
1905
1906 if(conn->bits.proxy) {
1907 /*
1908 * This connection uses a proxy and we need to connect to the proxy again
1909 * here. We don't want to rely on a former host lookup that might've
1910 * expired now, instead we remake the lookup here and now!
1911 */
1912 const char * const host_name = conn->bits.socksproxy ?
1913 conn->socks_proxy.host.name : conn->http_proxy.host.name;
1914 rc = Curl_resolv(conn, host_name, (int)conn->port, FALSE, &addr);
1915 if(rc == CURLRESOLV_PENDING)
1916 /* BLOCKING, ignores the return code but 'addr' will be NULL in
1917 case of failure */
1918 (void)Curl_resolver_wait_resolv(conn, &addr);
1919
1920 connectport =
1921 (unsigned short)conn->port; /* we connect to the proxy's port */
1922
1923 if(!addr) {
1924 failf(data, "Can't resolve proxy host %s:%hu", host_name, connectport);
1925 return CURLE_COULDNT_RESOLVE_PROXY;
1926 }
1927 }
1928 else {
1929 /* normal, direct, ftp connection */
1930 rc = Curl_resolv(conn, ftpc->newhost, ftpc->newport, FALSE, &addr);
1931 if(rc == CURLRESOLV_PENDING)
1932 /* BLOCKING */
1933 (void)Curl_resolver_wait_resolv(conn, &addr);
1934
1935 connectport = ftpc->newport; /* we connect to the remote port */
1936
1937 if(!addr) {
1938 failf(data, "Can't resolve new host %s:%hu", ftpc->newhost, connectport);
1939 return CURLE_FTP_CANT_GET_HOST;
1940 }
1941 }
1942
1943 conn->bits.tcpconnect[SECONDARYSOCKET] = FALSE;
1944 result = Curl_connecthost(conn, addr);
1945
1946 if(result) {
1947 Curl_resolv_unlock(data, addr); /* we're done using this address */
1948 if(ftpc->count1 == 0 && ftpcode == 229)
1949 return ftp_epsv_disable(conn);
1950
1951 return result;
1952 }
1953
1954
1955 /*
1956 * When this is used from the multi interface, this might've returned with
1957 * the 'connected' set to FALSE and thus we are now awaiting a non-blocking
1958 * connect to connect.
1959 */
1960
1961 if(data->set.verbose)
1962 /* this just dumps information about this second connection */
1963 ftp_pasv_verbose(conn, addr->addr, ftpc->newhost, connectport);
1964
1965 Curl_resolv_unlock(data, addr); /* we're done using this address */
1966
1967 Curl_safefree(conn->secondaryhostname);
1968 conn->secondary_port = ftpc->newport;
1969 conn->secondaryhostname = strdup(ftpc->newhost);
1970 if(!conn->secondaryhostname)
1971 return CURLE_OUT_OF_MEMORY;
1972
1973 conn->bits.do_more = TRUE;
1974 state(conn, FTP_STOP); /* this phase is completed */
1975
1976 return result;
1977 }
1978
1979 static CURLcode ftp_state_port_resp(struct connectdata *conn,
1980 int ftpcode)
1981 {
1982 struct Curl_easy *data = conn->data;
1983 struct ftp_conn *ftpc = &conn->proto.ftpc;
1984 ftpport fcmd = (ftpport)ftpc->count1;
1985 CURLcode result = CURLE_OK;
1986
1987 /* The FTP spec tells a positive response should have code 200.
1988 Be more permissive here to tolerate deviant servers. */
1989 if(ftpcode / 100 != 2) {
1990 /* the command failed */
1991
1992 if(EPRT == fcmd) {
1993 infof(data, "disabling EPRT usage\n");
1994 conn->bits.ftp_use_eprt = FALSE;
1995 }
1996 fcmd++;
1997
1998 if(fcmd == DONE) {
1999 failf(data, "Failed to do PORT");
2000 result = CURLE_FTP_PORT_FAILED;
2001 }
2002 else
2003 /* try next */
2004 result = ftp_state_use_port(conn, fcmd);
2005 }
2006 else {
2007 infof(data, "Connect data stream actively\n");
2008 state(conn, FTP_STOP); /* end of DO phase */
2009 result = ftp_dophase_done(conn, FALSE);
2010 }
2011
2012 return result;
2013 }
2014
2015 static CURLcode ftp_state_mdtm_resp(struct connectdata *conn,
2016 int ftpcode)
2017 {
2018 CURLcode result = CURLE_OK;
2019 struct Curl_easy *data = conn->data;
2020 struct FTP *ftp = data->req.protop;
2021 struct ftp_conn *ftpc = &conn->proto.ftpc;
2022
2023 switch(ftpcode) {
2024 case 213:
2025 {
2026 /* we got a time. Format should be: "YYYYMMDDHHMMSS[.sss]" where the
2027 last .sss part is optional and means fractions of a second */
2028 int year, month, day, hour, minute, second;
2029 if(6 == sscanf(&data->state.buffer[4], "%04d%02d%02d%02d%02d%02d",
2030 &year, &month, &day, &hour, &minute, &second)) {
2031 /* we have a time, reformat it */
2032 char timebuf[24];
2033 msnprintf(timebuf, sizeof(timebuf),
2034 "%04d%02d%02d %02d:%02d:%02d GMT",
2035 year, month, day, hour, minute, second);
2036 /* now, convert this into a time() value: */
2037 data->info.filetime = Curl_getdate_capped(timebuf);
2038 }
2039
2040 #ifdef CURL_FTP_HTTPSTYLE_HEAD
2041 /* If we asked for a time of the file and we actually got one as well,
2042 we "emulate" a HTTP-style header in our output. */
2043
2044 if(data->set.opt_no_body &&
2045 ftpc->file &&
2046 data->set.get_filetime &&
2047 (data->info.filetime >= 0) ) {
2048 char headerbuf[128];
2049 time_t filetime = data->info.filetime;
2050 struct tm buffer;
2051 const struct tm *tm = &buffer;
2052
2053 result = Curl_gmtime(filetime, &buffer);
2054 if(result)
2055 return result;
2056
2057 /* format: "Tue, 15 Nov 1994 12:45:26" */
2058 msnprintf(headerbuf, sizeof(headerbuf),
2059 "Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n",
2060 Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],
2061 tm->tm_mday,
2062 Curl_month[tm->tm_mon],
2063 tm->tm_year + 1900,
2064 tm->tm_hour,
2065 tm->tm_min,
2066 tm->tm_sec);
2067 result = Curl_client_write(conn, CLIENTWRITE_BOTH, headerbuf, 0);
2068 if(result)
2069 return result;
2070 } /* end of a ridiculous amount of conditionals */
2071 #endif
2072 }
2073 break;
2074 default:
2075 infof(data, "unsupported MDTM reply format\n");
2076 break;
2077 case 550: /* "No such file or directory" */
2078 failf(data, "Given file does not exist");
2079 result = CURLE_FTP_COULDNT_RETR_FILE;
2080 break;
2081 }
2082
2083 if(data->set.timecondition) {
2084 if((data->info.filetime > 0) && (data->set.timevalue > 0)) {
2085 switch(data->set.timecondition) {
2086 case CURL_TIMECOND_IFMODSINCE:
2087 default:
2088 if(data->info.filetime <= data->set.timevalue) {
2089 infof(data, "The requested document is not new enough\n");
2090 ftp->transfer = FTPTRANSFER_NONE; /* mark to not transfer data */
2091 data->info.timecond = TRUE;
2092 state(conn, FTP_STOP);
2093 return CURLE_OK;
2094 }
2095 break;
2096 case CURL_TIMECOND_IFUNMODSINCE:
2097 if(data->info.filetime > data->set.timevalue) {
2098 infof(data, "The requested document is not old enough\n");
2099 ftp->transfer = FTPTRANSFER_NONE; /* mark to not transfer data */
2100 data->info.timecond = TRUE;
2101 state(conn, FTP_STOP);
2102 return CURLE_OK;
2103 }
2104 break;
2105 } /* switch */
2106 }
2107 else {
2108 infof(data, "Skipping time comparison\n");
2109 }
2110 }
2111
2112 if(!result)
2113 result = ftp_state_type(conn);
2114
2115 return result;
2116 }
2117
2118 static CURLcode ftp_state_type_resp(struct connectdata *conn,
2119 int ftpcode,
2120 ftpstate instate)
2121 {
2122 CURLcode result = CURLE_OK;
2123 struct Curl_easy *data = conn->data;
2124
2125 if(ftpcode/100 != 2) {
2126 /* "sasserftpd" and "(u)r(x)bot ftpd" both responds with 226 after a
2127 successful 'TYPE I'. While that is not as RFC959 says, it is still a
2128 positive response code and we allow that. */
2129 failf(data, "Couldn't set desired mode");
2130 return CURLE_FTP_COULDNT_SET_TYPE;
2131 }
2132 if(ftpcode != 200)
2133 infof(data, "Got a %03d response code instead of the assumed 200\n",
2134 ftpcode);
2135
2136 if(instate == FTP_TYPE)
2137 result = ftp_state_size(conn);
2138 else if(instate == FTP_LIST_TYPE)
2139 result = ftp_state_list(conn);
2140 else if(instate == FTP_RETR_TYPE)
2141 result = ftp_state_retr_prequote(conn);
2142 else if(instate == FTP_STOR_TYPE)
2143 result = ftp_state_stor_prequote(conn);
2144
2145 return result;
2146 }
2147
2148 static CURLcode ftp_state_retr(struct connectdata *conn,
2149 curl_off_t filesize)
2150 {
2151 CURLcode result = CURLE_OK;
2152 struct Curl_easy *data = conn->data;
2153 struct FTP *ftp = data->req.protop;
2154 struct ftp_conn *ftpc = &conn->proto.ftpc;
2155
2156 if(data->set.max_filesize && (filesize > data->set.max_filesize)) {
2157 failf(data, "Maximum file size exceeded");
2158 return CURLE_FILESIZE_EXCEEDED;
2159 }
2160 ftp->downloadsize = filesize;
2161
2162 if(data->state.resume_from) {
2163 /* We always (attempt to) get the size of downloads, so it is done before
2164 this even when not doing resumes. */
2165 if(filesize == -1) {
2166 infof(data, "ftp server doesn't support SIZE\n");
2167 /* We couldn't get the size and therefore we can't know if there really
2168 is a part of the file left to get, although the server will just
2169 close the connection when we start the connection so it won't cause
2170 us any harm, just not make us exit as nicely. */
2171 }
2172 else {
2173 /* We got a file size report, so we check that there actually is a
2174 part of the file left to get, or else we go home. */
2175 if(data->state.resume_from< 0) {
2176 /* We're supposed to download the last abs(from) bytes */
2177 if(filesize < -data->state.resume_from) {
2178 failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T
2179 ") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")",
2180 data->state.resume_from, filesize);
2181 return CURLE_BAD_DOWNLOAD_RESUME;
2182 }
2183 /* convert to size to download */
2184 ftp->downloadsize = -data->state.resume_from;
2185 /* download from where? */
2186 data->state.resume_from = filesize - ftp->downloadsize;
2187 }
2188 else {
2189 if(filesize < data->state.resume_from) {
2190 failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T
2191 ") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")",
2192 data->state.resume_from, filesize);
2193 return CURLE_BAD_DOWNLOAD_RESUME;
2194 }
2195 /* Now store the number of bytes we are expected to download */
2196 ftp->downloadsize = filesize-data->state.resume_from;
2197 }
2198 }
2199
2200 if(ftp->downloadsize == 0) {
2201 /* no data to transfer */
2202 Curl_setup_transfer(data, -1, -1, FALSE, -1);
2203 infof(data, "File already completely downloaded\n");
2204
2205 /* Set ->transfer so that we won't get any error in ftp_done()
2206 * because we didn't transfer the any file */
2207 ftp->transfer = FTPTRANSFER_NONE;
2208 state(conn, FTP_STOP);
2209 return CURLE_OK;
2210 }
2211
2212 /* Set resume file transfer offset */
2213 infof(data, "Instructs server to resume from offset %"
2214 CURL_FORMAT_CURL_OFF_T "\n", data->state.resume_from);
2215
2216 PPSENDF(&ftpc->pp, "REST %" CURL_FORMAT_CURL_OFF_T,
2217 data->state.resume_from);
2218
2219 state(conn, FTP_RETR_REST);
2220 }
2221 else {
2222 /* no resume */
2223 PPSENDF(&ftpc->pp, "RETR %s", ftpc->file);
2224 state(conn, FTP_RETR);
2225 }
2226
2227 return result;
2228 }
2229
2230 static CURLcode ftp_state_size_resp(struct connectdata *conn,
2231 int ftpcode,
2232 ftpstate instate)
2233 {
2234 CURLcode result = CURLE_OK;
2235 struct Curl_easy *data = conn->data;
2236 curl_off_t filesize = -1;
2237 char *buf = data->state.buffer;
2238
2239 /* get the size from the ascii string: */
2240 if(ftpcode == 213) {
2241 /* To allow servers to prepend "rubbish" in the response string, we scan
2242 for all the digits at the end of the response and parse only those as a
2243 number. */
2244 char *start = &buf[4];
2245 char *fdigit = strchr(start, '\r');
2246 if(fdigit) {
2247 do
2248 fdigit--;
2249 while(ISDIGIT(*fdigit) && (fdigit > start));
2250 if(!ISDIGIT(*fdigit))
2251 fdigit++;
2252 }
2253 else
2254 fdigit = start;
2255 /* ignores parsing errors, which will make the size remain unknown */
2256 (void)curlx_strtoofft(fdigit, NULL, 0, &filesize);
2257
2258 }
2259
2260 if(instate == FTP_SIZE) {
2261 #ifdef CURL_FTP_HTTPSTYLE_HEAD
2262 if(-1 != filesize) {
2263 char clbuf[128];
2264 msnprintf(clbuf, sizeof(clbuf),
2265 "Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n", filesize);
2266 result = Curl_client_write(conn, CLIENTWRITE_BOTH, clbuf, 0);
2267 if(result)
2268 return result;
2269 }
2270 #endif
2271 Curl_pgrsSetDownloadSize(data, filesize);
2272 result = ftp_state_rest(conn);
2273 }
2274 else if(instate == FTP_RETR_SIZE) {
2275 Curl_pgrsSetDownloadSize(data, filesize);
2276 result = ftp_state_retr(conn, filesize);
2277 }
2278 else if(instate == FTP_STOR_SIZE) {
2279 data->state.resume_from = filesize;
2280 result = ftp_state_ul_setup(conn, TRUE);
2281 }
2282
2283 return result;
2284 }
2285
2286 static CURLcode ftp_state_rest_resp(struct connectdata *conn,
2287 int ftpcode,
2288 ftpstate instate)
2289 {
2290 CURLcode result = CURLE_OK;
2291 struct ftp_conn *ftpc = &conn->proto.ftpc;
2292
2293 switch(instate) {
2294 case FTP_REST:
2295 default:
2296 #ifdef CURL_FTP_HTTPSTYLE_HEAD
2297 if(ftpcode == 350) {
2298 char buffer[24]= { "Accept-ranges: bytes\r\n" };
2299 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buffer, 0);
2300 if(result)
2301 return result;
2302 }
2303 #endif
2304 result = ftp_state_prepare_transfer(conn);
2305 break;
2306
2307 case FTP_RETR_REST:
2308 if(ftpcode != 350) {
2309 failf(conn->data, "Couldn't use REST");
2310 result = CURLE_FTP_COULDNT_USE_REST;
2311 }
2312 else {
2313 PPSENDF(&ftpc->pp, "RETR %s", ftpc->file);
2314 state(conn, FTP_RETR);
2315 }
2316 break;
2317 }
2318
2319 return result;
2320 }
2321
2322 static CURLcode ftp_state_stor_resp(struct connectdata *conn,
2323 int ftpcode, ftpstate instate)
2324 {
2325 CURLcode result = CURLE_OK;
2326 struct Curl_easy *data = conn->data;
2327
2328 if(ftpcode >= 400) {
2329 failf(data, "Failed FTP upload: %0d", ftpcode);
2330 state(conn, FTP_STOP);
2331 /* oops, we never close the sockets! */
2332 return CURLE_UPLOAD_FAILED;
2333 }
2334
2335 conn->proto.ftpc.state_saved = instate;
2336
2337 /* PORT means we are now awaiting the server to connect to us. */
2338 if(data->set.ftp_use_port) {
2339 bool connected;
2340
2341 state(conn, FTP_STOP); /* no longer in STOR state */
2342
2343 result = AllowServerConnect(conn, &connected);
2344 if(result)
2345 return result;
2346
2347 if(!connected) {
2348 struct ftp_conn *ftpc = &conn->proto.ftpc;
2349 infof(data, "Data conn was not available immediately\n");
2350 ftpc->wait_data_conn = TRUE;
2351 }
2352
2353 return CURLE_OK;
2354 }
2355 return InitiateTransfer(conn);
2356 }
2357
2358 /* for LIST and RETR responses */
2359 static CURLcode ftp_state_get_resp(struct connectdata *conn,
2360 int ftpcode,
2361 ftpstate instate)
2362 {
2363 CURLcode result = CURLE_OK;
2364 struct Curl_easy *data = conn->data;
2365 struct FTP *ftp = data->req.protop;
2366
2367 if((ftpcode == 150) || (ftpcode == 125)) {
2368
2369 /*
2370 A;
2371 150 Opening BINARY mode data connection for /etc/passwd (2241
2372 bytes). (ok, the file is being transferred)
2373
2374 B:
2375 150 Opening ASCII mode data connection for /bin/ls
2376
2377 C:
2378 150 ASCII data connection for /bin/ls (137.167.104.91,37445) (0 bytes).
2379
2380 D:
2381 150 Opening ASCII mode data connection for [file] (0.0.0.0,0) (545 bytes)
2382
2383 E:
2384 125 Data connection already open; Transfer starting. */
2385
2386 curl_off_t size = -1; /* default unknown size */
2387
2388
2389 /*
2390 * It appears that there are FTP-servers that return size 0 for files when
2391 * SIZE is used on the file while being in BINARY mode. To work around
2392 * that (stupid) behavior, we attempt to parse the RETR response even if
2393 * the SIZE returned size zero.
2394 *
2395 * Debugging help from Salvatore Sorrentino on February 26, 2003.
2396 */
2397
2398 if((instate != FTP_LIST) &&
2399 !data->set.prefer_ascii &&
2400 (ftp->downloadsize < 1)) {
2401 /*
2402 * It seems directory listings either don't show the size or very
2403 * often uses size 0 anyway. ASCII transfers may very well turn out
2404 * that the transferred amount of data is not the same as this line
2405 * tells, why using this number in those cases only confuses us.
2406 *
2407 * Example D above makes this parsing a little tricky */
2408 char *bytes;
2409 char *buf = data->state.buffer;
2410 bytes = strstr(buf, " bytes");
2411 if(bytes) {
2412 long in = (long)(--bytes-buf);
2413 /* this is a hint there is size information in there! ;-) */
2414 while(--in) {
2415 /* scan for the left parenthesis and break there */
2416 if('(' == *bytes)
2417 break;
2418 /* skip only digits */
2419 if(!ISDIGIT(*bytes)) {
2420 bytes = NULL;
2421 break;
2422 }
2423 /* one more estep backwards */
2424 bytes--;
2425 }
2426 /* if we have nothing but digits: */
2427 if(bytes++) {
2428 /* get the number! */
2429 (void)curlx_strtoofft(bytes, NULL, 0, &size);
2430 }
2431 }
2432 }
2433 else if(ftp->downloadsize > -1)
2434 size = ftp->downloadsize;
2435
2436 if(size > data->req.maxdownload && data->req.maxdownload > 0)
2437 size = data->req.size = data->req.maxdownload;
2438 else if((instate != FTP_LIST) && (data->set.prefer_ascii))
2439 size = -1; /* kludge for servers that understate ASCII mode file size */
2440
2441 infof(data, "Maxdownload = %" CURL_FORMAT_CURL_OFF_T "\n",
2442 data->req.maxdownload);
2443
2444 if(instate != FTP_LIST)
2445 infof(data, "Getting file with size: %" CURL_FORMAT_CURL_OFF_T "\n",
2446 size);
2447
2448 /* FTP download: */
2449 conn->proto.ftpc.state_saved = instate;
2450 conn->proto.ftpc.retr_size_saved = size;
2451
2452 if(data->set.ftp_use_port) {
2453 bool connected;
2454
2455 result = AllowServerConnect(conn, &connected);
2456 if(result)
2457 return result;
2458
2459 if(!connected) {
2460 struct ftp_conn *ftpc = &conn->proto.ftpc;
2461 infof(data, "Data conn was not available immediately\n");
2462 state(conn, FTP_STOP);
2463 ftpc->wait_data_conn = TRUE;
2464 }
2465 }
2466 else
2467 return InitiateTransfer(conn);
2468 }
2469 else {
2470 if((instate == FTP_LIST) && (ftpcode == 450)) {
2471 /* simply no matching files in the dir listing */
2472 ftp->transfer = FTPTRANSFER_NONE; /* don't download anything */
2473 state(conn, FTP_STOP); /* this phase is over */
2474 }
2475 else {
2476 failf(data, "RETR response: %03d", ftpcode);
2477 return instate == FTP_RETR && ftpcode == 550?
2478 CURLE_REMOTE_FILE_NOT_FOUND:
2479 CURLE_FTP_COULDNT_RETR_FILE;
2480 }
2481 }
2482
2483 return result;
2484 }
2485
2486 /* after USER, PASS and ACCT */
2487 static CURLcode ftp_state_loggedin(struct connectdata *conn)
2488 {
2489 CURLcode result = CURLE_OK;
2490
2491 if(conn->ssl[FIRSTSOCKET].use) {
2492 /* PBSZ = PROTECTION BUFFER SIZE.
2493
2494 The 'draft-murray-auth-ftp-ssl' (draft 12, page 7) says:
2495
2496 Specifically, the PROT command MUST be preceded by a PBSZ
2497 command and a PBSZ command MUST be preceded by a successful
2498 security data exchange (the TLS negotiation in this case)
2499
2500 ... (and on page 8):
2501
2502 Thus the PBSZ command must still be issued, but must have a
2503 parameter of '0' to indicate that no buffering is taking place
2504 and the data connection should not be encapsulated.
2505 */
2506 PPSENDF(&conn->proto.ftpc.pp, "PBSZ %d", 0);
2507 state(conn, FTP_PBSZ);
2508 }
2509 else {
2510 result = ftp_state_pwd(conn);
2511 }
2512 return result;
2513 }
2514
2515 /* for USER and PASS responses */
2516 static CURLcode ftp_state_user_resp(struct connectdata *conn,
2517 int ftpcode,
2518 ftpstate instate)
2519 {
2520 CURLcode result = CURLE_OK;
2521 struct Curl_easy *data = conn->data;
2522 struct ftp_conn *ftpc = &conn->proto.ftpc;
2523 (void)instate; /* no use for this yet */
2524
2525 /* some need password anyway, and others just return 2xx ignored */
2526 if((ftpcode == 331) && (ftpc->state == FTP_USER)) {
2527 /* 331 Password required for ...
2528 (the server requires to send the user's password too) */
2529 PPSENDF(&ftpc->pp, "PASS %s", conn->passwd?conn->passwd:"");
2530 state(conn, FTP_PASS);
2531 }
2532 else if(ftpcode/100 == 2) {
2533 /* 230 User ... logged in.
2534 (the user logged in with or without password) */
2535 result = ftp_state_loggedin(conn);
2536 }
2537 else if(ftpcode == 332) {
2538 if(data->set.str[STRING_FTP_ACCOUNT]) {
2539 PPSENDF(&ftpc->pp, "ACCT %s", data->set.str[STRING_FTP_ACCOUNT]);
2540 state(conn, FTP_ACCT);
2541 }
2542 else {
2543 failf(data, "ACCT requested but none available");
2544 result = CURLE_LOGIN_DENIED;
2545 }
2546 }
2547 else {
2548 /* All other response codes, like:
2549
2550 530 User ... access denied
2551 (the server denies to log the specified user) */
2552
2553 if(conn->data->set.str[STRING_FTP_ALTERNATIVE_TO_USER] &&
2554 !conn->data->state.ftp_trying_alternative) {
2555 /* Ok, USER failed. Let's try the supplied command. */
2556 PPSENDF(&conn->proto.ftpc.pp, "%s",
2557 conn->data->set.str[STRING_FTP_ALTERNATIVE_TO_USER]);
2558 conn->data->state.ftp_trying_alternative = TRUE;
2559 state(conn, FTP_USER);
2560 result = CURLE_OK;
2561 }
2562 else {
2563 failf(data, "Access denied: %03d", ftpcode);
2564 result = CURLE_LOGIN_DENIED;
2565 }
2566 }
2567 return result;
2568 }
2569
2570 /* for ACCT response */
2571 static CURLcode ftp_state_acct_resp(struct connectdata *conn,
2572 int ftpcode)
2573 {
2574 CURLcode result = CURLE_OK;
2575 struct Curl_easy *data = conn->data;
2576 if(ftpcode != 230) {
2577 failf(data, "ACCT rejected by server: %03d", ftpcode);
2578 result = CURLE_FTP_WEIRD_PASS_REPLY; /* FIX */
2579 }
2580 else
2581 result = ftp_state_loggedin(conn);
2582
2583 return result;
2584 }
2585
2586
2587 static CURLcode ftp_statemach_act(struct connectdata *conn)
2588 {
2589 CURLcode result;
2590 curl_socket_t sock = conn->sock[FIRSTSOCKET];
2591 struct Curl_easy *data = conn->data;
2592 int ftpcode;
2593 struct ftp_conn *ftpc = &conn->proto.ftpc;
2594 struct pingpong *pp = &ftpc->pp;
2595 static const char ftpauth[][4] = { "SSL", "TLS" };
2596 size_t nread = 0;
2597
2598 if(pp->sendleft)
2599 return Curl_pp_flushsend(pp);
2600
2601 result = ftp_readresp(sock, pp, &ftpcode, &nread);
2602 if(result)
2603 return result;
2604
2605 if(ftpcode) {
2606 /* we have now received a full FTP server response */
2607 switch(ftpc->state) {
2608 case FTP_WAIT220:
2609 if(ftpcode == 230)
2610 /* 230 User logged in - already! */
2611 return ftp_state_user_resp(conn, ftpcode, ftpc->state);
2612 else if(ftpcode != 220) {
2613 failf(data, "Got a %03d ftp-server response when 220 was expected",
2614 ftpcode);
2615 return CURLE_WEIRD_SERVER_REPLY;
2616 }
2617
2618 /* We have received a 220 response fine, now we proceed. */
2619 #ifdef HAVE_GSSAPI
2620 if(data->set.krb) {
2621 /* If not anonymous login, try a secure login. Note that this
2622 procedure is still BLOCKING. */
2623
2624 Curl_sec_request_prot(conn, "private");
2625 /* We set private first as default, in case the line below fails to
2626 set a valid level */
2627 Curl_sec_request_prot(conn, data->set.str[STRING_KRB_LEVEL]);
2628
2629 if(Curl_sec_login(conn))
2630 infof(data, "Logging in with password in cleartext!\n");
2631 else
2632 infof(data, "Authentication successful\n");
2633 }
2634 #endif
2635
2636 if(data->set.use_ssl &&
2637 (!conn->ssl[FIRSTSOCKET].use ||
2638 (conn->bits.proxy_ssl_connected[FIRSTSOCKET] &&
2639 !conn->proxy_ssl[FIRSTSOCKET].use))) {
2640 /* We don't have a SSL/TLS connection yet, but FTPS is
2641 requested. Try a FTPS connection now */
2642
2643 ftpc->count3 = 0;
2644 switch(data->set.ftpsslauth) {
2645 case CURLFTPAUTH_DEFAULT:
2646 case CURLFTPAUTH_SSL:
2647 ftpc->count2 = 1; /* add one to get next */
2648 ftpc->count1 = 0;
2649 break;
2650 case CURLFTPAUTH_TLS:
2651 ftpc->count2 = -1; /* subtract one to get next */
2652 ftpc->count1 = 1;
2653 break;
2654 default:
2655 failf(data, "unsupported parameter to CURLOPT_FTPSSLAUTH: %d",
2656 (int)data->set.ftpsslauth);
2657 return CURLE_UNKNOWN_OPTION; /* we don't know what to do */
2658 }
2659 PPSENDF(&ftpc->pp, "AUTH %s", ftpauth[ftpc->count1]);
2660 state(conn, FTP_AUTH);
2661 }
2662 else {
2663 result = ftp_state_user(conn);
2664 if(result)
2665 return result;
2666 }
2667
2668 break;
2669
2670 case FTP_AUTH:
2671 /* we have gotten the response to a previous AUTH command */
2672
2673 /* RFC2228 (page 5) says:
2674 *
2675 * If the server is willing to accept the named security mechanism,
2676 * and does not require any security data, it must respond with
2677 * reply code 234/334.
2678 */
2679
2680 if((ftpcode == 234) || (ftpcode == 334)) {
2681 /* Curl_ssl_connect is BLOCKING */
2682 result = Curl_ssl_connect(conn, FIRSTSOCKET);
2683 if(!result) {
2684 conn->bits.ftp_use_data_ssl = FALSE; /* clear-text data */
2685 result = ftp_state_user(conn);
2686 }
2687 }
2688 else if(ftpc->count3 < 1) {
2689 ftpc->count3++;
2690 ftpc->count1 += ftpc->count2; /* get next attempt */
2691 result = Curl_pp_sendf(&ftpc->pp, "AUTH %s", ftpauth[ftpc->count1]);
2692 /* remain in this same state */
2693 }
2694 else {
2695 if(data->set.use_ssl > CURLUSESSL_TRY)
2696 /* we failed and CURLUSESSL_CONTROL or CURLUSESSL_ALL is set */
2697 result = CURLE_USE_SSL_FAILED;
2698 else
2699 /* ignore the failure and continue */
2700 result = ftp_state_user(conn);
2701 }
2702
2703 if(result)
2704 return result;
2705 break;
2706
2707 case FTP_USER:
2708 case FTP_PASS:
2709 result = ftp_state_user_resp(conn, ftpcode, ftpc->state);
2710 break;
2711
2712 case FTP_ACCT:
2713 result = ftp_state_acct_resp(conn, ftpcode);
2714 break;
2715
2716 case FTP_PBSZ:
2717 PPSENDF(&ftpc->pp, "PROT %c",
2718 data->set.use_ssl == CURLUSESSL_CONTROL ? 'C' : 'P');
2719 state(conn, FTP_PROT);
2720
2721 break;
2722
2723 case FTP_PROT:
2724 if(ftpcode/100 == 2)
2725 /* We have enabled SSL for the data connection! */
2726 conn->bits.ftp_use_data_ssl =
2727 (data->set.use_ssl != CURLUSESSL_CONTROL) ? TRUE : FALSE;
2728 /* FTP servers typically responds with 500 if they decide to reject
2729 our 'P' request */
2730 else if(data->set.use_ssl > CURLUSESSL_CONTROL)
2731 /* we failed and bails out */
2732 return CURLE_USE_SSL_FAILED;
2733
2734 if(data->set.ftp_ccc) {
2735 /* CCC - Clear Command Channel
2736 */
2737 PPSENDF(&ftpc->pp, "%s", "CCC");
2738 state(conn, FTP_CCC);
2739 }
2740 else {
2741 result = ftp_state_pwd(conn);
2742 if(result)
2743 return result;
2744 }
2745 break;
2746
2747 case FTP_CCC:
2748 if(ftpcode < 500) {
2749 /* First shut down the SSL layer (note: this call will block) */
2750 result = Curl_ssl_shutdown(conn, FIRSTSOCKET);
2751
2752 if(result) {
2753 failf(conn->data, "Failed to clear the command channel (CCC)");
2754 return result;
2755 }
2756 }
2757
2758 /* Then continue as normal */
2759 result = ftp_state_pwd(conn);
2760 if(result)
2761 return result;
2762 break;
2763
2764 case FTP_PWD:
2765 if(ftpcode == 257) {
2766 char *ptr = &data->state.buffer[4]; /* start on the first letter */
2767 const size_t buf_size = data->set.buffer_size;
2768 char *dir;
2769 bool entry_extracted = FALSE;
2770
2771 dir = malloc(nread + 1);
2772 if(!dir)
2773 return CURLE_OUT_OF_MEMORY;
2774
2775 /* Reply format is like
2776 257<space>[rubbish]"<directory-name>"<space><commentary> and the
2777 RFC959 says
2778
2779 The directory name can contain any character; embedded
2780 double-quotes should be escaped by double-quotes (the
2781 "quote-doubling" convention).
2782 */
2783
2784 /* scan for the first double-quote for non-standard responses */
2785 while(ptr < &data->state.buffer[buf_size]
2786 && *ptr != '\n' && *ptr != '\0' && *ptr != '"')
2787 ptr++;
2788
2789 if('\"' == *ptr) {
2790 /* it started good */
2791 char *store;
2792 ptr++;
2793 for(store = dir; *ptr;) {
2794 if('\"' == *ptr) {
2795 if('\"' == ptr[1]) {
2796 /* "quote-doubling" */
2797 *store = ptr[1];
2798 ptr++;
2799 }
2800 else {
2801 /* end of path */
2802 entry_extracted = TRUE;
2803 break; /* get out of this loop */
2804 }
2805 }
2806 else
2807 *store = *ptr;
2808 store++;
2809 ptr++;
2810 }
2811 *store = '\0'; /* zero terminate */
2812 }
2813 if(entry_extracted) {
2814 /* If the path name does not look like an absolute path (i.e.: it
2815 does not start with a '/'), we probably need some server-dependent
2816 adjustments. For example, this is the case when connecting to
2817 an OS400 FTP server: this server supports two name syntaxes,
2818 the default one being incompatible with standard paths. In
2819 addition, this server switches automatically to the regular path
2820 syntax when one is encountered in a command: this results in
2821 having an entrypath in the wrong syntax when later used in CWD.
2822 The method used here is to check the server OS: we do it only
2823 if the path name looks strange to minimize overhead on other
2824 systems. */
2825
2826 if(!ftpc->server_os && dir[0] != '/') {
2827
2828 result = Curl_pp_sendf(&ftpc->pp, "%s", "SYST");
2829 if(result) {
2830 free(dir);
2831 return result;
2832 }
2833 Curl_safefree(ftpc->entrypath);
2834 ftpc->entrypath = dir; /* remember this */
2835 infof(data, "Entry path is '%s'\n", ftpc->entrypath);
2836 /* also save it where getinfo can access it: */
2837 data->state.most_recent_ftp_entrypath = ftpc->entrypath;
2838 state(conn, FTP_SYST);
2839 break;
2840 }
2841
2842 Curl_safefree(ftpc->entrypath);
2843 ftpc->entrypath = dir; /* remember this */
2844 infof(data, "Entry path is '%s'\n", ftpc->entrypath);
2845 /* also save it where getinfo can access it: */
2846 data->state.most_recent_ftp_entrypath = ftpc->entrypath;
2847 }
2848 else {
2849 /* couldn't get the path */
2850 free(dir);
2851 infof(data, "Failed to figure out path\n");
2852 }
2853 }
2854 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2855 DEBUGF(infof(data, "protocol connect phase DONE\n"));
2856 break;
2857
2858 case FTP_SYST:
2859 if(ftpcode == 215) {
2860 char *ptr = &data->state.buffer[4]; /* start on the first letter */
2861 char *os;
2862 char *store;
2863
2864 os = malloc(nread + 1);
2865 if(!os)
2866 return CURLE_OUT_OF_MEMORY;
2867
2868 /* Reply format is like
2869 215<space><OS-name><space><commentary>
2870 */
2871 while(*ptr == ' ')
2872 ptr++;
2873 for(store = os; *ptr && *ptr != ' ';)
2874 *store++ = *ptr++;
2875 *store = '\0'; /* zero terminate */
2876
2877 /* Check for special servers here. */
2878
2879 if(strcasecompare(os, "OS/400")) {
2880 /* Force OS400 name format 1. */
2881 result = Curl_pp_sendf(&ftpc->pp, "%s", "SITE NAMEFMT 1");
2882 if(result) {
2883 free(os);
2884 return result;
2885 }
2886 /* remember target server OS */
2887 Curl_safefree(ftpc->server_os);
2888 ftpc->server_os = os;
2889 state(conn, FTP_NAMEFMT);
2890 break;
2891 }
2892 /* Nothing special for the target server. */
2893 /* remember target server OS */
2894 Curl_safefree(ftpc->server_os);
2895 ftpc->server_os = os;
2896 }
2897 else {
2898 /* Cannot identify server OS. Continue anyway and cross fingers. */
2899 }
2900
2901 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2902 DEBUGF(infof(data, "protocol connect phase DONE\n"));
2903 break;
2904
2905 case FTP_NAMEFMT:
2906 if(ftpcode == 250) {
2907 /* Name format change successful: reload initial path. */
2908 ftp_state_pwd(conn);
2909 break;
2910 }
2911
2912 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2913 DEBUGF(infof(data, "protocol connect phase DONE\n"));
2914 break;
2915
2916 case FTP_QUOTE:
2917 case FTP_POSTQUOTE:
2918 case FTP_RETR_PREQUOTE:
2919 case FTP_STOR_PREQUOTE:
2920 if((ftpcode >= 400) && !ftpc->count2) {
2921 /* failure response code, and not allowed to fail */
2922 failf(conn->data, "QUOT command failed with %03d", ftpcode);
2923 return CURLE_QUOTE_ERROR;
2924 }
2925 result = ftp_state_quote(conn, FALSE, ftpc->state);
2926 if(result)
2927 return result;
2928
2929 break;
2930
2931 case FTP_CWD:
2932 if(ftpcode/100 != 2) {
2933 /* failure to CWD there */
2934 if(conn->data->set.ftp_create_missing_dirs &&
2935 ftpc->cwdcount && !ftpc->count2) {
2936 /* try making it */
2937 ftpc->count2++; /* counter to prevent CWD-MKD loops */
2938 PPSENDF(&ftpc->pp, "MKD %s", ftpc->dirs[ftpc->cwdcount - 1]);
2939 state(conn, FTP_MKD);
2940 }
2941 else {
2942 /* return failure */
2943 failf(data, "Server denied you to change to the given directory");
2944 ftpc->cwdfail = TRUE; /* don't remember this path as we failed
2945 to enter it */
2946 return CURLE_REMOTE_ACCESS_DENIED;
2947 }
2948 }
2949 else {
2950 /* success */
2951 ftpc->count2 = 0;
2952 if(++ftpc->cwdcount <= ftpc->dirdepth) {
2953 /* send next CWD */
2954 PPSENDF(&ftpc->pp, "CWD %s", ftpc->dirs[ftpc->cwdcount - 1]);
2955 }
2956 else {
2957 result = ftp_state_mdtm(conn);
2958 if(result)
2959 return result;
2960 }
2961 }
2962 break;
2963
2964 case FTP_MKD:
2965 if((ftpcode/100 != 2) && !ftpc->count3--) {
2966 /* failure to MKD the dir */
2967 failf(data, "Failed to MKD dir: %03d", ftpcode);
2968 return CURLE_REMOTE_ACCESS_DENIED;
2969 }
2970 state(conn, FTP_CWD);
2971 /* send CWD */
2972 PPSENDF(&ftpc->pp, "CWD %s", ftpc->dirs[ftpc->cwdcount - 1]);
2973 break;
2974
2975 case FTP_MDTM:
2976 result = ftp_state_mdtm_resp(conn, ftpcode);
2977 break;
2978
2979 case FTP_TYPE:
2980 case FTP_LIST_TYPE:
2981 case FTP_RETR_TYPE:
2982 case FTP_STOR_TYPE:
2983 result = ftp_state_type_resp(conn, ftpcode, ftpc->state);
2984 break;
2985
2986 case FTP_SIZE:
2987 case FTP_RETR_SIZE:
2988 case FTP_STOR_SIZE:
2989 result = ftp_state_size_resp(conn, ftpcode, ftpc->state);
2990 break;
2991
2992 case FTP_REST:
2993 case FTP_RETR_REST:
2994 result = ftp_state_rest_resp(conn, ftpcode, ftpc->state);
2995 break;
2996
2997 case FTP_PRET:
2998 if(ftpcode != 200) {
2999 /* there only is this one standard OK return code. */
3000 failf(data, "PRET command not accepted: %03d", ftpcode);
3001 return CURLE_FTP_PRET_FAILED;
3002 }
3003 result = ftp_state_use_pasv(conn);
3004 break;
3005
3006 case FTP_PASV:
3007 result = ftp_state_pasv_resp(conn, ftpcode);
3008 break;
3009
3010 case FTP_PORT:
3011 result = ftp_state_port_resp(conn, ftpcode);
3012 break;
3013
3014 case FTP_LIST:
3015 case FTP_RETR:
3016 result = ftp_state_get_resp(conn, ftpcode, ftpc->state);
3017 break;
3018
3019 case FTP_STOR:
3020 result = ftp_state_stor_resp(conn, ftpcode, ftpc->state);
3021 break;
3022
3023 case FTP_QUIT:
3024 /* fallthrough, just stop! */
3025 default:
3026 /* internal error */
3027 state(conn, FTP_STOP);
3028 break;
3029 }
3030 } /* if(ftpcode) */
3031
3032 return result;
3033 }
3034
3035
3036 /* called repeatedly until done from multi.c */
3037 static CURLcode ftp_multi_statemach(struct connectdata *conn,
3038 bool *done)
3039 {
3040 struct ftp_conn *ftpc = &conn->proto.ftpc;
3041 CURLcode result = Curl_pp_statemach(&ftpc->pp, FALSE, FALSE);
3042
3043 /* Check for the state outside of the Curl_socket_check() return code checks
3044 since at times we are in fact already in this state when this function
3045 gets called. */
3046 *done = (ftpc->state == FTP_STOP) ? TRUE : FALSE;
3047
3048 return result;
3049 }
3050
3051 static CURLcode ftp_block_statemach(struct connectdata *conn)
3052 {
3053 struct ftp_conn *ftpc = &conn->proto.ftpc;
3054 struct pingpong *pp = &ftpc->pp;
3055 CURLcode result = CURLE_OK;
3056
3057 while(ftpc->state != FTP_STOP) {
3058 result = Curl_pp_statemach(pp, TRUE, TRUE /* disconnecting */);
3059 if(result)
3060 break;
3061 }
3062
3063 return result;
3064 }
3065
3066 /*
3067 * ftp_connect() should do everything that is to be considered a part of
3068 * the connection phase.
3069 *
3070 * The variable 'done' points to will be TRUE if the protocol-layer connect
3071 * phase is done when this function returns, or FALSE if not.
3072 *
3073 */
3074 static CURLcode ftp_connect(struct connectdata *conn,
3075 bool *done) /* see description above */
3076 {
3077 CURLcode result;
3078 struct ftp_conn *ftpc = &conn->proto.ftpc;
3079 struct pingpong *pp = &ftpc->pp;
3080
3081 *done = FALSE; /* default to not done yet */
3082
3083 /* We always support persistent connections on ftp */
3084 connkeep(conn, "FTP default");
3085
3086 pp->response_time = RESP_TIMEOUT; /* set default response time-out */
3087 pp->statemach_act = ftp_statemach_act;
3088 pp->endofresp = ftp_endofresp;
3089 pp->conn = conn;
3090
3091 if(conn->handler->flags & PROTOPT_SSL) {
3092 /* BLOCKING */
3093 result = Curl_ssl_connect(conn, FIRSTSOCKET);
3094 if(result)
3095 return result;
3096 }
3097
3098 Curl_pp_init(pp); /* init the generic pingpong data */
3099
3100 /* When we connect, we start in the state where we await the 220
3101 response */
3102 state(conn, FTP_WAIT220);
3103
3104 result = ftp_multi_statemach(conn, done);
3105
3106 return result;
3107 }
3108
3109 /***********************************************************************
3110 *
3111 * ftp_done()
3112 *
3113 * The DONE function. This does what needs to be done after a single DO has
3114 * performed.
3115 *
3116 * Input argument is already checked for validity.
3117 */
3118 static CURLcode ftp_done(struct connectdata *conn, CURLcode status,
3119 bool premature)
3120 {
3121 struct Curl_easy *data = conn->data;
3122 struct FTP *ftp = data->req.protop;
3123 struct ftp_conn *ftpc = &conn->proto.ftpc;
3124 struct pingpong *pp = &ftpc->pp;
3125 ssize_t nread;
3126 int ftpcode;
3127 CURLcode result = CURLE_OK;
3128 char *rawPath = NULL;
3129 size_t pathLen = 0;
3130
3131 if(!ftp)
3132 return CURLE_OK;
3133
3134 switch(status) {
3135 case CURLE_BAD_DOWNLOAD_RESUME:
3136 case CURLE_FTP_WEIRD_PASV_REPLY:
3137 case CURLE_FTP_PORT_FAILED:
3138 case CURLE_FTP_ACCEPT_FAILED:
3139 case CURLE_FTP_ACCEPT_TIMEOUT:
3140 case CURLE_FTP_COULDNT_SET_TYPE:
3141 case CURLE_FTP_COULDNT_RETR_FILE:
3142 case CURLE_PARTIAL_FILE:
3143 case CURLE_UPLOAD_FAILED:
3144 case CURLE_REMOTE_ACCESS_DENIED:
3145 case CURLE_FILESIZE_EXCEEDED:
3146 case CURLE_REMOTE_FILE_NOT_FOUND:
3147 case CURLE_WRITE_ERROR:
3148 /* the connection stays alive fine even though this happened */
3149 /* fall-through */
3150 case CURLE_OK: /* doesn't affect the control connection's status */
3151 if(!premature)
3152 break;
3153
3154 /* until we cope better with prematurely ended requests, let them
3155 * fallback as if in complete failure */
3156 /* FALLTHROUGH */
3157 default: /* by default, an error means the control connection is
3158 wedged and should not be used anymore */
3159 ftpc->ctl_valid = FALSE;
3160 ftpc->cwdfail = TRUE; /* set this TRUE to prevent us to remember the
3161 current path, as this connection is going */
3162 connclose(conn, "FTP ended with bad error code");
3163 result = status; /* use the already set error code */
3164 break;
3165 }
3166
3167 if(data->state.wildcardmatch) {
3168 if(data->set.chunk_end && ftpc->file) {
3169 Curl_set_in_callback(data, true);
3170 data->set.chunk_end(data->wildcard.customptr);
3171 Curl_set_in_callback(data, false);
3172 }
3173 ftpc->known_filesize = -1;
3174 }
3175
3176 if(!result)
3177 /* get the url-decoded "raw" path */
3178 result = Curl_urldecode(data, ftp->path, 0, &rawPath, &pathLen, TRUE);
3179 if(result) {
3180 /* We can limp along anyway (and should try to since we may already be in
3181 * the error path) */
3182 ftpc->ctl_valid = FALSE; /* mark control connection as bad */
3183 connclose(conn, "FTP: out of memory!"); /* mark for connection closure */
3184 free(ftpc->prevpath);
3185 ftpc->prevpath = NULL; /* no path remembering */
3186 }
3187 else { /* remember working directory for connection reuse */
3188 if((data->set.ftp_filemethod == FTPFILE_NOCWD) && (rawPath[0] == '/'))
3189 free(rawPath); /* full path => no CWDs happened => keep ftpc->prevpath */
3190 else {
3191 free(ftpc->prevpath);
3192
3193 if(!ftpc->cwdfail) {
3194 if(data->set.ftp_filemethod == FTPFILE_NOCWD)
3195 pathLen = 0; /* relative path => working directory is FTP home */
3196 else
3197 pathLen -= ftpc->file?strlen(ftpc->file):0; /* file is url-decoded */
3198
3199 rawPath[pathLen] = '\0';
3200 ftpc->prevpath = rawPath;
3201 }
3202 else {
3203 free(rawPath);
3204 ftpc->prevpath = NULL; /* no path */
3205 }
3206 }
3207
3208 if(ftpc->prevpath)
3209 infof(data, "Remembering we are in dir \"%s\"\n", ftpc->prevpath);
3210 }
3211
3212 /* free the dir tree and file parts */
3213 freedirs(ftpc);
3214
3215 /* shut down the socket to inform the server we're done */
3216
3217 #ifdef _WIN32_WCE
3218 shutdown(conn->sock[SECONDARYSOCKET], 2); /* SD_BOTH */
3219 #endif
3220
3221 if(conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD) {
3222 if(!result && ftpc->dont_check && data->req.maxdownload > 0) {
3223 /* partial download completed */
3224 result = Curl_pp_sendf(pp, "%s", "ABOR");
3225 if(result) {
3226 failf(data, "Failure sending ABOR command: %s",
3227 curl_easy_strerror(result));
3228 ftpc->ctl_valid = FALSE; /* mark control connection as bad */
3229 connclose(conn, "ABOR command failed"); /* connection closure */
3230 }
3231 }
3232
3233 if(conn->ssl[SECONDARYSOCKET].use) {
3234 /* The secondary socket is using SSL so we must close down that part
3235 first before we close the socket for real */
3236 Curl_ssl_close(conn, SECONDARYSOCKET);
3237
3238 /* Note that we keep "use" set to TRUE since that (next) connection is
3239 still requested to use SSL */
3240 }
3241 close_secondarysocket(conn);
3242 }
3243
3244 if(!result && (ftp->transfer == FTPTRANSFER_BODY) && ftpc->ctl_valid &&
3245 pp->pending_resp && !premature) {
3246 /*
3247 * Let's see what the server says about the transfer we just performed,
3248 * but lower the timeout as sometimes this connection has died while the
3249 * data has been transferred. This happens when doing through NATs etc that
3250 * abandon old silent connections.
3251 */
3252 long old_time = pp->response_time;
3253
3254 pp->response_time = 60*1000; /* give it only a minute for now */
3255 pp->response = Curl_now(); /* timeout relative now */
3256
3257 result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
3258
3259 pp->response_time = old_time; /* set this back to previous value */
3260
3261 if(!nread && (CURLE_OPERATION_TIMEDOUT == result)) {
3262 failf(data, "control connection looks dead");
3263 ftpc->ctl_valid = FALSE; /* mark control connection as bad */
3264 connclose(conn, "Timeout or similar in FTP DONE operation"); /* close */
3265 }
3266
3267 if(result)
3268 return result;
3269
3270 if(ftpc->dont_check && data->req.maxdownload > 0) {
3271 /* we have just sent ABOR and there is no reliable way to check if it was
3272 * successful or not; we have to close the connection now */
3273 infof(data, "partial download completed, closing connection\n");
3274 connclose(conn, "Partial download with no ability to check");
3275 return result;
3276 }
3277
3278 if(!ftpc->dont_check) {
3279 /* 226 Transfer complete, 250 Requested file action okay, completed. */
3280 if((ftpcode != 226) && (ftpcode != 250)) {
3281 failf(data, "server did not report OK, got %d", ftpcode);
3282 result = CURLE_PARTIAL_FILE;
3283 }
3284 }
3285 }
3286
3287 if(result || premature)
3288 /* the response code from the transfer showed an error already so no
3289 use checking further */
3290 ;
3291 else if(data->set.upload) {
3292 if((-1 != data->state.infilesize) &&
3293 (data->state.infilesize != data->req.writebytecount) &&
3294 !data->set.crlf &&
3295 (ftp->transfer == FTPTRANSFER_BODY)) {
3296 failf(data, "Uploaded unaligned file size (%" CURL_FORMAT_CURL_OFF_T
3297 " out of %" CURL_FORMAT_CURL_OFF_T " bytes)",
3298 data->req.bytecount, data->state.infilesize);
3299 result = CURLE_PARTIAL_FILE;
3300 }
3301 }
3302 else {
3303 if((-1 != data->req.size) &&
3304 (data->req.size != data->req.bytecount) &&
3305 #ifdef CURL_DO_LINEEND_CONV
3306 /* Most FTP servers don't adjust their file SIZE response for CRLFs, so
3307 * we'll check to see if the discrepancy can be explained by the number
3308 * of CRLFs we've changed to LFs.
3309 */
3310 ((data->req.size + data->state.crlf_conversions) !=
3311 data->req.bytecount) &&
3312 #endif /* CURL_DO_LINEEND_CONV */
3313 (data->req.maxdownload != data->req.bytecount)) {
3314 failf(data, "Received only partial file: %" CURL_FORMAT_CURL_OFF_T
3315 " bytes", data->req.bytecount);
3316 result = CURLE_PARTIAL_FILE;
3317 }
3318 else if(!ftpc->dont_check &&
3319 !data->req.bytecount &&
3320 (data->req.size>0)) {
3321 failf(data, "No data was received!");
3322 result = CURLE_FTP_COULDNT_RETR_FILE;
3323 }
3324 }
3325
3326 /* clear these for next connection */
3327 ftp->transfer = FTPTRANSFER_BODY;
3328 ftpc->dont_check = FALSE;
3329
3330 /* Send any post-transfer QUOTE strings? */
3331 if(!status && !result && !premature && data->set.postquote)
3332 result = ftp_sendquote(conn, data->set.postquote);
3333 Curl_safefree(ftp->pathalloc);
3334 return result;
3335 }
3336
3337 /***********************************************************************
3338 *
3339 * ftp_sendquote()
3340 *
3341 * Where a 'quote' means a list of custom commands to send to the server.
3342 * The quote list is passed as an argument.
3343 *
3344 * BLOCKING
3345 */
3346
3347 static
3348 CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
3349 {
3350 struct curl_slist *item;
3351 ssize_t nread;
3352 int ftpcode;
3353 CURLcode result;
3354 struct ftp_conn *ftpc = &conn->proto.ftpc;
3355 struct pingpong *pp = &ftpc->pp;
3356
3357 item = quote;
3358 while(item) {
3359 if(item->data) {
3360 char *cmd = item->data;
3361 bool acceptfail = FALSE;
3362
3363 /* if a command starts with an asterisk, which a legal FTP command never
3364 can, the command will be allowed to fail without it causing any
3365 aborts or cancels etc. It will cause libcurl to act as if the command
3366 is successful, whatever the server reponds. */
3367
3368 if(cmd[0] == '*') {
3369 cmd++;
3370 acceptfail = TRUE;
3371 }
3372
3373 PPSENDF(&conn->proto.ftpc.pp, "%s", cmd);
3374
3375 pp->response = Curl_now(); /* timeout relative now */
3376
3377 result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
3378 if(result)
3379 return result;
3380
3381 if(!acceptfail && (ftpcode >= 400)) {
3382 failf(conn->data, "QUOT string not accepted: %s", cmd);
3383 return CURLE_QUOTE_ERROR;
3384 }
3385 }
3386
3387 item = item->next;
3388 }
3389
3390 return CURLE_OK;
3391 }
3392
3393 /***********************************************************************
3394 *
3395 * ftp_need_type()
3396 *
3397 * Returns TRUE if we in the current situation should send TYPE
3398 */
3399 static int ftp_need_type(struct connectdata *conn,
3400 bool ascii_wanted)
3401 {
3402 return conn->proto.ftpc.transfertype != (ascii_wanted?'A':'I');
3403 }
3404
3405 /***********************************************************************
3406 *
3407 * ftp_nb_type()
3408 *
3409 * Set TYPE. We only deal with ASCII or BINARY so this function
3410 * sets one of them.
3411 * If the transfer type is not sent, simulate on OK response in newstate
3412 */
3413 static CURLcode ftp_nb_type(struct connectdata *conn,
3414 bool ascii, ftpstate newstate)
3415 {
3416 struct ftp_conn *ftpc = &conn->proto.ftpc;
3417 CURLcode result;
3418 char want = (char)(ascii?'A':'I');
3419
3420 if(ftpc->transfertype == want) {
3421 state(conn, newstate);
3422 return ftp_state_type_resp(conn, 200, newstate);
3423 }
3424
3425 PPSENDF(&ftpc->pp, "TYPE %c", want);
3426 state(conn, newstate);
3427
3428 /* keep track of our current transfer type */
3429 ftpc->transfertype = want;
3430 return CURLE_OK;
3431 }
3432
3433 /***************************************************************************
3434 *
3435 * ftp_pasv_verbose()
3436 *
3437 * This function only outputs some informationals about this second connection
3438 * when we've issued a PASV command before and thus we have connected to a
3439 * possibly new IP address.
3440 *
3441 */
3442 #ifndef CURL_DISABLE_VERBOSE_STRINGS
3443 static void
3444 ftp_pasv_verbose(struct connectdata *conn,
3445 Curl_addrinfo *ai,
3446 char *newhost, /* ascii version */
3447 int port)
3448 {
3449 char buf[256];
3450 Curl_printable_address(ai, buf, sizeof(buf));
3451 infof(conn->data, "Connecting to %s (%s) port %d\n", newhost, buf, port);
3452 }
3453 #endif
3454
3455 /*
3456 * ftp_do_more()
3457 *
3458 * This function shall be called when the second FTP (data) connection is
3459 * connected.
3460 *
3461 * 'complete' can return 0 for incomplete, 1 for done and -1 for go back
3462 * (which basically is only for when PASV is being sent to retry a failed
3463 * EPSV).
3464 */
3465
3466 static CURLcode ftp_do_more(struct connectdata *conn, int *completep)
3467 {
3468 struct Curl_easy *data = conn->data;
3469 struct ftp_conn *ftpc = &conn->proto.ftpc;
3470 CURLcode result = CURLE_OK;
3471 bool connected = FALSE;
3472 bool complete = FALSE;
3473
3474 /* the ftp struct is inited in ftp_connect() */
3475 struct FTP *ftp = data->req.protop;
3476
3477 /* if the second connection isn't done yet, wait for it */
3478 if(!conn->bits.tcpconnect[SECONDARYSOCKET]) {
3479 if(Curl_connect_ongoing(conn)) {
3480 /* As we're in TUNNEL_CONNECT state now, we know the proxy name and port
3481 aren't used so we blank their arguments. */
3482 result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, NULL, 0);
3483
3484 return result;
3485 }
3486
3487 result = Curl_is_connected(conn, SECONDARYSOCKET, &connected);
3488
3489 /* Ready to do more? */
3490 if(connected) {
3491 DEBUGF(infof(data, "DO-MORE connected phase starts\n"));
3492 }
3493 else {
3494 if(result && (ftpc->count1 == 0)) {
3495 *completep = -1; /* go back to DOING please */
3496 /* this is a EPSV connect failing, try PASV instead */
3497 return ftp_epsv_disable(conn);
3498 }
3499 return result;
3500 }
3501 }
3502
3503 result = Curl_proxy_connect(conn, SECONDARYSOCKET);
3504 if(result)
3505 return result;
3506
3507 if(CONNECT_SECONDARYSOCKET_PROXY_SSL())
3508 return result;
3509
3510 if(conn->bits.tunnel_proxy && conn->bits.httpproxy &&
3511 Curl_connect_ongoing(conn))
3512 return result;
3513
3514
3515 if(ftpc->state) {
3516 /* already in a state so skip the initial commands.
3517 They are only done to kickstart the do_more state */
3518 result = ftp_multi_statemach(conn, &complete);
3519
3520 *completep = (int)complete;
3521
3522 /* if we got an error or if we don't wait for a data connection return
3523 immediately */
3524 if(result || !ftpc->wait_data_conn)
3525 return result;
3526
3527 /* if we reach the end of the FTP state machine here, *complete will be
3528 TRUE but so is ftpc->wait_data_conn, which says we need to wait for the
3529 data connection and therefore we're not actually complete */
3530 *completep = 0;
3531 }
3532
3533 if(ftp->transfer <= FTPTRANSFER_INFO) {
3534 /* a transfer is about to take place, or if not a file name was given
3535 so we'll do a SIZE on it later and then we need the right TYPE first */
3536
3537 if(ftpc->wait_data_conn == TRUE) {
3538 bool serv_conned;
3539
3540 result = ReceivedServerConnect(conn, &serv_conned);
3541 if(result)
3542 return result; /* Failed to accept data connection */
3543
3544 if(serv_conned) {
3545 /* It looks data connection is established */
3546 result = AcceptServerConnect(conn);
3547 ftpc->wait_data_conn = FALSE;
3548 if(!result)
3549 result = InitiateTransfer(conn);
3550
3551 if(result)
3552 return result;
3553
3554 *completep = 1; /* this state is now complete when the server has
3555 connected back to us */
3556 }
3557 }
3558 else if(data->set.upload) {
3559 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_STOR_TYPE);
3560 if(result)
3561 return result;
3562
3563 result = ftp_multi_statemach(conn, &complete);
3564 /* ftpc->wait_data_conn is always false here */
3565 *completep = (int)complete;
3566 }
3567 else {
3568 /* download */
3569 ftp->downloadsize = -1; /* unknown as of yet */
3570
3571 result = Curl_range(conn);
3572
3573 if(result == CURLE_OK && data->req.maxdownload >= 0) {
3574 /* Don't check for successful transfer */
3575 ftpc->dont_check = TRUE;
3576 }
3577
3578 if(result)
3579 ;
3580 else if(data->set.ftp_list_only || !ftpc->file) {
3581 /* The specified path ends with a slash, and therefore we think this
3582 is a directory that is requested, use LIST. But before that we
3583 need to set ASCII transfer mode. */
3584
3585 /* But only if a body transfer was requested. */
3586 if(ftp->transfer == FTPTRANSFER_BODY) {
3587 result = ftp_nb_type(conn, TRUE, FTP_LIST_TYPE);
3588 if(result)
3589 return result;
3590 }
3591 /* otherwise just fall through */
3592 }
3593 else {
3594 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_RETR_TYPE);
3595 if(result)
3596 return result;
3597 }
3598
3599 result = ftp_multi_statemach(conn, &complete);
3600 *completep = (int)complete;
3601 }
3602 return result;
3603 }
3604
3605 /* no data to transfer */
3606 Curl_setup_transfer(data, -1, -1, FALSE, -1);
3607
3608 if(!ftpc->wait_data_conn) {
3609 /* no waiting for the data connection so this is now complete */
3610 *completep = 1;
3611 DEBUGF(infof(data, "DO-MORE phase ends with %d\n", (int)result));
3612 }
3613
3614 return result;
3615 }
3616
3617
3618
3619 /***********************************************************************
3620 *
3621 * ftp_perform()
3622 *
3623 * This is the actual DO function for FTP. Get a file/directory according to
3624 * the options previously setup.
3625 */
3626
3627 static
3628 CURLcode ftp_perform(struct connectdata *conn,
3629 bool *connected, /* connect status after PASV / PORT */
3630 bool *dophase_done)
3631 {
3632 /* this is FTP and no proxy */
3633 CURLcode result = CURLE_OK;
3634
3635 DEBUGF(infof(conn->data, "DO phase starts\n"));
3636
3637 if(conn->data->set.opt_no_body) {
3638 /* requested no body means no transfer... */
3639 struct FTP *ftp = conn->data->req.protop;
3640 ftp->transfer = FTPTRANSFER_INFO;
3641 }
3642
3643 *dophase_done = FALSE; /* not done yet */
3644
3645 /* start the first command in the DO phase */
3646 result = ftp_state_quote(conn, TRUE, FTP_QUOTE);
3647 if(result)
3648 return result;
3649
3650 /* run the state-machine */
3651 result = ftp_multi_statemach(conn, dophase_done);
3652
3653 *connected = conn->bits.tcpconnect[SECONDARYSOCKET];
3654
3655 infof(conn->data, "ftp_perform ends with SECONDARY: %d\n", *connected);
3656
3657 if(*dophase_done)
3658 DEBUGF(infof(conn->data, "DO phase is complete1\n"));
3659
3660 return result;
3661 }
3662
3663 static void wc_data_dtor(void *ptr)
3664 {
3665 struct ftp_wc *ftpwc = ptr;
3666 if(ftpwc && ftpwc->parser)
3667 Curl_ftp_parselist_data_free(&ftpwc->parser);
3668 free(ftpwc);
3669 }
3670
3671 static CURLcode init_wc_data(struct connectdata *conn)
3672 {
3673 char *last_slash;
3674 struct FTP *ftp = conn->data->req.protop;
3675 char *path = ftp->path;
3676 struct WildcardData *wildcard = &(conn->data->wildcard);
3677 CURLcode result = CURLE_OK;
3678 struct ftp_wc *ftpwc = NULL;
3679
3680 last_slash = strrchr(ftp->path, '/');
3681 if(last_slash) {
3682 last_slash++;
3683 if(last_slash[0] == '\0') {
3684 wildcard->state = CURLWC_CLEAN;
3685 result = ftp_parse_url_path(conn);
3686 return result;
3687 }
3688 wildcard->pattern = strdup(last_slash);
3689 if(!wildcard->pattern)
3690 return CURLE_OUT_OF_MEMORY;
3691 last_slash[0] = '\0'; /* cut file from path */
3692 }
3693 else { /* there is only 'wildcard pattern' or nothing */
3694 if(path[0]) {
3695 wildcard->pattern = strdup(path);
3696 if(!wildcard->pattern)
3697 return CURLE_OUT_OF_MEMORY;
3698 path[0] = '\0';
3699 }
3700 else { /* only list */
3701 wildcard->state = CURLWC_CLEAN;
3702 result = ftp_parse_url_path(conn);
3703 return result;
3704 }
3705 }
3706
3707 /* program continues only if URL is not ending with slash, allocate needed
3708 resources for wildcard transfer */
3709
3710 /* allocate ftp protocol specific wildcard data */
3711 ftpwc = calloc(1, sizeof(struct ftp_wc));
3712 if(!ftpwc) {
3713 result = CURLE_OUT_OF_MEMORY;
3714 goto fail;
3715 }
3716
3717 /* INITIALIZE parselist structure */
3718 ftpwc->parser = Curl_ftp_parselist_data_alloc();
3719 if(!ftpwc->parser) {
3720 result = CURLE_OUT_OF_MEMORY;
3721 goto fail;
3722 }
3723
3724 wildcard->protdata = ftpwc; /* put it to the WildcardData tmp pointer */
3725 wildcard->dtor = wc_data_dtor;
3726
3727 /* wildcard does not support NOCWD option (assert it?) */
3728 if(conn->data->set.ftp_filemethod == FTPFILE_NOCWD)
3729 conn->data->set.ftp_filemethod = FTPFILE_MULTICWD;
3730
3731 /* try to parse ftp url */
3732 result = ftp_parse_url_path(conn);
3733 if(result) {
3734 goto fail;
3735 }
3736
3737 wildcard->path = strdup(ftp->path);
3738 if(!wildcard->path) {
3739 result = CURLE_OUT_OF_MEMORY;
3740 goto fail;
3741 }
3742
3743 /* backup old write_function */
3744 ftpwc->backup.write_function = conn->data->set.fwrite_func;
3745 /* parsing write function */
3746 conn->data->set.fwrite_func = Curl_ftp_parselist;
3747 /* backup old file descriptor */
3748 ftpwc->backup.file_descriptor = conn->data->set.out;
3749 /* let the writefunc callback know what curl pointer is working with */
3750 conn->data->set.out = conn;
3751
3752 infof(conn->data, "Wildcard - Parsing started\n");
3753 return CURLE_OK;
3754
3755 fail:
3756 if(ftpwc) {
3757 Curl_ftp_parselist_data_free(&ftpwc->parser);
3758 free(ftpwc);
3759 }
3760 Curl_safefree(wildcard->pattern);
3761 wildcard->dtor = ZERO_NULL;
3762 wildcard->protdata = NULL;
3763 return result;
3764 }
3765
3766 /* This is called recursively */
3767 static CURLcode wc_statemach(struct connectdata *conn)
3768 {
3769 struct WildcardData * const wildcard = &(conn->data->wildcard);
3770 CURLcode result = CURLE_OK;
3771
3772 switch(wildcard->state) {
3773 case CURLWC_INIT:
3774 result = init_wc_data(conn);
3775 if(wildcard->state == CURLWC_CLEAN)
3776 /* only listing! */
3777 break;
3778 wildcard->state = result ? CURLWC_ERROR : CURLWC_MATCHING;
3779 break;
3780
3781 case CURLWC_MATCHING: {
3782 /* In this state is LIST response successfully parsed, so lets restore
3783 previous WRITEFUNCTION callback and WRITEDATA pointer */
3784 struct ftp_wc *ftpwc = wildcard->protdata;
3785 conn->data->set.fwrite_func = ftpwc->backup.write_function;
3786 conn->data->set.out = ftpwc->backup.file_descriptor;
3787 ftpwc->backup.write_function = ZERO_NULL;
3788 ftpwc->backup.file_descriptor = NULL;
3789 wildcard->state = CURLWC_DOWNLOADING;
3790
3791 if(Curl_ftp_parselist_geterror(ftpwc->parser)) {
3792 /* error found in LIST parsing */
3793 wildcard->state = CURLWC_CLEAN;
3794 return wc_statemach(conn);
3795 }
3796 if(wildcard->filelist.size == 0) {
3797 /* no corresponding file */
3798 wildcard->state = CURLWC_CLEAN;
3799 return CURLE_REMOTE_FILE_NOT_FOUND;
3800 }
3801 return wc_statemach(conn);
3802 }
3803
3804 case CURLWC_DOWNLOADING: {
3805 /* filelist has at least one file, lets get first one */
3806 struct ftp_conn *ftpc = &conn->proto.ftpc;
3807 struct curl_fileinfo *finfo = wildcard->filelist.head->ptr;
3808 struct FTP *ftp = conn->data->req.protop;
3809
3810 char *tmp_path = aprintf("%s%s", wildcard->path, finfo->filename);
3811 if(!tmp_path)
3812 return CURLE_OUT_OF_MEMORY;
3813
3814 /* switch default ftp->path and tmp_path */
3815 free(ftp->pathalloc);
3816 ftp->pathalloc = ftp->path = tmp_path;
3817
3818 infof(conn->data, "Wildcard - START of \"%s\"\n", finfo->filename);
3819 if(conn->data->set.chunk_bgn) {
3820 long userresponse;
3821 Curl_set_in_callback(conn->data, true);
3822 userresponse = conn->data->set.chunk_bgn(
3823 finfo, wildcard->customptr, (int)wildcard->filelist.size);
3824 Curl_set_in_callback(conn->data, false);
3825 switch(userresponse) {
3826 case CURL_CHUNK_BGN_FUNC_SKIP:
3827 infof(conn->data, "Wildcard - \"%s\" skipped by user\n",
3828 finfo->filename);
3829 wildcard->state = CURLWC_SKIP;
3830 return wc_statemach(conn);
3831 case CURL_CHUNK_BGN_FUNC_FAIL:
3832 return CURLE_CHUNK_FAILED;
3833 }
3834 }
3835
3836 if(finfo->filetype != CURLFILETYPE_FILE) {
3837 wildcard->state = CURLWC_SKIP;
3838 return wc_statemach(conn);
3839 }
3840
3841 if(finfo->flags & CURLFINFOFLAG_KNOWN_SIZE)
3842 ftpc->known_filesize = finfo->size;
3843
3844 result = ftp_parse_url_path(conn);
3845 if(result)
3846 return result;
3847
3848 /* we don't need the Curl_fileinfo of first file anymore */
3849 Curl_llist_remove(&wildcard->filelist, wildcard->filelist.head, NULL);
3850
3851 if(wildcard->filelist.size == 0) { /* remains only one file to down. */
3852 wildcard->state = CURLWC_CLEAN;
3853 /* after that will be ftp_do called once again and no transfer
3854 will be done because of CURLWC_CLEAN state */
3855 return CURLE_OK;
3856 }
3857 } break;
3858
3859 case CURLWC_SKIP: {
3860 if(conn->data->set.chunk_end) {
3861 Curl_set_in_callback(conn->data, true);
3862 conn->data->set.chunk_end(conn->data->wildcard.customptr);
3863 Curl_set_in_callback(conn->data, false);
3864 }
3865 Curl_llist_remove(&wildcard->filelist, wildcard->filelist.head, NULL);
3866 wildcard->state = (wildcard->filelist.size == 0) ?
3867 CURLWC_CLEAN : CURLWC_DOWNLOADING;
3868 return wc_statemach(conn);
3869 }
3870
3871 case CURLWC_CLEAN: {
3872 struct ftp_wc *ftpwc = wildcard->protdata;
3873 result = CURLE_OK;
3874 if(ftpwc)
3875 result = Curl_ftp_parselist_geterror(ftpwc->parser);
3876
3877 wildcard->state = result ? CURLWC_ERROR : CURLWC_DONE;
3878 } break;
3879
3880 case CURLWC_DONE:
3881 case CURLWC_ERROR:
3882 case CURLWC_CLEAR:
3883 if(wildcard->dtor)
3884 wildcard->dtor(wildcard->protdata);
3885 break;
3886 }
3887
3888 return result;
3889 }
3890
3891 /***********************************************************************
3892 *
3893 * ftp_do()
3894 *
3895 * This function is registered as 'curl_do' function. It decodes the path
3896 * parts etc as a wrapper to the actual DO function (ftp_perform).
3897 *
3898 * The input argument is already checked for validity.
3899 */
3900 static CURLcode ftp_do(struct connectdata *conn, bool *done)
3901 {
3902 CURLcode result = CURLE_OK;
3903 struct ftp_conn *ftpc = &conn->proto.ftpc;
3904
3905 *done = FALSE; /* default to false */
3906 ftpc->wait_data_conn = FALSE; /* default to no such wait */
3907
3908 if(conn->data->state.wildcardmatch) {
3909 result = wc_statemach(conn);
3910 if(conn->data->wildcard.state == CURLWC_SKIP ||
3911 conn->data->wildcard.state == CURLWC_DONE) {
3912 /* do not call ftp_regular_transfer */
3913 return CURLE_OK;
3914 }
3915 if(result) /* error, loop or skipping the file */
3916 return result;
3917 }
3918 else { /* no wildcard FSM needed */
3919 result = ftp_parse_url_path(conn);
3920 if(result)
3921 return result;
3922 }
3923
3924 result = ftp_regular_transfer(conn, done);
3925
3926 return result;
3927 }
3928
3929
3930 CURLcode Curl_ftpsend(struct connectdata *conn, const char *cmd)
3931 {
3932 ssize_t bytes_written;
3933 #define SBUF_SIZE 1024
3934 char s[SBUF_SIZE];
3935 size_t write_len;
3936 char *sptr = s;
3937 CURLcode result = CURLE_OK;
3938 #ifdef HAVE_GSSAPI
3939 enum protection_level data_sec = conn->data_prot;
3940 #endif
3941
3942 if(!cmd)
3943 return CURLE_BAD_FUNCTION_ARGUMENT;
3944
3945 write_len = strlen(cmd);
3946 if(!write_len || write_len > (sizeof(s) -3))
3947 return CURLE_BAD_FUNCTION_ARGUMENT;
3948
3949 memcpy(&s, cmd, write_len);
3950 strcpy(&s[write_len], "\r\n"); /* append a trailing CRLF */
3951 write_len += 2;
3952 bytes_written = 0;
3953
3954 result = Curl_convert_to_network(conn->data, s, write_len);
3955 /* Curl_convert_to_network calls failf if unsuccessful */
3956 if(result)
3957 return result;
3958
3959 for(;;) {
3960 #ifdef HAVE_GSSAPI
3961 conn->data_prot = PROT_CMD;
3962 #endif
3963 result = Curl_write(conn, conn->sock[FIRSTSOCKET], sptr, write_len,
3964 &bytes_written);
3965 #ifdef HAVE_GSSAPI
3966 DEBUGASSERT(data_sec > PROT_NONE && data_sec < PROT_LAST);
3967 conn->data_prot = data_sec;
3968 #endif
3969
3970 if(result)
3971 break;
3972
3973 if(conn->data->set.verbose)
3974 Curl_debug(conn->data, CURLINFO_HEADER_OUT, sptr, (size_t)bytes_written);
3975
3976 if(bytes_written != (ssize_t)write_len) {
3977 write_len -= bytes_written;
3978 sptr += bytes_written;
3979 }
3980 else
3981 break;
3982 }
3983
3984 return result;
3985 }
3986
3987 /***********************************************************************
3988 *
3989 * ftp_quit()
3990 *
3991 * This should be called before calling sclose() on an ftp control connection
3992 * (not data connections). We should then wait for the response from the
3993 * server before returning. The calling code should then try to close the
3994 * connection.
3995 *
3996 */
3997 static CURLcode ftp_quit(struct connectdata *conn)
3998 {
3999 CURLcode result = CURLE_OK;
4000
4001 if(conn->proto.ftpc.ctl_valid) {
4002 result = Curl_pp_sendf(&conn->proto.ftpc.pp, "%s", "QUIT");
4003 if(result) {
4004 failf(conn->data, "Failure sending QUIT command: %s",
4005 curl_easy_strerror(result));
4006 conn->proto.ftpc.ctl_valid = FALSE; /* mark control connection as bad */
4007 connclose(conn, "QUIT command failed"); /* mark for connection closure */
4008 state(conn, FTP_STOP);
4009 return result;
4010 }
4011
4012 state(conn, FTP_QUIT);
4013
4014 result = ftp_block_statemach(conn);
4015 }
4016
4017 return result;
4018 }
4019
4020 /***********************************************************************
4021 *
4022 * ftp_disconnect()
4023 *
4024 * Disconnect from an FTP server. Cleanup protocol-specific per-connection
4025 * resources. BLOCKING.
4026 */
4027 static CURLcode ftp_disconnect(struct connectdata *conn, bool dead_connection)
4028 {
4029 struct ftp_conn *ftpc = &conn->proto.ftpc;
4030 struct pingpong *pp = &ftpc->pp;
4031
4032 /* We cannot send quit unconditionally. If this connection is stale or
4033 bad in any way, sending quit and waiting around here will make the
4034 disconnect wait in vain and cause more problems than we need to.
4035
4036 ftp_quit() will check the state of ftp->ctl_valid. If it's ok it
4037 will try to send the QUIT command, otherwise it will just return.
4038 */
4039 if(dead_connection)
4040 ftpc->ctl_valid = FALSE;
4041
4042 /* The FTP session may or may not have been allocated/setup at this point! */
4043 (void)ftp_quit(conn); /* ignore errors on the QUIT */
4044
4045 if(ftpc->entrypath) {
4046 struct Curl_easy *data = conn->data;
4047 if(data->state.most_recent_ftp_entrypath == ftpc->entrypath) {
4048 data->state.most_recent_ftp_entrypath = NULL;
4049 }
4050 free(ftpc->entrypath);
4051 ftpc->entrypath = NULL;
4052 }
4053
4054 freedirs(ftpc);
4055 free(ftpc->prevpath);
4056 ftpc->prevpath = NULL;
4057 free(ftpc->server_os);
4058 ftpc->server_os = NULL;
4059
4060 Curl_pp_disconnect(pp);
4061
4062 #ifdef HAVE_GSSAPI
4063 Curl_sec_end(conn);
4064 #endif
4065
4066 return CURLE_OK;
4067 }
4068
4069 /***********************************************************************
4070 *
4071 * ftp_parse_url_path()
4072 *
4073 * Parse the URL path into separate path components.
4074 *
4075 */
4076 static
4077 CURLcode ftp_parse_url_path(struct connectdata *conn)
4078 {
4079 struct Curl_easy *data = conn->data;
4080 /* the ftp struct is already inited in ftp_connect() */
4081 struct FTP *ftp = data->req.protop;
4082 struct ftp_conn *ftpc = &conn->proto.ftpc;
4083 const char *slashPos = NULL;
4084 const char *fileName = NULL;
4085 CURLcode result = CURLE_OK;
4086 char *rawPath = NULL; /* url-decoded "raw" path */
4087 size_t pathLen = 0;
4088
4089 ftpc->ctl_valid = FALSE;
4090 ftpc->cwdfail = FALSE;
4091
4092 /* url-decode ftp path before further evaluation */
4093 result = Curl_urldecode(data, ftp->path, 0, &rawPath, &pathLen, TRUE);
4094 if(result)
4095 return result;
4096
4097 switch(data->set.ftp_filemethod) {
4098 case FTPFILE_NOCWD: /* fastest, but less standard-compliant */
4099
4100 if((pathLen > 0) && (rawPath[pathLen - 1] != '/'))
4101 fileName = rawPath; /* this is a full file path */
4102 /*
4103 else: ftpc->file is not used anywhere other than for operations on
4104 a file. In other words, never for directory operations.
4105 So we can safely leave filename as NULL here and use it as a
4106 argument in dir/file decisions.
4107 */
4108 break;
4109
4110 case FTPFILE_SINGLECWD:
4111 slashPos = strrchr(rawPath, '/');
4112 if(slashPos) {
4113 /* get path before last slash, except for / */
4114 size_t dirlen = slashPos - rawPath;
4115 if(dirlen == 0)
4116 dirlen++;
4117
4118 ftpc->dirs = calloc(1, sizeof(ftpc->dirs[0]));
4119 if(!ftpc->dirs) {
4120 free(rawPath);
4121 return CURLE_OUT_OF_MEMORY;
4122 }
4123
4124 ftpc->dirs[0] = calloc(1, dirlen + 1);
4125 if(!ftpc->dirs[0]) {
4126 free(rawPath);
4127 return CURLE_OUT_OF_MEMORY;
4128 }
4129
4130 strncpy(ftpc->dirs[0], rawPath, dirlen);
4131 ftpc->dirdepth = 1; /* we consider it to be a single dir */
4132 fileName = slashPos + 1; /* rest is file name */
4133 }
4134 else
4135 fileName = rawPath; /* file name only (or empty) */
4136 break;
4137
4138 default: /* allow pretty much anything */
4139 case FTPFILE_MULTICWD: {
4140 /* current position: begin of next path component */
4141 const char *curPos = rawPath;
4142
4143 int dirAlloc = 0; /* number of entries allocated for the 'dirs' array */
4144 const char *str = rawPath;
4145 for(; *str != 0; ++str)
4146 if (*str == '/')
4147 ++dirAlloc;
4148
4149 if(dirAlloc > 0) {
4150 ftpc->dirs = calloc(dirAlloc, sizeof(ftpc->dirs[0]));
4151 if(!ftpc->dirs) {
4152 free(rawPath);
4153 return CURLE_OUT_OF_MEMORY;
4154 }
4155
4156 /* parse the URL path into separate path components */
4157 while((slashPos = strchr(curPos, '/')) != NULL) {
4158 size_t compLen = slashPos - curPos;
4159
4160 /* path starts with a slash: add that as a directory */
4161 if((compLen == 0) && (ftpc->dirdepth == 0))
4162 ++compLen;
4163
4164 /* we skip empty path components, like "x//y" since the FTP command
4165 CWD requires a parameter and a non-existent parameter a) doesn't
4166 work on many servers and b) has no effect on the others. */
4167 if(compLen > 0) {
4168 char *comp = calloc(1, compLen + 1);
4169 if(!comp) {
4170 free(rawPath);
4171 return CURLE_OUT_OF_MEMORY;
4172 }
4173 strncpy(comp, curPos, compLen);
4174 ftpc->dirs[ftpc->dirdepth++] = comp;
4175 }
4176 curPos = slashPos + 1;
4177 }
4178 }
4179 DEBUGASSERT(ftpc->dirdepth <= dirAlloc);
4180 fileName = curPos; /* the rest is the file name (or empty) */
4181 }
4182 break;
4183 } /* switch */
4184
4185 if(fileName && *fileName)
4186 ftpc->file = strdup(fileName);
4187 else
4188 ftpc->file = NULL; /* instead of point to a zero byte,
4189 we make it a NULL pointer */
4190
4191 if(data->set.upload && !ftpc->file && (ftp->transfer == FTPTRANSFER_BODY)) {
4192 /* We need a file name when uploading. Return error! */
4193 failf(data, "Uploading to a URL without a file name!");
4194 free(rawPath);
4195 return CURLE_URL_MALFORMAT;
4196 }
4197
4198 ftpc->cwddone = FALSE; /* default to not done */
4199
4200 if((data->set.ftp_filemethod == FTPFILE_NOCWD) && (rawPath[0] == '/'))
4201 ftpc->cwddone = TRUE; /* skip CWD for absolute paths */
4202 else { /* newly created FTP connections are already in entry path */
4203 const char *oldPath = conn->bits.reuse ? ftpc->prevpath : "";
4204 if(oldPath) {
4205 size_t n = pathLen;
4206 if(data->set.ftp_filemethod == FTPFILE_NOCWD)
4207 n = 0; /* CWD to entry for relative paths */
4208 else
4209 n -= ftpc->file?strlen(ftpc->file):0;
4210
4211 if((strlen(oldPath) == n) && !strncmp(rawPath, oldPath, n)) {
4212 infof(data, "Request has same path as previous transfer\n");
4213 ftpc->cwddone = TRUE;
4214 }
4215 }
4216 }
4217
4218 free(rawPath);
4219 return CURLE_OK;
4220 }
4221
4222 /* call this when the DO phase has completed */
4223 static CURLcode ftp_dophase_done(struct connectdata *conn,
4224 bool connected)
4225 {
4226 struct FTP *ftp = conn->data->req.protop;
4227 struct ftp_conn *ftpc = &conn->proto.ftpc;
4228
4229 if(connected) {
4230 int completed;
4231 CURLcode result = ftp_do_more(conn, &completed);
4232
4233 if(result) {
4234 close_secondarysocket(conn);
4235 return result;
4236 }
4237 }
4238
4239 if(ftp->transfer != FTPTRANSFER_BODY)
4240 /* no data to transfer */
4241 Curl_setup_transfer(conn->data, -1, -1, FALSE, -1);
4242 else if(!connected)
4243 /* since we didn't connect now, we want do_more to get called */
4244 conn->bits.do_more = TRUE;
4245
4246 ftpc->ctl_valid = TRUE; /* seems good */
4247
4248 return CURLE_OK;
4249 }
4250
4251 /* called from multi.c while DOing */
4252 static CURLcode ftp_doing(struct connectdata *conn,
4253 bool *dophase_done)
4254 {
4255 CURLcode result = ftp_multi_statemach(conn, dophase_done);
4256
4257 if(result)
4258 DEBUGF(infof(conn->data, "DO phase failed\n"));
4259 else if(*dophase_done) {
4260 result = ftp_dophase_done(conn, FALSE /* not connected */);
4261
4262 DEBUGF(infof(conn->data, "DO phase is complete2\n"));
4263 }
4264 return result;
4265 }
4266
4267 /***********************************************************************
4268 *
4269 * ftp_regular_transfer()
4270 *
4271 * The input argument is already checked for validity.
4272 *
4273 * Performs all commands done before a regular transfer between a local and a
4274 * remote host.
4275 *
4276 * ftp->ctl_valid starts out as FALSE, and gets set to TRUE if we reach the
4277 * ftp_done() function without finding any major problem.
4278 */
4279 static
4280 CURLcode ftp_regular_transfer(struct connectdata *conn,
4281 bool *dophase_done)
4282 {
4283 CURLcode result = CURLE_OK;
4284 bool connected = FALSE;
4285 struct Curl_easy *data = conn->data;
4286 struct ftp_conn *ftpc = &conn->proto.ftpc;
4287 data->req.size = -1; /* make sure this is unknown at this point */
4288
4289 Curl_pgrsSetUploadCounter(data, 0);
4290 Curl_pgrsSetDownloadCounter(data, 0);
4291 Curl_pgrsSetUploadSize(data, -1);
4292 Curl_pgrsSetDownloadSize(data, -1);
4293
4294 ftpc->ctl_valid = TRUE; /* starts good */
4295
4296 result = ftp_perform(conn,
4297 &connected, /* have we connected after PASV/PORT */
4298 dophase_done); /* all commands in the DO-phase done? */
4299
4300 if(!result) {
4301
4302 if(!*dophase_done)
4303 /* the DO phase has not completed yet */
4304 return CURLE_OK;
4305
4306 result = ftp_dophase_done(conn, connected);
4307
4308 if(result)
4309 return result;
4310 }
4311 else
4312 freedirs(ftpc);
4313
4314 return result;
4315 }
4316
4317 static CURLcode ftp_setup_connection(struct connectdata *conn)
4318 {
4319 struct Curl_easy *data = conn->data;
4320 char *type;
4321 struct FTP *ftp;
4322
4323 conn->data->req.protop = ftp = calloc(sizeof(struct FTP), 1);
4324 if(NULL == ftp)
4325 return CURLE_OUT_OF_MEMORY;
4326
4327 ftp->path = &data->state.up.path[1]; /* don't include the initial slash */
4328
4329 /* FTP URLs support an extension like ";type=<typecode>" that
4330 * we'll try to get now! */
4331 type = strstr(ftp->path, ";type=");
4332
4333 if(!type)
4334 type = strstr(conn->host.rawalloc, ";type=");
4335
4336 if(type) {
4337 char command;
4338 *type = 0; /* it was in the middle of the hostname */
4339 command = Curl_raw_toupper(type[6]);
4340 conn->bits.type_set = TRUE;
4341
4342 switch(command) {
4343 case 'A': /* ASCII mode */
4344 data->set.prefer_ascii = TRUE;
4345 break;
4346
4347 case 'D': /* directory mode */
4348 data->set.ftp_list_only = TRUE;
4349 break;
4350
4351 case 'I': /* binary mode */
4352 default:
4353 /* switch off ASCII */
4354 data->set.prefer_ascii = FALSE;
4355 break;
4356 }
4357 }
4358
4359 /* get some initial data into the ftp struct */
4360 ftp->transfer = FTPTRANSFER_BODY;
4361 ftp->downloadsize = 0;
4362 conn->proto.ftpc.known_filesize = -1; /* unknown size for now */
4363
4364 return CURLE_OK;
4365 }
4366
4367 #endif /* CURL_DISABLE_FTP */