1 /***************************************************************************
3 * Project ___| | | | _ \| |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
8 * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at http://curl.haxx.se/docs/copyright.html.
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 ***************************************************************************/
25 #ifndef CURL_DISABLE_FTP
31 #ifdef HAVE_SYS_SOCKET_H
32 #include <sys/socket.h>
34 #ifdef HAVE_NETINET_IN_H
35 #include <netinet/in.h>
37 #ifdef HAVE_ARPA_INET_H
38 #include <arpa/inet.h>
41 #include <sys/utsname.h>
51 #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
53 #define in_addr_t unsigned long
56 #include <curl/curl.h>
64 #include "http.h" /* for HTTP proxy tunnel stuff */
68 #include "ftplistparser.h"
70 #if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)
74 #include "strtoofft.h"
79 #include "inet_ntop.h"
80 #include "inet_pton.h"
82 #include "parsedate.h" /* for the week day and month names */
83 #include "sockaddr.h" /* required for Curl_sockaddr_storage */
87 #include "speedcheck.h"
89 #include "http_proxy.h"
90 #include "non-ascii.h"
92 #define _MPRINTF_REPLACE /* use our functions only */
93 #include <curl/mprintf.h>
95 #include "curl_memory.h"
96 /* The last #include file should be: */
100 #define NI_MAXHOST 1025
102 #ifndef INET_ADDRSTRLEN
103 #define INET_ADDRSTRLEN 16
106 #ifdef CURL_DISABLE_VERBOSE_STRINGS
107 #define ftp_pasv_verbose(a,b,c,d) do { } while(0)
110 /* Local API functions */
111 static CURLcode ftp_sendquote(struct connectdata *conn,
112 struct curl_slist *quote);
113 static CURLcode ftp_quit(struct connectdata *conn);
114 static CURLcode ftp_parse_url_path(struct connectdata *conn);
115 static CURLcode ftp_regular_transfer(struct connectdata *conn, bool *done);
116 #ifndef CURL_DISABLE_VERBOSE_STRINGS
117 static void ftp_pasv_verbose(struct connectdata *conn,
119 char *newhost, /* ascii version */
122 static CURLcode ftp_state_post_rest(struct connectdata *conn);
123 static CURLcode ftp_state_post_cwd(struct connectdata *conn);
124 static CURLcode ftp_state_quote(struct connectdata *conn,
125 bool init, ftpstate instate);
126 static CURLcode ftp_nb_type(struct connectdata *conn,
127 bool ascii, ftpstate newstate);
128 static int ftp_need_type(struct connectdata *conn,
130 static CURLcode ftp_do(struct connectdata *conn, bool *done);
131 static CURLcode ftp_done(struct connectdata *conn,
132 CURLcode, bool premature);
133 static CURLcode ftp_connect(struct connectdata *conn, bool *done);
134 static CURLcode ftp_disconnect(struct connectdata *conn, bool dead_connection);
135 static CURLcode ftp_nextconnect(struct connectdata *conn);
136 static CURLcode ftp_multi_statemach(struct connectdata *conn, bool *done);
137 static int ftp_getsock(struct connectdata *conn,
138 curl_socket_t *socks,
140 static CURLcode ftp_doing(struct connectdata *conn,
142 static CURLcode ftp_setup_connection(struct connectdata * conn);
144 static CURLcode init_wc_data(struct connectdata *conn);
145 static CURLcode wc_statemach(struct connectdata *conn);
147 static void wc_data_dtor(void *ptr);
149 static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
150 curl_off_t filesize);
152 /* easy-to-use macro: */
153 #define FTPSENDF(x,y,z) if((result = Curl_ftpsendf(x,y,z)) != CURLE_OK) \
155 #define PPSENDF(x,y,z) if((result = Curl_pp_sendf(x,y,z)) != CURLE_OK) \
160 * FTP protocol handler.
163 const struct Curl_handler Curl_handler_ftp = {
165 ftp_setup_connection, /* setup_connection */
168 ftp_nextconnect, /* do_more */
169 ftp_connect, /* connect_it */
170 ftp_multi_statemach, /* connecting */
171 ftp_doing, /* doing */
172 ftp_getsock, /* proto_getsock */
173 ftp_getsock, /* doing_getsock */
174 ZERO_NULL, /* perform_getsock */
175 ftp_disconnect, /* disconnect */
176 ZERO_NULL, /* readwrite */
177 PORT_FTP, /* defport */
178 CURLPROTO_FTP, /* protocol */
179 PROTOPT_DUAL | PROTOPT_CLOSEACTION | PROTOPT_NEEDSPWD /* flags */
185 * FTPS protocol handler.
188 const struct Curl_handler Curl_handler_ftps = {
190 ftp_setup_connection, /* setup_connection */
193 ftp_nextconnect, /* do_more */
194 ftp_connect, /* connect_it */
195 ftp_multi_statemach, /* connecting */
196 ftp_doing, /* doing */
197 ftp_getsock, /* proto_getsock */
198 ftp_getsock, /* doing_getsock */
199 ZERO_NULL, /* perform_getsock */
200 ftp_disconnect, /* disconnect */
201 ZERO_NULL, /* readwrite */
202 PORT_FTPS, /* defport */
203 CURLPROTO_FTP | CURLPROTO_FTPS, /* protocol */
204 PROTOPT_SSL | PROTOPT_DUAL | PROTOPT_CLOSEACTION |
205 PROTOPT_NEEDSPWD /* flags */
209 #ifndef CURL_DISABLE_HTTP
211 * HTTP-proxyed FTP protocol handler.
214 static const struct Curl_handler Curl_handler_ftp_proxy = {
216 ZERO_NULL, /* setup_connection */
217 Curl_http, /* do_it */
218 Curl_http_done, /* done */
219 ZERO_NULL, /* do_more */
220 ZERO_NULL, /* connect_it */
221 ZERO_NULL, /* connecting */
222 ZERO_NULL, /* doing */
223 ZERO_NULL, /* proto_getsock */
224 ZERO_NULL, /* doing_getsock */
225 ZERO_NULL, /* perform_getsock */
226 ZERO_NULL, /* disconnect */
227 ZERO_NULL, /* readwrite */
228 PORT_FTP, /* defport */
229 CURLPROTO_HTTP, /* protocol */
230 PROTOPT_NONE /* flags */
236 * HTTP-proxyed FTPS protocol handler.
239 static const struct Curl_handler Curl_handler_ftps_proxy = {
241 ZERO_NULL, /* setup_connection */
242 Curl_http, /* do_it */
243 Curl_http_done, /* done */
244 ZERO_NULL, /* do_more */
245 ZERO_NULL, /* connect_it */
246 ZERO_NULL, /* connecting */
247 ZERO_NULL, /* doing */
248 ZERO_NULL, /* proto_getsock */
249 ZERO_NULL, /* doing_getsock */
250 ZERO_NULL, /* perform_getsock */
251 ZERO_NULL, /* disconnect */
252 ZERO_NULL, /* readwrite */
253 PORT_FTPS, /* defport */
254 CURLPROTO_HTTP, /* protocol */
255 PROTOPT_NONE /* flags */
262 * NOTE: back in the old days, we added code in the FTP code that made NOBODY
263 * requests on files respond with headers passed to the client/stdout that
264 * looked like HTTP ones.
266 * This approach is not very elegant, it causes confusion and is error-prone.
267 * It is subject for removal at the next (or at least a future) soname bump.
268 * Until then you can test the effects of the removal by undefining the
269 * following define named CURL_FTP_HTTPSTYLE_HEAD.
271 #define CURL_FTP_HTTPSTYLE_HEAD 1
273 static void freedirs(struct ftp_conn *ftpc)
277 for(i=0; i < ftpc->dirdepth; i++) {
293 /* Returns non-zero if the given string contains CR (\r) or LF (\n),
294 which are not allowed within RFC 959 <string>.
295 Note: The input string is in the client's encoding which might
296 not be ASCII, so escape sequences \r & \n must be used instead
297 of hex values 0x0d & 0x0a.
299 static bool isBadFtpString(const char *string)
301 return (bool)((NULL != strchr(string, '\r')) ||
302 (NULL != strchr(string, '\n')));
305 /***********************************************************************
307 * AllowServerConnect()
309 * When we've issue the PORT command, we have told the server to connect
310 * to us. This function will sit and wait here until the server has
314 static CURLcode AllowServerConnect(struct connectdata *conn)
316 struct SessionHandle *data = conn->data;
317 curl_socket_t sock = conn->sock[SECONDARYSOCKET];
320 curl_socket_t s = CURL_SOCKET_BAD;
322 struct Curl_sockaddr_storage add;
324 struct sockaddr_in add;
326 curl_socklen_t size = (curl_socklen_t) sizeof(add);
329 timeout_ms = Curl_timeleft(data, NULL, TRUE);
332 /* if a timeout was already reached, bail out */
333 failf(data, "Timeout while waiting for server connect");
334 return CURLE_OPERATION_TIMEDOUT;
337 interval_ms = 1000; /* use 1 second timeout intervals */
338 if(timeout_ms < interval_ms)
339 interval_ms = timeout_ms;
341 switch (Curl_socket_ready(sock, CURL_SOCKET_BAD, interval_ms)) {
344 failf(data, "Error while waiting for server connect");
345 return CURLE_FTP_PORT_FAILED;
346 case 0: /* timeout */
349 /* we have received data here */
350 if(0 == getsockname(sock, (struct sockaddr *) &add, &size)) {
353 s=accept(sock, (struct sockaddr *) &add, &size);
355 Curl_closesocket(conn, sock); /* close the first socket */
357 if(CURL_SOCKET_BAD == s) {
358 failf(data, "Error accept()ing server connect");
359 return CURLE_FTP_PORT_FAILED;
361 infof(data, "Connection accepted from server\n");
363 conn->sock[SECONDARYSOCKET] = s;
364 curlx_nonblock(s, TRUE); /* enable non-blocking */
368 /* never reaches this point */
371 /* macro to check for a three-digit ftp status code at the start of the
373 #define STATUSCODE(line) (ISDIGIT(line[0]) && ISDIGIT(line[1]) && \
376 /* macro to check for the last line in an FTP server response */
377 #define LASTLINE(line) (STATUSCODE(line) && (' ' == line[3]))
379 static int ftp_endofresp(struct pingpong *pp,
382 char *line = pp->linestart_resp;
383 size_t len = pp->nread_resp;
385 if((len > 3) && LASTLINE(line)) {
386 *code = curlx_sltosi(strtol(line, NULL, 10));
392 static CURLcode ftp_readresp(curl_socket_t sockfd,
394 int *ftpcode, /* return the ftp-code if done */
395 size_t *size) /* size of the response */
397 struct connectdata *conn = pp->conn;
398 #if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)
399 struct SessionHandle *data = conn->data;
400 char * const buf = data->state.buffer;
402 CURLcode result = CURLE_OK;
405 result = Curl_pp_readresp(sockfd, pp, &code, size);
407 #if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)
408 /* handle the security-oriented responses 6xx ***/
409 /* FIXME: some errorchecking perhaps... ***/
412 code = Curl_sec_read_msg(conn, buf, PROT_SAFE);
415 code = Curl_sec_read_msg(conn, buf, PROT_PRIVATE);
418 code = Curl_sec_read_msg(conn, buf, PROT_CONFIDENTIAL);
421 /* normal ftp stuff we pass through! */
426 /* store the latest code for later retrieval */
427 conn->data->info.httpcode=code;
433 /* 421 means "Service not available, closing control connection." and FTP
434 * servers use it to signal that idle session timeout has been exceeded.
435 * If we ignored the response, it could end up hanging in some cases. */
436 return CURLE_OPERATION_TIMEDOUT;
441 /* --- parse FTP server responses --- */
444 * Curl_GetFTPResponse() is a BLOCKING function to read the full response
445 * from a server after a command.
449 CURLcode Curl_GetFTPResponse(ssize_t *nreadp, /* return number of bytes read */
450 struct connectdata *conn,
451 int *ftpcode) /* return the ftp-code */
454 * We cannot read just one byte per read() and then go back to select() as
455 * the OpenSSL read() doesn't grok that properly.
457 * Alas, read as much as possible, split up into lines, use the ending
458 * line in a response or continue reading. */
460 curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
461 long timeout; /* timeout in milliseconds */
463 struct SessionHandle *data = conn->data;
464 CURLcode result = CURLE_OK;
465 struct ftp_conn *ftpc = &conn->proto.ftpc;
466 struct pingpong *pp = &ftpc->pp;
469 int value_to_be_ignored=0;
472 *ftpcode = 0; /* 0 for errors */
474 /* make the pointer point to something for the rest of this function */
475 ftpcode = &value_to_be_ignored;
479 while(!*ftpcode && !result) {
480 /* check and reset timeout value every lap */
481 timeout = Curl_pp_state_timeout(pp);
484 failf(data, "FTP response timeout");
485 return CURLE_OPERATION_TIMEDOUT; /* already too little time */
488 interval_ms = 1000; /* use 1 second timeout intervals */
489 if(timeout < interval_ms)
490 interval_ms = timeout;
493 * Since this function is blocking, we need to wait here for input on the
494 * connection and only then we call the response reading function. We do
495 * timeout at least every second to make the timeout check run.
497 * A caution here is that the ftp_readresp() function has a cache that may
498 * contain pieces of a response from the previous invoke and we need to
499 * make sure we don't just wait for input while there is unhandled data in
500 * that cache. But also, if the cache is there, we call ftp_readresp() and
501 * the cache wasn't good enough to continue we must not just busy-loop
502 * around this function.
506 if(pp->cache && (cache_skip < 2)) {
508 * There's a cache left since before. We then skipping the wait for
509 * socket action, unless this is the same cache like the previous round
510 * as then the cache was deemed not enough to act on and we then need to
511 * wait for more data anyway.
515 switch (Curl_socket_ready(sockfd, CURL_SOCKET_BAD, interval_ms)) {
516 case -1: /* select() error, stop reading */
517 failf(data, "FTP response aborted due to select/poll error: %d",
519 return CURLE_RECV_ERROR;
521 case 0: /* timeout */
522 if(Curl_pgrsUpdate(conn))
523 return CURLE_ABORTED_BY_CALLBACK;
524 continue; /* just continue in our loop for the timeout duration */
526 default: /* for clarity */
530 result = ftp_readresp(sockfd, pp, ftpcode, &nread);
534 if(!nread && pp->cache)
535 /* bump cache skip counter as on repeated skips we must wait for more
539 /* when we got data or there is no cache left, we reset the cache skip
545 } /* while there's buffer left and loop is requested */
547 pp->pending_resp = FALSE;
552 /* This is the ONLY way to change FTP state! */
553 static void state(struct connectdata *conn,
556 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
557 /* for debug purposes */
558 static const char * const names[]={
596 struct ftp_conn *ftpc = &conn->proto.ftpc;
597 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
598 if(ftpc->state != newstate)
599 infof(conn->data, "FTP %p state change from %s to %s\n",
600 ftpc, names[ftpc->state], names[newstate]);
602 ftpc->state = newstate;
605 static CURLcode ftp_state_user(struct connectdata *conn)
608 struct FTP *ftp = conn->data->state.proto.ftp;
610 PPSENDF(&conn->proto.ftpc.pp, "USER %s", ftp->user?ftp->user:"");
612 state(conn, FTP_USER);
613 conn->data->state.ftp_trying_alternative = FALSE;
618 static CURLcode ftp_state_pwd(struct connectdata *conn)
622 /* send PWD to discover our entry point */
623 PPSENDF(&conn->proto.ftpc.pp, "PWD", NULL);
624 state(conn, FTP_PWD);
629 /* For the FTP "protocol connect" and "doing" phases only */
630 static int ftp_getsock(struct connectdata *conn,
631 curl_socket_t *socks,
634 return Curl_pp_getsock(&conn->proto.ftpc.pp, socks, numsocks);
637 /* This is called after the FTP_QUOTE state is passed.
639 ftp_state_cwd() sends the range of CWD commands to the server to change to
640 the correct directory. It may also need to send MKD commands to create
641 missing ones, if that option is enabled.
643 static CURLcode ftp_state_cwd(struct connectdata *conn)
645 CURLcode result = CURLE_OK;
646 struct ftp_conn *ftpc = &conn->proto.ftpc;
649 /* already done and fine */
650 result = ftp_state_post_cwd(conn);
652 ftpc->count2 = 0; /* count2 counts failed CWDs */
654 /* count3 is set to allow a MKD to fail once. In the case when first CWD
655 fails and then MKD fails (due to another session raced it to create the
656 dir) this then allows for a second try to CWD to it */
657 ftpc->count3 = (conn->data->set.ftp_create_missing_dirs==2)?1:0;
659 if(conn->bits.reuse && ftpc->entrypath) {
660 /* This is a re-used connection. Since we change directory to where the
661 transfer is taking place, we must first get back to the original dir
662 where we ended up after login: */
663 ftpc->count1 = 0; /* we count this as the first path, then we add one
664 for all upcoming ones in the ftp->dirs[] array */
665 PPSENDF(&conn->proto.ftpc.pp, "CWD %s", ftpc->entrypath);
666 state(conn, FTP_CWD);
671 /* issue the first CWD, the rest is sent when the CWD responses are
673 PPSENDF(&conn->proto.ftpc.pp, "CWD %s", ftpc->dirs[ftpc->count1 -1]);
674 state(conn, FTP_CWD);
677 /* No CWD necessary */
678 result = ftp_state_post_cwd(conn);
691 static CURLcode ftp_state_use_port(struct connectdata *conn,
692 ftpport fcmd) /* start with this */
695 CURLcode result = CURLE_OK;
696 struct ftp_conn *ftpc = &conn->proto.ftpc;
697 struct SessionHandle *data=conn->data;
698 curl_socket_t portsock= CURL_SOCKET_BAD;
699 char myhost[256] = "";
701 struct Curl_sockaddr_storage ss;
702 Curl_addrinfo *res, *ai;
703 curl_socklen_t sslen;
704 char hbuf[NI_MAXHOST];
705 struct sockaddr *sa=(struct sockaddr *)&ss;
706 struct sockaddr_in * const sa4 = (void *)sa;
708 struct sockaddr_in6 * const sa6 = (void *)sa;
711 static const char mode[][5] = { "EPRT", "PORT" };
715 char *string_ftpport = data->set.str[STRING_FTPPORT];
716 struct Curl_dns_entry *h=NULL;
717 unsigned short port_min = 0;
718 unsigned short port_max = 0;
723 /* Step 1, figure out what is requested,
725 * (ipv4|ipv6|domain|interface)?(:port(-range)?)?
728 if(data->set.str[STRING_FTPPORT] &&
729 (strlen(data->set.str[STRING_FTPPORT]) > 1)) {
732 size_t addrlen = INET6_ADDRSTRLEN > strlen(string_ftpport) ?
733 INET6_ADDRSTRLEN : strlen(string_ftpport);
735 size_t addrlen = INET_ADDRSTRLEN > strlen(string_ftpport) ?
736 INET_ADDRSTRLEN : strlen(string_ftpport);
738 char *ip_start = string_ftpport;
740 char *port_start = NULL;
741 char *port_sep = NULL;
743 addr = calloc(addrlen+1, 1);
745 return CURLE_OUT_OF_MEMORY;
748 if(*string_ftpport == '[') {
749 /* [ipv6]:port(-range) */
750 ip_start = string_ftpport + 1;
751 if((ip_end = strchr(string_ftpport, ']')) != NULL )
752 strncpy(addr, ip_start, ip_end - ip_start);
756 if(*string_ftpport == ':') {
758 ip_end = string_ftpport;
760 else if((ip_end = strchr(string_ftpport, ':')) != NULL) {
761 /* either ipv6 or (ipv4|domain|interface):port(-range) */
763 if(Curl_inet_pton(AF_INET6, string_ftpport, sa6) == 1) {
765 port_min = port_max = 0;
766 strcpy(addr, string_ftpport);
767 ip_end = NULL; /* this got no port ! */
771 /* (ipv4|domain|interface):port(-range) */
772 strncpy(addr, string_ftpport, ip_end - ip_start );
776 strcpy(addr, string_ftpport);
780 if((port_start = strchr(ip_end, ':')) != NULL) {
781 port_min = curlx_ultous(strtoul(port_start+1, NULL, 10));
782 if((port_sep = strchr(port_start, '-')) != NULL) {
783 port_max = curlx_ultous(strtoul(port_sep + 1, NULL, 10));
790 /* correct errors like:
792 * :-4711 , in this case port_min is (unsigned)-1,
793 * therefore port_min > port_max for all cases
794 * but port_max = (unsigned)-1
796 if(port_min > port_max )
797 port_min = port_max = 0;
801 /* attempt to get the address of the given interface name */
802 if(!Curl_if2ip(conn->ip_addr->ai_family, addr,
804 /* not an interface, use the given string as host name instead */
807 host = hbuf; /* use the hbuf for host name */
809 /* there was only a port(-range) given, default the host */
811 } /* data->set.ftpport */
814 /* not an interface and not a host name, get default by extracting
815 the IP from the control connection */
818 if(getsockname(conn->sock[FIRSTSOCKET], sa, &sslen)) {
819 failf(data, "getsockname() failed: %s",
820 Curl_strerror(conn, SOCKERRNO) );
823 return CURLE_FTP_PORT_FAILED;
825 switch(sa->sa_family) {
828 Curl_inet_ntop(sa->sa_family, &sa6->sin6_addr, hbuf, sizeof(hbuf));
832 Curl_inet_ntop(sa->sa_family, &sa4->sin_addr, hbuf, sizeof(hbuf));
835 host = hbuf; /* use this host name */
838 /* resolv ip/host to ip */
839 rc = Curl_resolv(conn, host, 0, &h);
840 if(rc == CURLRESOLV_PENDING)
841 (void)Curl_resolver_wait_resolv(conn, &h);
844 /* when we return from this function, we can forget about this entry
845 to we can unlock it now already */
846 Curl_resolv_unlock(data, h);
849 res = NULL; /* failure! */
855 failf(data, "Curl_resolv failed, we can not recover!");
856 return CURLE_FTP_PORT_FAILED;
859 /* step 2, create a socket for the requested address */
861 portsock = CURL_SOCKET_BAD;
863 for(ai = res; ai; ai = ai->ai_next) {
865 * Workaround for AIX5 getaddrinfo() problem (it doesn't set ai_socktype):
867 if(ai->ai_socktype == 0)
868 ai->ai_socktype = conn->socktype;
870 portsock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
871 if(portsock == CURL_SOCKET_BAD) {
878 failf(data, "socket failure: %s", Curl_strerror(conn, error));
879 return CURLE_FTP_PORT_FAILED;
882 /* step 3, bind to a suitable local address */
884 memcpy(sa, ai->ai_addr, ai->ai_addrlen);
885 sslen = ai->ai_addrlen;
887 for(port = port_min; port <= port_max;) {
888 if(sa->sa_family == AF_INET)
889 sa4->sin_port = htons(port);
892 sa6->sin6_port = htons(port);
894 /* Try binding the given address. */
895 if(bind(portsock, sa, sslen) ) {
898 if(error == EADDRNOTAVAIL) {
900 /* The requested bind address is not local. Use the address used for
901 * the control connection instead and restart the port loop
903 failf(data, "bind(port=%hu) failed: %s", port,
904 Curl_strerror(conn, error) );
907 if(getsockname(conn->sock[FIRSTSOCKET], sa, &sslen)) {
908 failf(data, "getsockname() failed: %s",
909 Curl_strerror(conn, SOCKERRNO) );
910 Curl_closesocket(conn, portsock);
911 return CURLE_FTP_PORT_FAILED;
916 else if(error != EADDRINUSE && error != EACCES) {
917 failf(data, "bind(port=%hu) failed: %s", port,
918 Curl_strerror(conn, error) );
919 Curl_closesocket(conn, portsock);
920 return CURLE_FTP_PORT_FAILED;
929 /* maybe all ports were in use already*/
930 if(port > port_max) {
931 failf(data, "bind() failed, we ran out of ports!");
932 Curl_closesocket(conn, portsock);
933 return CURLE_FTP_PORT_FAILED;
936 /* get the name again after the bind() so that we can extract the
937 port number it uses now */
939 if(getsockname(portsock, (struct sockaddr *)sa, &sslen)) {
940 failf(data, "getsockname() failed: %s",
941 Curl_strerror(conn, SOCKERRNO) );
942 Curl_closesocket(conn, portsock);
943 return CURLE_FTP_PORT_FAILED;
946 /* step 4, listen on the socket */
948 if(listen(portsock, 1)) {
949 failf(data, "socket failure: %s", Curl_strerror(conn, SOCKERRNO));
950 Curl_closesocket(conn, portsock);
951 return CURLE_FTP_PORT_FAILED;
954 /* step 5, send the proper FTP command */
956 /* get a plain printable version of the numerical address to work with
958 Curl_printable_address(ai, myhost, sizeof(myhost));
961 if(!conn->bits.ftp_use_eprt && conn->bits.ipv6)
962 /* EPRT is disabled but we are connected to a IPv6 host, so we ignore the
963 request and enable EPRT again! */
964 conn->bits.ftp_use_eprt = TRUE;
967 for(; fcmd != DONE; fcmd++) {
969 if(!conn->bits.ftp_use_eprt && (EPRT == fcmd))
970 /* if disabled, goto next */
973 if((PORT == fcmd) && sa->sa_family != AF_INET)
974 /* PORT is ipv4 only */
977 switch (sa->sa_family) {
979 port = ntohs(sa4->sin_port);
983 port = ntohs(sa6->sin6_port);
987 continue; /* might as well skip this */
992 * Two fine examples from RFC2428;
994 * EPRT |1|132.235.1.2|6275|
996 * EPRT |2|1080::8:800:200C:417A|5282|
999 result = Curl_pp_sendf(&ftpc->pp, "%s |%d|%s|%hu|", mode[fcmd],
1000 sa->sa_family == AF_INET?1:2,
1006 else if(PORT == fcmd) {
1007 char *source = myhost;
1010 /* translate x.x.x.x to x,x,x,x */
1011 while(source && *source) {
1020 snprintf(dest, 20, ",%d,%d", (int)(port>>8), (int)(port&0xff));
1022 result = Curl_pp_sendf(&ftpc->pp, "%s %s", mode[fcmd], tmp);
1029 /* store which command was sent */
1030 ftpc->count1 = fcmd;
1032 /* we set the secondary socket variable to this for now, it is only so that
1033 the cleanup function will close it in case we fail before the true
1034 secondary stuff is made */
1035 if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET])
1036 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
1037 conn->sock[SECONDARYSOCKET] = portsock;
1039 /* this tcpconnect assignment below is a hackish work-around to make the
1040 multi interface with active FTP work - as it will not wait for a
1041 (passive) connect in Curl_is_connected().
1043 The *proper* fix is to make sure that the active connection from the
1044 server is done in a non-blocking way. Currently, it is still BLOCKING.
1046 conn->bits.tcpconnect[SECONDARYSOCKET] = TRUE;
1048 state(conn, FTP_PORT);
1052 static CURLcode ftp_state_use_pasv(struct connectdata *conn)
1054 struct ftp_conn *ftpc = &conn->proto.ftpc;
1055 CURLcode result = CURLE_OK;
1057 Here's the excecutive summary on what to do:
1059 PASV is RFC959, expect:
1060 227 Entering Passive Mode (a1,a2,a3,a4,p1,p2)
1062 LPSV is RFC1639, expect:
1063 228 Entering Long Passive Mode (4,4,a1,a2,a3,a4,2,p1,p2)
1065 EPSV is RFC2428, expect:
1066 229 Entering Extended Passive Mode (|||port|)
1070 static const char mode[][5] = { "EPSV", "PASV" };
1074 if(!conn->bits.ftp_use_epsv && conn->bits.ipv6)
1075 /* EPSV is disabled but we are connected to a IPv6 host, so we ignore the
1076 request and enable EPSV again! */
1077 conn->bits.ftp_use_epsv = TRUE;
1080 modeoff = conn->bits.ftp_use_epsv?0:1;
1082 PPSENDF(&ftpc->pp, "%s", mode[modeoff]);
1084 ftpc->count1 = modeoff;
1085 state(conn, FTP_PASV);
1086 infof(conn->data, "Connect data stream passively\n");
1091 /* REST is the last command in the chain of commands when a "head"-like
1092 request is made. Thus, if an actual transfer is to be made this is where
1093 we take off for real. */
1094 static CURLcode ftp_state_post_rest(struct connectdata *conn)
1096 CURLcode result = CURLE_OK;
1097 struct FTP *ftp = conn->data->state.proto.ftp;
1098 struct SessionHandle *data = conn->data;
1100 if(ftp->transfer != FTPTRANSFER_BODY) {
1101 /* doesn't transfer any data */
1103 /* still possibly do PRE QUOTE jobs */
1104 state(conn, FTP_RETR_PREQUOTE);
1105 result = ftp_state_quote(conn, TRUE, FTP_RETR_PREQUOTE);
1107 else if(data->set.ftp_use_port) {
1108 /* We have chosen to use the PORT (or similar) command */
1109 result = ftp_state_use_port(conn, EPRT);
1112 /* We have chosen (this is default) to use the PASV (or similar) command */
1113 if(data->set.ftp_use_pret) {
1114 /* The user has requested that we send a PRET command
1115 to prepare the server for the upcoming PASV */
1116 if(!conn->proto.ftpc.file) {
1117 PPSENDF(&conn->proto.ftpc.pp, "PRET %s",
1118 data->set.str[STRING_CUSTOMREQUEST]?
1119 data->set.str[STRING_CUSTOMREQUEST]:
1120 (data->set.ftp_list_only?"NLST":"LIST"));
1122 else if(data->set.upload) {
1123 PPSENDF(&conn->proto.ftpc.pp, "PRET STOR %s", conn->proto.ftpc.file);
1126 PPSENDF(&conn->proto.ftpc.pp, "PRET RETR %s", conn->proto.ftpc.file);
1128 state(conn, FTP_PRET);
1131 result = ftp_state_use_pasv(conn);
1137 static CURLcode ftp_state_post_size(struct connectdata *conn)
1139 CURLcode result = CURLE_OK;
1140 struct FTP *ftp = conn->data->state.proto.ftp;
1141 struct ftp_conn *ftpc = &conn->proto.ftpc;
1143 if((ftp->transfer != FTPTRANSFER_BODY) && ftpc->file) {
1144 /* if a "head"-like request is being made (on a file) */
1146 /* Determine if server can respond to REST command and therefore
1147 whether it supports range */
1148 PPSENDF(&conn->proto.ftpc.pp, "REST %d", 0);
1150 state(conn, FTP_REST);
1153 result = ftp_state_post_rest(conn);
1158 static CURLcode ftp_state_post_type(struct connectdata *conn)
1160 CURLcode result = CURLE_OK;
1161 struct FTP *ftp = conn->data->state.proto.ftp;
1162 struct ftp_conn *ftpc = &conn->proto.ftpc;
1164 if((ftp->transfer == FTPTRANSFER_INFO) && ftpc->file) {
1165 /* if a "head"-like request is being made (on a file) */
1167 /* we know ftpc->file is a valid pointer to a file name */
1168 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file);
1170 state(conn, FTP_SIZE);
1173 result = ftp_state_post_size(conn);
1178 static CURLcode ftp_state_post_listtype(struct connectdata *conn)
1180 CURLcode result = CURLE_OK;
1181 struct SessionHandle *data = conn->data;
1183 /* If this output is to be machine-parsed, the NLST command might be better
1184 to use, since the LIST command output is not specified or standard in any
1185 way. It has turned out that the NLST list output is not the same on all
1186 servers either... */
1189 if FTPFILE_NOCWD was specified, we are currently in
1190 the user's home directory, so we should add the path
1191 as argument for the LIST / NLST / or custom command.
1192 Whether the server will support this, is uncertain.
1194 The other ftp_filemethods will CWD into dir/dir/ first and
1195 then just do LIST (in that case: nothing to do here)
1197 char *cmd,*lstArg,*slashPos;
1200 if((data->set.ftp_filemethod == FTPFILE_NOCWD) &&
1202 data->state.path[0] &&
1203 strchr(data->state.path,'/')) {
1205 lstArg = strdup(data->state.path);
1207 return CURLE_OUT_OF_MEMORY;
1209 /* Check if path does not end with /, as then we cut off the file part */
1210 if(lstArg[strlen(lstArg) - 1] != '/') {
1212 /* chop off the file part if format is dir/dir/file */
1213 slashPos = strrchr(lstArg,'/');
1215 *(slashPos+1) = '\0';
1219 cmd = aprintf( "%s%s%s",
1220 data->set.str[STRING_CUSTOMREQUEST]?
1221 data->set.str[STRING_CUSTOMREQUEST]:
1222 (data->set.ftp_list_only?"NLST":"LIST"),
1224 lstArg? lstArg: "" );
1229 return CURLE_OUT_OF_MEMORY;
1232 result = Curl_pp_sendf(&conn->proto.ftpc.pp, "%s", cmd);
1239 if(result != CURLE_OK)
1242 state(conn, FTP_LIST);
1247 static CURLcode ftp_state_post_retrtype(struct connectdata *conn)
1249 CURLcode result = CURLE_OK;
1251 /* We've sent the TYPE, now we must send the list of prequote strings */
1253 result = ftp_state_quote(conn, TRUE, FTP_RETR_PREQUOTE);
1258 static CURLcode ftp_state_post_stortype(struct connectdata *conn)
1260 CURLcode result = CURLE_OK;
1262 /* We've sent the TYPE, now we must send the list of prequote strings */
1264 result = ftp_state_quote(conn, TRUE, FTP_STOR_PREQUOTE);
1269 static CURLcode ftp_state_post_mdtm(struct connectdata *conn)
1271 CURLcode result = CURLE_OK;
1272 struct FTP *ftp = conn->data->state.proto.ftp;
1273 struct SessionHandle *data = conn->data;
1274 struct ftp_conn *ftpc = &conn->proto.ftpc;
1276 /* If we have selected NOBODY and HEADER, it means that we only want file
1277 information. Which in FTP can't be much more than the file size and
1279 if(data->set.opt_no_body && ftpc->file &&
1280 ftp_need_type(conn, data->set.prefer_ascii)) {
1281 /* The SIZE command is _not_ RFC 959 specified, and therefor many servers
1282 may not support it! It is however the only way we have to get a file's
1285 ftp->transfer = FTPTRANSFER_INFO;
1286 /* this means no actual transfer will be made */
1288 /* Some servers return different sizes for different modes, and thus we
1289 must set the proper type before we check the size */
1290 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_TYPE);
1295 result = ftp_state_post_type(conn);
1300 /* This is called after the CWD commands have been done in the beginning of
1302 static CURLcode ftp_state_post_cwd(struct connectdata *conn)
1304 CURLcode result = CURLE_OK;
1305 struct SessionHandle *data = conn->data;
1306 struct ftp_conn *ftpc = &conn->proto.ftpc;
1308 /* Requested time of file or time-depended transfer? */
1309 if((data->set.get_filetime || data->set.timecondition) && ftpc->file) {
1311 /* we have requested to get the modified-time of the file, this is a white
1312 spot as the MDTM is not mentioned in RFC959 */
1313 PPSENDF(&ftpc->pp, "MDTM %s", ftpc->file);
1315 state(conn, FTP_MDTM);
1318 result = ftp_state_post_mdtm(conn);
1324 /* This is called after the TYPE and possible quote commands have been sent */
1325 static CURLcode ftp_state_ul_setup(struct connectdata *conn,
1328 CURLcode result = CURLE_OK;
1329 struct FTP *ftp = conn->data->state.proto.ftp;
1330 struct SessionHandle *data = conn->data;
1331 struct ftp_conn *ftpc = &conn->proto.ftpc;
1332 int seekerr = CURL_SEEKFUNC_OK;
1334 if((data->state.resume_from && !sizechecked) ||
1335 ((data->state.resume_from > 0) && sizechecked)) {
1336 /* we're about to continue the uploading of a file */
1337 /* 1. get already existing file's size. We use the SIZE command for this
1338 which may not exist in the server! The SIZE command is not in
1341 /* 2. This used to set REST. But since we can do append, we
1342 don't another ftp command. We just skip the source file
1343 offset and then we APPEND the rest on the file instead */
1345 /* 3. pass file-size number of bytes in the source file */
1346 /* 4. lower the infilesize counter */
1347 /* => transfer as usual */
1349 if(data->state.resume_from < 0 ) {
1350 /* Got no given size to start from, figure it out */
1351 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file);
1352 state(conn, FTP_STOR_SIZE);
1357 data->set.ftp_append = TRUE;
1359 /* Let's read off the proper amount of bytes from the input. */
1360 if(conn->seek_func) {
1361 seekerr = conn->seek_func(conn->seek_client, data->state.resume_from,
1365 if(seekerr != CURL_SEEKFUNC_OK) {
1366 if(seekerr != CURL_SEEKFUNC_CANTSEEK) {
1367 failf(data, "Could not seek stream");
1368 return CURLE_FTP_COULDNT_USE_REST;
1370 /* seekerr == CURL_SEEKFUNC_CANTSEEK (can't seek to offset) */
1372 curl_off_t passed=0;
1374 size_t readthisamountnow =
1375 (data->state.resume_from - passed > CURL_OFF_T_C(BUFSIZE)) ?
1376 BUFSIZE : curlx_sotouz(data->state.resume_from - passed);
1378 size_t actuallyread =
1379 conn->fread_func(data->state.buffer, 1, readthisamountnow,
1382 passed += actuallyread;
1383 if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
1384 /* this checks for greater-than only to make sure that the
1385 CURL_READFUNC_ABORT return code still aborts */
1386 failf(data, "Failed to read data");
1387 return CURLE_FTP_COULDNT_USE_REST;
1389 } while(passed < data->state.resume_from);
1392 /* now, decrease the size of the read */
1393 if(data->set.infilesize>0) {
1394 data->set.infilesize -= data->state.resume_from;
1396 if(data->set.infilesize <= 0) {
1397 infof(data, "File already completely uploaded\n");
1399 /* no data to transfer */
1400 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
1402 /* Set ->transfer so that we won't get any error in
1403 * ftp_done() because we didn't transfer anything! */
1404 ftp->transfer = FTPTRANSFER_NONE;
1406 state(conn, FTP_STOP);
1410 /* we've passed, proceed as normal */
1413 PPSENDF(&ftpc->pp, data->set.ftp_append?"APPE %s":"STOR %s",
1416 state(conn, FTP_STOR);
1421 static CURLcode ftp_state_quote(struct connectdata *conn,
1425 CURLcode result = CURLE_OK;
1426 struct SessionHandle *data = conn->data;
1427 struct FTP *ftp = data->state.proto.ftp;
1428 struct ftp_conn *ftpc = &conn->proto.ftpc;
1430 struct curl_slist *item;
1435 item = data->set.quote;
1437 case FTP_RETR_PREQUOTE:
1438 case FTP_STOR_PREQUOTE:
1439 item = data->set.prequote;
1442 item = data->set.postquote;
1448 * 'count1' to iterate over the commands to send
1449 * 'count2' to store wether to allow commands to fail
1460 /* Skip count1 items in the linked list */
1461 while((i< ftpc->count1) && item) {
1466 char *cmd = item->data;
1469 ftpc->count2 = 1; /* the sent command is allowed to fail */
1472 ftpc->count2 = 0; /* failure means cancel operation */
1474 PPSENDF(&ftpc->pp, "%s", cmd);
1475 state(conn, instate);
1481 /* No more quote to send, continue to ... */
1485 result = ftp_state_cwd(conn);
1487 case FTP_RETR_PREQUOTE:
1488 if(ftp->transfer != FTPTRANSFER_BODY)
1489 state(conn, FTP_STOP);
1491 if(ftpc->known_filesize != -1) {
1492 Curl_pgrsSetDownloadSize(data, ftpc->known_filesize);
1493 result = ftp_state_post_retr_size(conn, ftpc->known_filesize);
1496 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file);
1497 state(conn, FTP_RETR_SIZE);
1501 case FTP_STOR_PREQUOTE:
1502 result = ftp_state_ul_setup(conn, FALSE);
1512 static CURLcode ftp_state_pasv_resp(struct connectdata *conn,
1515 struct ftp_conn *ftpc = &conn->proto.ftpc;
1517 struct SessionHandle *data=conn->data;
1518 Curl_addrinfo *conninfo;
1519 struct Curl_dns_entry *addr=NULL;
1521 unsigned short connectport; /* the local port connect() should use! */
1522 unsigned short newport=0; /* remote port */
1525 /* newhost must be able to hold a full IP-style address in ASCII, which
1526 in the IPv6 case means 5*8-1 = 39 letters */
1527 #define NEWHOST_BUFSIZE 48
1528 char newhost[NEWHOST_BUFSIZE];
1529 char *str=&data->state.buffer[4]; /* start on the first letter */
1531 if((ftpc->count1 == 0) &&
1533 /* positive EPSV response */
1534 char *ptr = strchr(str, '(');
1539 if(5 == sscanf(ptr, "%c%c%c%u%c",
1545 const char sep1 = separator[0];
1548 /* The four separators should be identical, or else this is an oddly
1549 formatted reply and we bail out immediately. */
1550 for(i=1; i<4; i++) {
1551 if(separator[i] != sep1) {
1552 ptr=NULL; /* set to NULL to signal error */
1557 newport = (unsigned short)(num & 0xffff);
1559 if(conn->bits.tunnel_proxy ||
1560 conn->proxytype == CURLPROXY_SOCKS5 ||
1561 conn->proxytype == CURLPROXY_SOCKS5_HOSTNAME ||
1562 conn->proxytype == CURLPROXY_SOCKS4 ||
1563 conn->proxytype == CURLPROXY_SOCKS4A)
1564 /* proxy tunnel -> use other host info because ip_addr_str is the
1565 proxy address not the ftp host */
1566 snprintf(newhost, sizeof(newhost), "%s", conn->host.name);
1568 /* use the same IP we are already connected to */
1569 snprintf(newhost, NEWHOST_BUFSIZE, "%s", conn->ip_addr_str);
1576 failf(data, "Weirdly formatted EPSV reply");
1577 return CURLE_FTP_WEIRD_PASV_REPLY;
1580 else if((ftpc->count1 == 1) &&
1582 /* positive PASV response */
1587 * Scan for a sequence of six comma-separated numbers and use them as
1588 * IP+port indicators.
1590 * Found reply-strings include:
1591 * "227 Entering Passive Mode (127,0,0,1,4,51)"
1592 * "227 Data transfer will passively listen to 127,0,0,1,4,51"
1593 * "227 Entering passive mode. 127,0,0,1,4,51"
1596 if(6 == sscanf(str, "%d,%d,%d,%d,%d,%d",
1597 &ip[0], &ip[1], &ip[2], &ip[3],
1598 &port[0], &port[1]))
1604 failf(data, "Couldn't interpret the 227-response");
1605 return CURLE_FTP_WEIRD_227_FORMAT;
1608 /* we got OK from server */
1609 if(data->set.ftp_skip_ip) {
1610 /* told to ignore the remotely given IP but instead use the one we used
1611 for the control connection */
1612 infof(data, "Skips %d.%d.%d.%d for data connection, uses %s instead\n",
1613 ip[0], ip[1], ip[2], ip[3],
1615 if(conn->bits.tunnel_proxy ||
1616 conn->proxytype == CURLPROXY_SOCKS5 ||
1617 conn->proxytype == CURLPROXY_SOCKS5_HOSTNAME ||
1618 conn->proxytype == CURLPROXY_SOCKS4 ||
1619 conn->proxytype == CURLPROXY_SOCKS4A)
1620 /* proxy tunnel -> use other host info because ip_addr_str is the
1621 proxy address not the ftp host */
1622 snprintf(newhost, sizeof(newhost), "%s", conn->host.name);
1624 snprintf(newhost, sizeof(newhost), "%s", conn->ip_addr_str);
1627 snprintf(newhost, sizeof(newhost),
1628 "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
1629 newport = (unsigned short)(((port[0]<<8) + port[1]) & 0xffff);
1631 else if(ftpc->count1 == 0) {
1632 /* EPSV failed, move on to PASV */
1634 /* disable it for next transfer */
1635 conn->bits.ftp_use_epsv = FALSE;
1636 infof(data, "disabling EPSV usage\n");
1638 PPSENDF(&ftpc->pp, "PASV", NULL);
1640 /* remain in the FTP_PASV state */
1644 failf(data, "Bad PASV/EPSV response: %03d", ftpcode);
1645 return CURLE_FTP_WEIRD_PASV_REPLY;
1648 if(data->set.str[STRING_PROXY] && *data->set.str[STRING_PROXY]) {
1650 * This is a tunnel through a http proxy and we need to connect to the
1653 * We don't want to rely on a former host lookup that might've expired
1654 * now, instead we remake the lookup here and now!
1656 rc = Curl_resolv(conn, conn->proxy.name, (int)conn->port, &addr);
1657 if(rc == CURLRESOLV_PENDING)
1658 /* BLOCKING, ignores the return code but 'addr' will be NULL in
1660 (void)Curl_resolver_wait_resolv(conn, &addr);
1663 (unsigned short)conn->port; /* we connect to the proxy's port */
1666 failf(data, "Can't resolve proxy host %s:%hu",
1667 conn->proxy.name, connectport);
1668 return CURLE_FTP_CANT_GET_HOST;
1672 /* normal, direct, ftp connection */
1673 rc = Curl_resolv(conn, newhost, newport, &addr);
1674 if(rc == CURLRESOLV_PENDING)
1676 (void)Curl_resolver_wait_resolv(conn, &addr);
1678 connectport = newport; /* we connect to the remote port */
1681 failf(data, "Can't resolve new host %s:%hu", newhost, connectport);
1682 return CURLE_FTP_CANT_GET_HOST;
1686 result = Curl_connecthost(conn,
1688 &conn->sock[SECONDARYSOCKET],
1692 Curl_resolv_unlock(data, addr); /* we're done using this address */
1694 if(result && ftpc->count1 == 0 && ftpcode == 229) {
1695 infof(data, "got positive EPSV response, but can't connect. "
1696 "Disabling EPSV\n");
1697 /* disable it for next transfer */
1698 conn->bits.ftp_use_epsv = FALSE;
1699 data->state.errorbuf = FALSE; /* allow error message to get rewritten */
1700 PPSENDF(&ftpc->pp, "PASV", NULL);
1702 /* remain in the FTP_PASV state */
1709 conn->bits.tcpconnect[SECONDARYSOCKET] = connected;
1712 * When this is used from the multi interface, this might've returned with
1713 * the 'connected' set to FALSE and thus we are now awaiting a non-blocking
1714 * connect to connect and we should not be "hanging" here waiting.
1717 if(data->set.verbose)
1718 /* this just dumps information about this second connection */
1719 ftp_pasv_verbose(conn, conninfo, newhost, connectport);
1721 switch(conn->proxytype) {
1722 /* FIX: this MUST wait for a proper connect first if 'connected' is
1724 case CURLPROXY_SOCKS5:
1725 case CURLPROXY_SOCKS5_HOSTNAME:
1726 result = Curl_SOCKS5(conn->proxyuser, conn->proxypasswd, newhost, newport,
1727 SECONDARYSOCKET, conn);
1729 case CURLPROXY_SOCKS4:
1730 result = Curl_SOCKS4(conn->proxyuser, newhost, newport,
1731 SECONDARYSOCKET, conn, FALSE);
1733 case CURLPROXY_SOCKS4A:
1734 result = Curl_SOCKS4(conn->proxyuser, newhost, newport,
1735 SECONDARYSOCKET, conn, TRUE);
1737 case CURLPROXY_HTTP:
1738 case CURLPROXY_HTTP_1_0:
1739 /* do nothing here. handled later. */
1742 failf(data, "unknown proxytype option given");
1743 result = CURLE_COULDNT_CONNECT;
1750 if(conn->bits.tunnel_proxy && conn->bits.httpproxy) {
1751 /* FIX: this MUST wait for a proper connect first if 'connected' is
1755 /* We want "seamless" FTP operations through HTTP proxy tunnel */
1757 /* Curl_proxyCONNECT is based on a pointer to a struct HTTP at the member
1758 * conn->proto.http; we want FTP through HTTP and we have to change the
1759 * member temporarily for connecting to the HTTP proxy. After
1760 * Curl_proxyCONNECT we have to set back the member to the original struct
1763 struct HTTP http_proxy;
1764 struct FTP *ftp_save = data->state.proto.ftp;
1765 memset(&http_proxy, 0, sizeof(http_proxy));
1766 data->state.proto.http = &http_proxy;
1768 result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, newhost, newport);
1770 data->state.proto.ftp = ftp_save;
1776 conn->bits.tcpconnect[SECONDARYSOCKET] = TRUE;
1778 state(conn, FTP_STOP); /* this phase is completed */
1783 static CURLcode ftp_state_port_resp(struct connectdata *conn,
1786 struct SessionHandle *data = conn->data;
1787 struct ftp_conn *ftpc = &conn->proto.ftpc;
1788 ftpport fcmd = (ftpport)ftpc->count1;
1789 CURLcode result = CURLE_OK;
1791 if(ftpcode != 200) {
1792 /* the command failed */
1795 infof(data, "disabling EPRT usage\n");
1796 conn->bits.ftp_use_eprt = FALSE;
1801 failf(data, "Failed to do PORT");
1802 result = CURLE_FTP_PORT_FAILED;
1806 result = ftp_state_use_port(conn, fcmd);
1809 infof(data, "Connect data stream actively\n");
1810 state(conn, FTP_STOP); /* end of DO phase */
1816 static CURLcode ftp_state_mdtm_resp(struct connectdata *conn,
1819 CURLcode result = CURLE_OK;
1820 struct SessionHandle *data=conn->data;
1821 struct FTP *ftp = data->state.proto.ftp;
1822 struct ftp_conn *ftpc = &conn->proto.ftpc;
1827 /* we got a time. Format should be: "YYYYMMDDHHMMSS[.sss]" where the
1828 last .sss part is optional and means fractions of a second */
1829 int year, month, day, hour, minute, second;
1830 char *buf = data->state.buffer;
1831 if(6 == sscanf(buf+4, "%04d%02d%02d%02d%02d%02d",
1832 &year, &month, &day, &hour, &minute, &second)) {
1833 /* we have a time, reformat it */
1834 time_t secs=time(NULL);
1835 /* using the good old yacc/bison yuck */
1836 snprintf(buf, sizeof(conn->data->state.buffer),
1837 "%04d%02d%02d %02d:%02d:%02d GMT",
1838 year, month, day, hour, minute, second);
1839 /* now, convert this into a time() value: */
1840 data->info.filetime = (long)curl_getdate(buf, &secs);
1843 #ifdef CURL_FTP_HTTPSTYLE_HEAD
1844 /* If we asked for a time of the file and we actually got one as well,
1845 we "emulate" a HTTP-style header in our output. */
1847 if(data->set.opt_no_body &&
1849 data->set.get_filetime &&
1850 (data->info.filetime>=0) ) {
1851 time_t filetime = (time_t)data->info.filetime;
1853 const struct tm *tm = &buffer;
1855 result = Curl_gmtime(filetime, &buffer);
1859 /* format: "Tue, 15 Nov 1994 12:45:26" */
1860 snprintf(buf, BUFSIZE-1,
1861 "Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n",
1862 Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],
1864 Curl_month[tm->tm_mon],
1869 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
1872 } /* end of a ridiculous amount of conditionals */
1877 infof(data, "unsupported MDTM reply format\n");
1879 case 550: /* "No such file or directory" */
1880 failf(data, "Given file does not exist");
1881 result = CURLE_FTP_COULDNT_RETR_FILE;
1885 if(data->set.timecondition) {
1886 if((data->info.filetime > 0) && (data->set.timevalue > 0)) {
1887 switch(data->set.timecondition) {
1888 case CURL_TIMECOND_IFMODSINCE:
1890 if(data->info.filetime <= data->set.timevalue) {
1891 infof(data, "The requested document is not new enough\n");
1892 ftp->transfer = FTPTRANSFER_NONE; /* mark to not transfer data */
1893 data->info.timecond = TRUE;
1894 state(conn, FTP_STOP);
1898 case CURL_TIMECOND_IFUNMODSINCE:
1899 if(data->info.filetime > data->set.timevalue) {
1900 infof(data, "The requested document is not old enough\n");
1901 ftp->transfer = FTPTRANSFER_NONE; /* mark to not transfer data */
1902 data->info.timecond = TRUE;
1903 state(conn, FTP_STOP);
1910 infof(data, "Skipping time comparison\n");
1915 result = ftp_state_post_mdtm(conn);
1920 static CURLcode ftp_state_type_resp(struct connectdata *conn,
1924 CURLcode result = CURLE_OK;
1925 struct SessionHandle *data=conn->data;
1927 if(ftpcode/100 != 2) {
1928 /* "sasserftpd" and "(u)r(x)bot ftpd" both responds with 226 after a
1929 successful 'TYPE I'. While that is not as RFC959 says, it is still a
1930 positive response code and we allow that. */
1931 failf(data, "Couldn't set desired mode");
1932 return CURLE_FTP_COULDNT_SET_TYPE;
1935 infof(data, "Got a %03d response code instead of the assumed 200\n",
1938 if(instate == FTP_TYPE)
1939 result = ftp_state_post_type(conn);
1940 else if(instate == FTP_LIST_TYPE)
1941 result = ftp_state_post_listtype(conn);
1942 else if(instate == FTP_RETR_TYPE)
1943 result = ftp_state_post_retrtype(conn);
1944 else if(instate == FTP_STOR_TYPE)
1945 result = ftp_state_post_stortype(conn);
1950 static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
1951 curl_off_t filesize)
1953 CURLcode result = CURLE_OK;
1954 struct SessionHandle *data=conn->data;
1955 struct FTP *ftp = data->state.proto.ftp;
1956 struct ftp_conn *ftpc = &conn->proto.ftpc;
1958 if(data->set.max_filesize && (filesize > data->set.max_filesize)) {
1959 failf(data, "Maximum file size exceeded");
1960 return CURLE_FILESIZE_EXCEEDED;
1962 ftp->downloadsize = filesize;
1964 if(data->state.resume_from) {
1965 /* We always (attempt to) get the size of downloads, so it is done before
1966 this even when not doing resumes. */
1967 if(filesize == -1) {
1968 infof(data, "ftp server doesn't support SIZE\n");
1969 /* We couldn't get the size and therefore we can't know if there really
1970 is a part of the file left to get, although the server will just
1971 close the connection when we start the connection so it won't cause
1972 us any harm, just not make us exit as nicely. */
1975 /* We got a file size report, so we check that there actually is a
1976 part of the file left to get, or else we go home. */
1977 if(data->state.resume_from< 0) {
1978 /* We're supposed to download the last abs(from) bytes */
1979 if(filesize < -data->state.resume_from) {
1980 failf(data, "Offset (%" FORMAT_OFF_T
1981 ") was beyond file size (%" FORMAT_OFF_T ")",
1982 data->state.resume_from, filesize);
1983 return CURLE_BAD_DOWNLOAD_RESUME;
1985 /* convert to size to download */
1986 ftp->downloadsize = -data->state.resume_from;
1987 /* download from where? */
1988 data->state.resume_from = filesize - ftp->downloadsize;
1991 if(filesize < data->state.resume_from) {
1992 failf(data, "Offset (%" FORMAT_OFF_T
1993 ") was beyond file size (%" FORMAT_OFF_T ")",
1994 data->state.resume_from, filesize);
1995 return CURLE_BAD_DOWNLOAD_RESUME;
1997 /* Now store the number of bytes we are expected to download */
1998 ftp->downloadsize = filesize-data->state.resume_from;
2002 if(ftp->downloadsize == 0) {
2003 /* no data to transfer */
2004 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
2005 infof(data, "File already completely downloaded\n");
2007 /* Set ->transfer so that we won't get any error in ftp_done()
2008 * because we didn't transfer the any file */
2009 ftp->transfer = FTPTRANSFER_NONE;
2010 state(conn, FTP_STOP);
2014 /* Set resume file transfer offset */
2015 infof(data, "Instructs server to resume from offset %" FORMAT_OFF_T
2016 "\n", data->state.resume_from);
2018 PPSENDF(&ftpc->pp, "REST %" FORMAT_OFF_T, data->state.resume_from);
2020 state(conn, FTP_RETR_REST);
2025 PPSENDF(&ftpc->pp, "RETR %s", ftpc->file);
2026 state(conn, FTP_RETR);
2032 static CURLcode ftp_state_size_resp(struct connectdata *conn,
2036 CURLcode result = CURLE_OK;
2037 struct SessionHandle *data=conn->data;
2038 curl_off_t filesize;
2039 char *buf = data->state.buffer;
2041 /* get the size from the ascii string: */
2042 filesize = (ftpcode == 213)?curlx_strtoofft(buf+4, NULL, 0):-1;
2044 if(instate == FTP_SIZE) {
2045 #ifdef CURL_FTP_HTTPSTYLE_HEAD
2046 if(-1 != filesize) {
2047 snprintf(buf, sizeof(data->state.buffer),
2048 "Content-Length: %" FORMAT_OFF_T "\r\n", filesize);
2049 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
2054 Curl_pgrsSetDownloadSize(data, filesize);
2055 result = ftp_state_post_size(conn);
2057 else if(instate == FTP_RETR_SIZE) {
2058 Curl_pgrsSetDownloadSize(data, filesize);
2059 result = ftp_state_post_retr_size(conn, filesize);
2061 else if(instate == FTP_STOR_SIZE) {
2062 data->state.resume_from = filesize;
2063 result = ftp_state_ul_setup(conn, TRUE);
2069 static CURLcode ftp_state_rest_resp(struct connectdata *conn,
2073 CURLcode result = CURLE_OK;
2074 struct ftp_conn *ftpc = &conn->proto.ftpc;
2079 #ifdef CURL_FTP_HTTPSTYLE_HEAD
2080 if(ftpcode == 350) {
2081 char buffer[24]= { "Accept-ranges: bytes\r\n" };
2082 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buffer, 0);
2087 result = ftp_state_post_rest(conn);
2091 if(ftpcode != 350) {
2092 failf(conn->data, "Couldn't use REST");
2093 result = CURLE_FTP_COULDNT_USE_REST;
2096 PPSENDF(&ftpc->pp, "RETR %s", ftpc->file);
2097 state(conn, FTP_RETR);
2105 static CURLcode ftp_state_stor_resp(struct connectdata *conn,
2108 CURLcode result = CURLE_OK;
2109 struct SessionHandle *data = conn->data;
2110 struct FTP *ftp = data->state.proto.ftp;
2113 failf(data, "Failed FTP upload: %0d", ftpcode);
2114 /* oops, we never close the sockets! */
2115 return CURLE_UPLOAD_FAILED;
2118 if(data->set.ftp_use_port) {
2120 /* PORT means we are now awaiting the server to connect to us. */
2121 result = AllowServerConnect(conn);
2126 if(conn->ssl[SECONDARYSOCKET].use) {
2127 /* since we only have a plaintext TCP connection here, we must now
2129 infof(data, "Doing the SSL/TLS handshake on the data stream\n");
2131 result = Curl_ssl_connect(conn, SECONDARYSOCKET);
2136 *(ftp->bytecountp)=0;
2138 /* When we know we're uploading a specified file, we can get the file
2139 size prior to the actual upload. */
2141 Curl_pgrsSetUploadSize(data, data->set.infilesize);
2143 /* set the SO_SNDBUF for the secondary socket for those who need it */
2144 Curl_sndbufset(conn->sock[SECONDARYSOCKET]);
2146 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, /* no download */
2147 SECONDARYSOCKET, ftp->bytecountp);
2148 state(conn, FTP_STOP);
2150 conn->proto.ftpc.pp.pending_resp = TRUE; /* expect a server response */
2155 /* for LIST and RETR responses */
2156 static CURLcode ftp_state_get_resp(struct connectdata *conn,
2160 CURLcode result = CURLE_OK;
2161 struct SessionHandle *data = conn->data;
2162 struct FTP *ftp = data->state.proto.ftp;
2163 char *buf = data->state.buffer;
2165 if((ftpcode == 150) || (ftpcode == 125)) {
2169 150 Opening BINARY mode data connection for /etc/passwd (2241
2170 bytes). (ok, the file is being transferred)
2173 150 Opening ASCII mode data connection for /bin/ls
2176 150 ASCII data connection for /bin/ls (137.167.104.91,37445) (0 bytes).
2179 150 Opening ASCII mode data connection for [file] (0.0.0.0,0) (545 bytes)
2182 125 Data connection already open; Transfer starting. */
2184 curl_off_t size=-1; /* default unknown size */
2188 * It appears that there are FTP-servers that return size 0 for files when
2189 * SIZE is used on the file while being in BINARY mode. To work around
2190 * that (stupid) behavior, we attempt to parse the RETR response even if
2191 * the SIZE returned size zero.
2193 * Debugging help from Salvatore Sorrentino on February 26, 2003.
2196 if((instate != FTP_LIST) &&
2197 !data->set.prefer_ascii &&
2198 (ftp->downloadsize < 1)) {
2200 * It seems directory listings either don't show the size or very
2201 * often uses size 0 anyway. ASCII transfers may very well turn out
2202 * that the transferred amount of data is not the same as this line
2203 * tells, why using this number in those cases only confuses us.
2205 * Example D above makes this parsing a little tricky */
2207 bytes=strstr(buf, " bytes");
2209 long in=(long)(bytes-buf);
2210 /* this is a hint there is size information in there! ;-) */
2212 /* scan for the left parenthesis and break there */
2215 /* skip only digits */
2216 if(!ISDIGIT(*bytes)) {
2220 /* one more estep backwards */
2223 /* if we have nothing but digits: */
2225 /* get the number! */
2226 size = curlx_strtoofft(bytes, NULL, 0);
2230 else if(ftp->downloadsize > -1)
2231 size = ftp->downloadsize;
2233 if(data->set.ftp_use_port) {
2235 result = AllowServerConnect(conn);
2240 if(conn->ssl[SECONDARYSOCKET].use) {
2241 /* since we only have a plaintext TCP connection here, we must now
2243 infof(data, "Doing the SSL/TLS handshake on the data stream\n");
2244 result = Curl_ssl_connect(conn, SECONDARYSOCKET);
2249 if(size > data->req.maxdownload && data->req.maxdownload > 0)
2250 size = data->req.size = data->req.maxdownload;
2251 else if((instate != FTP_LIST) && (data->set.prefer_ascii))
2252 size = -1; /* kludge for servers that understate ASCII mode file size */
2254 infof(data, "Maxdownload = %" FORMAT_OFF_T "\n", data->req.maxdownload);
2256 if(instate != FTP_LIST)
2257 infof(data, "Getting file with size: %" FORMAT_OFF_T "\n", size);
2260 Curl_setup_transfer(conn, SECONDARYSOCKET, size, FALSE,
2261 ftp->bytecountp, -1, NULL); /* no upload here */
2263 conn->proto.ftpc.pp.pending_resp = TRUE; /* expect server response */
2264 state(conn, FTP_STOP);
2267 if((instate == FTP_LIST) && (ftpcode == 450)) {
2268 /* simply no matching files in the dir listing */
2269 ftp->transfer = FTPTRANSFER_NONE; /* don't download anything */
2270 state(conn, FTP_STOP); /* this phase is over */
2273 failf(data, "RETR response: %03d", ftpcode);
2274 return instate == FTP_RETR && ftpcode == 550?
2275 CURLE_REMOTE_FILE_NOT_FOUND:
2276 CURLE_FTP_COULDNT_RETR_FILE;
2283 /* after USER, PASS and ACCT */
2284 static CURLcode ftp_state_loggedin(struct connectdata *conn)
2286 CURLcode result = CURLE_OK;
2289 if(conn->data->set.krb) {
2290 /* We may need to issue a KAUTH here to have access to the files
2291 * do it if user supplied a password
2293 if(conn->passwd && *conn->passwd) {
2295 result = Curl_krb_kauth(conn);
2301 if(conn->ssl[FIRSTSOCKET].use) {
2302 /* PBSZ = PROTECTION BUFFER SIZE.
2304 The 'draft-murray-auth-ftp-ssl' (draft 12, page 7) says:
2306 Specifically, the PROT command MUST be preceded by a PBSZ
2307 command and a PBSZ command MUST be preceded by a successful
2308 security data exchange (the TLS negotiation in this case)
2310 ... (and on page 8):
2312 Thus the PBSZ command must still be issued, but must have a
2313 parameter of '0' to indicate that no buffering is taking place
2314 and the data connection should not be encapsulated.
2316 PPSENDF(&conn->proto.ftpc.pp, "PBSZ %d", 0);
2317 state(conn, FTP_PBSZ);
2320 result = ftp_state_pwd(conn);
2325 /* for USER and PASS responses */
2326 static CURLcode ftp_state_user_resp(struct connectdata *conn,
2330 CURLcode result = CURLE_OK;
2331 struct SessionHandle *data = conn->data;
2332 struct FTP *ftp = data->state.proto.ftp;
2333 struct ftp_conn *ftpc = &conn->proto.ftpc;
2334 (void)instate; /* no use for this yet */
2336 /* some need password anyway, and others just return 2xx ignored */
2337 if((ftpcode == 331) && (ftpc->state == FTP_USER)) {
2338 /* 331 Password required for ...
2339 (the server requires to send the user's password too) */
2340 PPSENDF(&ftpc->pp, "PASS %s", ftp->passwd?ftp->passwd:"");
2341 state(conn, FTP_PASS);
2343 else if(ftpcode/100 == 2) {
2344 /* 230 User ... logged in.
2345 (the user logged in with or without password) */
2346 result = ftp_state_loggedin(conn);
2348 else if(ftpcode == 332) {
2349 if(data->set.str[STRING_FTP_ACCOUNT]) {
2350 PPSENDF(&ftpc->pp, "ACCT %s", data->set.str[STRING_FTP_ACCOUNT]);
2351 state(conn, FTP_ACCT);
2354 failf(data, "ACCT requested but none available");
2355 result = CURLE_LOGIN_DENIED;
2359 /* All other response codes, like:
2361 530 User ... access denied
2362 (the server denies to log the specified user) */
2364 if(conn->data->set.str[STRING_FTP_ALTERNATIVE_TO_USER] &&
2365 !conn->data->state.ftp_trying_alternative) {
2366 /* Ok, USER failed. Let's try the supplied command. */
2367 PPSENDF(&conn->proto.ftpc.pp, "%s",
2368 conn->data->set.str[STRING_FTP_ALTERNATIVE_TO_USER]);
2369 conn->data->state.ftp_trying_alternative = TRUE;
2370 state(conn, FTP_USER);
2374 failf(data, "Access denied: %03d", ftpcode);
2375 result = CURLE_LOGIN_DENIED;
2381 /* for ACCT response */
2382 static CURLcode ftp_state_acct_resp(struct connectdata *conn,
2385 CURLcode result = CURLE_OK;
2386 struct SessionHandle *data = conn->data;
2387 if(ftpcode != 230) {
2388 failf(data, "ACCT rejected by server: %03d", ftpcode);
2389 result = CURLE_FTP_WEIRD_PASS_REPLY; /* FIX */
2392 result = ftp_state_loggedin(conn);
2398 static CURLcode ftp_statemach_act(struct connectdata *conn)
2401 curl_socket_t sock = conn->sock[FIRSTSOCKET];
2402 struct SessionHandle *data=conn->data;
2404 struct ftp_conn *ftpc = &conn->proto.ftpc;
2405 struct pingpong *pp = &ftpc->pp;
2406 static const char ftpauth[][4] = { "SSL", "TLS" };
2410 return Curl_pp_flushsend(pp);
2412 /* we read a piece of response */
2413 result = ftp_readresp(sock, pp, &ftpcode, &nread);
2418 /* we have now received a full FTP server response */
2419 switch(ftpc->state) {
2421 if(ftpcode != 220) {
2422 failf(data, "Got a %03d ftp-server response when 220 was expected",
2424 return CURLE_FTP_WEIRD_SERVER_REPLY;
2427 /* We have received a 220 response fine, now we proceed. */
2428 #if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)
2430 /* If not anonymous login, try a secure login. Note that this
2431 procedure is still BLOCKING. */
2433 Curl_sec_request_prot(conn, "private");
2434 /* We set private first as default, in case the line below fails to
2435 set a valid level */
2436 Curl_sec_request_prot(conn, data->set.str[STRING_KRB_LEVEL]);
2438 if(Curl_sec_login(conn) != CURLE_OK)
2439 infof(data, "Logging in with password in cleartext!\n");
2441 infof(data, "Authentication successful\n");
2445 if(data->set.ftp_ssl && !conn->ssl[FIRSTSOCKET].use) {
2446 /* We don't have a SSL/TLS connection yet, but FTPS is
2447 requested. Try a FTPS connection now */
2450 switch(data->set.ftpsslauth) {
2451 case CURLFTPAUTH_DEFAULT:
2452 case CURLFTPAUTH_SSL:
2453 ftpc->count2 = 1; /* add one to get next */
2456 case CURLFTPAUTH_TLS:
2457 ftpc->count2 = -1; /* subtract one to get next */
2461 failf(data, "unsupported parameter to CURLOPT_FTPSSLAUTH: %d",
2462 (int)data->set.ftpsslauth);
2463 return CURLE_UNKNOWN_OPTION; /* we don't know what to do */
2465 PPSENDF(&ftpc->pp, "AUTH %s", ftpauth[ftpc->count1]);
2466 state(conn, FTP_AUTH);
2469 result = ftp_state_user(conn);
2477 /* we have gotten the response to a previous AUTH command */
2479 /* RFC2228 (page 5) says:
2481 * If the server is willing to accept the named security mechanism,
2482 * and does not require any security data, it must respond with
2483 * reply code 234/334.
2486 if((ftpcode == 234) || (ftpcode == 334)) {
2487 /* Curl_ssl_connect is BLOCKING */
2488 result = Curl_ssl_connect(conn, FIRSTSOCKET);
2489 if(CURLE_OK == result) {
2490 conn->ssl[SECONDARYSOCKET].use = FALSE; /* clear-text data */
2491 result = ftp_state_user(conn);
2494 else if(ftpc->count3 < 1) {
2496 ftpc->count1 += ftpc->count2; /* get next attempt */
2497 result = Curl_pp_sendf(&ftpc->pp, "AUTH %s", ftpauth[ftpc->count1]);
2498 /* remain in this same state */
2501 if(data->set.ftp_ssl > CURLUSESSL_TRY)
2502 /* we failed and CURLUSESSL_CONTROL or CURLUSESSL_ALL is set */
2503 result = CURLE_USE_SSL_FAILED;
2505 /* ignore the failure and continue */
2506 result = ftp_state_user(conn);
2515 result = ftp_state_user_resp(conn, ftpcode, ftpc->state);
2519 result = ftp_state_acct_resp(conn, ftpcode);
2523 PPSENDF(&ftpc->pp, "PROT %c",
2524 data->set.ftp_ssl == CURLUSESSL_CONTROL ? 'C' : 'P');
2525 state(conn, FTP_PROT);
2530 if(ftpcode/100 == 2)
2531 /* We have enabled SSL for the data connection! */
2532 conn->ssl[SECONDARYSOCKET].use =
2533 (bool)(data->set.ftp_ssl != CURLUSESSL_CONTROL);
2534 /* FTP servers typically responds with 500 if they decide to reject
2536 else if(data->set.ftp_ssl > CURLUSESSL_CONTROL)
2537 /* we failed and bails out */
2538 return CURLE_USE_SSL_FAILED;
2540 if(data->set.ftp_ccc) {
2541 /* CCC - Clear Command Channel
2543 PPSENDF(&ftpc->pp, "CCC", NULL);
2544 state(conn, FTP_CCC);
2547 result = ftp_state_pwd(conn);
2555 /* First shut down the SSL layer (note: this call will block) */
2556 result = Curl_ssl_shutdown(conn, FIRSTSOCKET);
2559 failf(conn->data, "Failed to clear the command channel (CCC)");
2564 /* Then continue as normal */
2565 result = ftp_state_pwd(conn);
2571 if(ftpcode == 257) {
2572 char *ptr=&data->state.buffer[4]; /* start on the first letter */
2576 dir = malloc(nread + 1);
2578 return CURLE_OUT_OF_MEMORY;
2580 /* Reply format is like
2581 257<space>"<directory-name>"<space><commentary> and the RFC959
2584 The directory name can contain any character; embedded
2585 double-quotes should be escaped by double-quotes (the
2586 "quote-doubling" convention).
2589 /* it started good */
2591 for(store = dir; *ptr;) {
2593 if('\"' == ptr[1]) {
2594 /* "quote-doubling" */
2600 *store = '\0'; /* zero terminate */
2601 break; /* get out of this loop */
2610 free(ftpc->entrypath);
2611 ftpc->entrypath =dir; /* remember this */
2612 infof(data, "Entry path is '%s'\n", ftpc->entrypath);
2613 /* also save it where getinfo can access it: */
2614 data->state.most_recent_ftp_entrypath = ftpc->entrypath;
2616 /* If the path name does not look like an absolute path (i.e.: it
2617 does not start with a '/'), we probably need some server-dependent
2618 adjustments. For example, this is the case when connecting to
2619 an OS400 FTP server: this server supports two name syntaxes,
2620 the default one being incompatible with standard pathes. In
2621 addition, this server switches automatically to the regular path
2622 syntax when one is encountered in a command: this results in
2623 having an entrypath in the wrong syntax when later used in CWD.
2624 The method used here is to check the server OS: we do it only
2625 if the path name looks strange to minimize overhead on other
2628 if(!ftpc->server_os && ftpc->entrypath[0] != '/') {
2630 result = Curl_pp_sendf(&ftpc->pp, "SYST", NULL);
2631 if(result != CURLE_OK) {
2632 free(ftpc->entrypath);
2633 ftpc->entrypath = NULL;
2634 data->state.most_recent_ftp_entrypath = NULL;
2637 state(conn, FTP_SYST);
2642 /* couldn't get the path */
2644 infof(data, "Failed to figure out path\n");
2647 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2648 DEBUGF(infof(data, "protocol connect phase DONE\n"));
2652 if(ftpcode == 215) {
2653 char *ptr=&data->state.buffer[4]; /* start on the first letter */
2657 os = malloc(nread + 1);
2659 return CURLE_OUT_OF_MEMORY;
2661 /* Reply format is like
2662 215<space><OS-name><space><commentary>
2666 for(store = os; *ptr && *ptr != ' ';)
2668 *store = '\0'; /* zero terminate */
2669 Curl_safefree(ftpc->server_os);
2670 ftpc->server_os = os;
2672 /* Check for special servers here. */
2674 if(strequal(ftpc->server_os, "OS/400")) {
2675 /* Force OS400 name format 1. */
2676 result = Curl_pp_sendf(&ftpc->pp, "SITE NAMEFMT 1", NULL);
2677 if(result != CURLE_OK) {
2678 free(ftpc->server_os);
2679 ftpc->server_os = NULL;
2682 state(conn, FTP_NAMEFMT);
2686 /* Nothing special for the target server. */
2690 /* Cannot identify server OS. Continue anyway and cross fingers. */
2693 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2694 DEBUGF(infof(data, "protocol connect phase DONE\n"));
2698 if(ftpcode == 250) {
2699 /* Name format change successful: reload initial path. */
2700 ftp_state_pwd(conn);
2704 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2705 DEBUGF(infof(data, "protocol connect phase DONE\n"));
2710 case FTP_RETR_PREQUOTE:
2711 case FTP_STOR_PREQUOTE:
2712 if((ftpcode >= 400) && !ftpc->count2) {
2713 /* failure response code, and not allowed to fail */
2714 failf(conn->data, "QUOT command failed with %03d", ftpcode);
2715 return CURLE_QUOTE_ERROR;
2717 result = ftp_state_quote(conn, FALSE, ftpc->state);
2724 if(ftpcode/100 != 2) {
2725 /* failure to CWD there */
2726 if(conn->data->set.ftp_create_missing_dirs &&
2727 ftpc->count1 && !ftpc->count2) {
2729 ftpc->count2++; /* counter to prevent CWD-MKD loops */
2730 PPSENDF(&ftpc->pp, "MKD %s", ftpc->dirs[ftpc->count1 - 1]);
2731 state(conn, FTP_MKD);
2734 /* return failure */
2735 failf(data, "Server denied you to change to the given directory");
2736 ftpc->cwdfail = TRUE; /* don't remember this path as we failed
2738 return CURLE_REMOTE_ACCESS_DENIED;
2744 if(++ftpc->count1 <= ftpc->dirdepth) {
2746 PPSENDF(&ftpc->pp, "CWD %s", ftpc->dirs[ftpc->count1 - 1]);
2749 result = ftp_state_post_cwd(conn);
2757 if((ftpcode/100 != 2) && !ftpc->count3--) {
2758 /* failure to MKD the dir */
2759 failf(data, "Failed to MKD dir: %03d", ftpcode);
2760 return CURLE_REMOTE_ACCESS_DENIED;
2762 state(conn, FTP_CWD);
2764 PPSENDF(&ftpc->pp, "CWD %s", ftpc->dirs[ftpc->count1 - 1]);
2768 result = ftp_state_mdtm_resp(conn, ftpcode);
2775 result = ftp_state_type_resp(conn, ftpcode, ftpc->state);
2781 result = ftp_state_size_resp(conn, ftpcode, ftpc->state);
2786 result = ftp_state_rest_resp(conn, ftpcode, ftpc->state);
2790 if(ftpcode != 200) {
2791 /* there only is this one standard OK return code. */
2792 failf(data, "PRET command not accepted: %03d", ftpcode);
2793 return CURLE_FTP_PRET_FAILED;
2795 result = ftp_state_use_pasv(conn);
2799 result = ftp_state_pasv_resp(conn, ftpcode);
2803 result = ftp_state_port_resp(conn, ftpcode);
2808 result = ftp_state_get_resp(conn, ftpcode, ftpc->state);
2812 result = ftp_state_stor_resp(conn, ftpcode);
2816 /* fallthrough, just stop! */
2818 /* internal error */
2819 state(conn, FTP_STOP);
2828 /* called repeatedly until done from multi.c */
2829 static CURLcode ftp_multi_statemach(struct connectdata *conn,
2832 struct ftp_conn *ftpc = &conn->proto.ftpc;
2833 CURLcode result = Curl_pp_multi_statemach(&ftpc->pp);
2835 /* Check for the state outside of the Curl_socket_ready() return code checks
2836 since at times we are in fact already in this state when this function
2838 *done = (bool)(ftpc->state == FTP_STOP);
2843 static CURLcode ftp_easy_statemach(struct connectdata *conn)
2845 struct ftp_conn *ftpc = &conn->proto.ftpc;
2846 struct pingpong *pp = &ftpc->pp;
2847 CURLcode result = CURLE_OK;
2849 while(ftpc->state != FTP_STOP) {
2850 result = Curl_pp_easy_statemach(pp);
2859 * Allocate and initialize the struct FTP for the current SessionHandle. If
2863 #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \
2864 defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__)
2865 /* workaround icc 9.1 optimizer issue */
2866 #pragma optimize("", off)
2869 static CURLcode ftp_init(struct connectdata *conn)
2873 if(NULL == conn->data->state.proto.ftp) {
2874 conn->data->state.proto.ftp = malloc(sizeof(struct FTP));
2875 if(NULL == conn->data->state.proto.ftp)
2876 return CURLE_OUT_OF_MEMORY;
2879 ftp = conn->data->state.proto.ftp;
2881 /* get some initial data into the ftp struct */
2882 ftp->bytecountp = &conn->data->req.bytecount;
2883 ftp->transfer = FTPTRANSFER_BODY;
2884 ftp->downloadsize = 0;
2886 /* No need to duplicate user+password, the connectdata struct won't change
2887 during a session, but we re-init them here since on subsequent inits
2888 since the conn struct may have changed or been replaced.
2890 ftp->user = conn->user;
2891 ftp->passwd = conn->passwd;
2892 if(TRUE == isBadFtpString(ftp->user))
2893 return CURLE_URL_MALFORMAT;
2894 if(TRUE == isBadFtpString(ftp->passwd))
2895 return CURLE_URL_MALFORMAT;
2897 conn->proto.ftpc.known_filesize = -1; /* unknown size for now */
2902 #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \
2903 defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__)
2904 /* workaround icc 9.1 optimizer issue */
2905 #pragma optimize("", on)
2909 * ftp_connect() should do everything that is to be considered a part of
2910 * the connection phase.
2912 * The variable 'done' points to will be TRUE if the protocol-layer connect
2913 * phase is done when this function returns, or FALSE is not. When called as
2914 * a part of the easy interface, it will always be TRUE.
2916 static CURLcode ftp_connect(struct connectdata *conn,
2917 bool *done) /* see description above */
2920 struct ftp_conn *ftpc = &conn->proto.ftpc;
2921 struct SessionHandle *data=conn->data;
2922 struct pingpong *pp = &ftpc->pp;
2924 *done = FALSE; /* default to not done yet */
2926 /* If there already is a protocol-specific struct allocated for this
2927 sessionhandle, deal with it */
2928 Curl_reset_reqproto(conn);
2930 result = ftp_init(conn);
2931 if(CURLE_OK != result)
2934 /* We always support persistent connections on ftp */
2935 conn->bits.close = FALSE;
2937 pp->response_time = RESP_TIMEOUT; /* set default response time-out */
2938 pp->statemach_act = ftp_statemach_act;
2939 pp->endofresp = ftp_endofresp;
2942 if(conn->bits.tunnel_proxy && conn->bits.httpproxy) {
2943 /* for FTP over HTTP proxy */
2944 struct HTTP http_proxy;
2945 struct FTP *ftp_save;
2948 /* We want "seamless" FTP operations through HTTP proxy tunnel */
2950 /* Curl_proxyCONNECT is based on a pointer to a struct HTTP at the member
2951 * conn->proto.http; we want FTP through HTTP and we have to change the
2952 * member temporarily for connecting to the HTTP proxy. After
2953 * Curl_proxyCONNECT we have to set back the member to the original struct
2956 ftp_save = data->state.proto.ftp;
2957 memset(&http_proxy, 0, sizeof(http_proxy));
2958 data->state.proto.http = &http_proxy;
2960 result = Curl_proxyCONNECT(conn, FIRSTSOCKET,
2961 conn->host.name, conn->remote_port);
2963 data->state.proto.ftp = ftp_save;
2965 if(CURLE_OK != result)
2969 if(conn->handler->flags & PROTOPT_SSL) {
2971 result = Curl_ssl_connect(conn, FIRSTSOCKET);
2976 Curl_pp_init(pp); /* init the generic pingpong data */
2978 /* When we connect, we start in the state where we await the 220
2980 state(conn, FTP_WAIT220);
2982 if(data->state.used_interface == Curl_if_multi)
2983 result = ftp_multi_statemach(conn, done);
2985 result = ftp_easy_statemach(conn);
2993 /***********************************************************************
2997 * The DONE function. This does what needs to be done after a single DO has
3000 * Input argument is already checked for validity.
3002 static CURLcode ftp_done(struct connectdata *conn, CURLcode status,
3005 struct SessionHandle *data = conn->data;
3006 struct FTP *ftp = data->state.proto.ftp;
3007 struct ftp_conn *ftpc = &conn->proto.ftpc;
3008 struct pingpong *pp = &ftpc->pp;
3011 CURLcode result=CURLE_OK;
3012 bool was_ctl_valid = ftpc->ctl_valid;
3014 const char *path_to_use = data->state.path;
3017 /* When the easy handle is removed from the multi while libcurl is still
3018 * trying to resolve the host name, it seems that the ftp struct is not
3019 * yet initialized, but the removal action calls Curl_done() which calls
3020 * this function. So we simply return success if no ftp pointer is set.
3025 case CURLE_BAD_DOWNLOAD_RESUME:
3026 case CURLE_FTP_WEIRD_PASV_REPLY:
3027 case CURLE_FTP_PORT_FAILED:
3028 case CURLE_FTP_COULDNT_SET_TYPE:
3029 case CURLE_FTP_COULDNT_RETR_FILE:
3030 case CURLE_UPLOAD_FAILED:
3031 case CURLE_REMOTE_ACCESS_DENIED:
3032 case CURLE_FILESIZE_EXCEEDED:
3033 case CURLE_REMOTE_FILE_NOT_FOUND:
3034 case CURLE_WRITE_ERROR:
3035 /* the connection stays alive fine even though this happened */
3037 case CURLE_OK: /* doesn't affect the control connection's status */
3039 ftpc->ctl_valid = was_ctl_valid;
3042 /* until we cope better with prematurely ended requests, let them
3043 * fallback as if in complete failure */
3044 default: /* by default, an error means the control connection is
3045 wedged and should not be used anymore */
3046 ftpc->ctl_valid = FALSE;
3047 ftpc->cwdfail = TRUE; /* set this TRUE to prevent us to remember the
3048 current path, as this connection is going */
3049 conn->bits.close = TRUE; /* marked for closure */
3050 result = status; /* use the already set error code */
3054 /* now store a copy of the directory we are in */
3056 free(ftpc->prevpath);
3058 if(data->set.wildcardmatch) {
3059 if(data->set.chunk_end && ftpc->file) {
3060 data->set.chunk_end(data->wildcard.customptr);
3062 ftpc->known_filesize = -1;
3065 /* get the "raw" path */
3066 path = curl_easy_unescape(data, path_to_use, 0, NULL);
3068 /* out of memory, but we can limp along anyway (and should try to
3069 * since we're in the out of memory cleanup path) */
3070 ftpc->prevpath = NULL; /* no path */
3073 size_t flen = ftpc->file?strlen(ftpc->file):0; /* file is "raw" already */
3074 size_t dlen = strlen(path)-flen;
3075 if(!ftpc->cwdfail) {
3076 if(dlen && (data->set.ftp_filemethod != FTPFILE_NOCWD)) {
3077 ftpc->prevpath = path;
3079 /* if 'path' is not the whole string */
3080 ftpc->prevpath[dlen]=0; /* terminate */
3083 /* we never changed dir */
3084 ftpc->prevpath=strdup("");
3088 infof(data, "Remembering we are in dir \"%s\"\n", ftpc->prevpath);
3091 ftpc->prevpath = NULL; /* no path */
3095 /* free the dir tree and file parts */
3098 /* shut down the socket to inform the server we're done */
3101 shutdown(conn->sock[SECONDARYSOCKET],2); /* SD_BOTH */
3104 if(conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD) {
3105 if(!result && ftpc->dont_check && data->req.maxdownload > 0)
3106 /* partial download completed */
3107 result = Curl_pp_sendf(pp, "ABOR");
3109 if(conn->ssl[SECONDARYSOCKET].use) {
3110 /* The secondary socket is using SSL so we must close down that part
3111 first before we close the socket for real */
3112 Curl_ssl_close(conn, SECONDARYSOCKET);
3114 /* Note that we keep "use" set to TRUE since that (next) connection is
3115 still requested to use SSL */
3117 if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET]) {
3118 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
3119 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
3123 if(!result && (ftp->transfer == FTPTRANSFER_BODY) && ftpc->ctl_valid &&
3124 pp->pending_resp && !premature) {
3126 * Let's see what the server says about the transfer we just performed,
3127 * but lower the timeout as sometimes this connection has died while the
3128 * data has been transferred. This happens when doing through NATs etc that
3129 * abandon old silent connections.
3131 long old_time = pp->response_time;
3133 pp->response_time = 60*1000; /* give it only a minute for now */
3134 pp->response = Curl_tvnow(); /* timeout relative now */
3136 result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
3138 pp->response_time = old_time; /* set this back to previous value */
3140 if(!nread && (CURLE_OPERATION_TIMEDOUT == result)) {
3141 failf(data, "control connection looks dead");
3142 ftpc->ctl_valid = FALSE; /* mark control connection as bad */
3143 conn->bits.close = TRUE; /* mark for closure */
3149 if(ftpc->dont_check && data->req.maxdownload > 0) {
3150 /* we have just sent ABOR and there is no reliable way to check if it was
3151 * successful or not; we have to close the connection now */
3152 infof(data, "partial download completed, closing connection\n");
3153 conn->bits.close = TRUE; /* mark for closure */
3157 if(!ftpc->dont_check) {
3158 /* 226 Transfer complete, 250 Requested file action okay, completed. */
3159 if((ftpcode != 226) && (ftpcode != 250)) {
3160 failf(data, "server did not report OK, got %d", ftpcode);
3161 result = CURLE_PARTIAL_FILE;
3166 if(result || premature)
3167 /* the response code from the transfer showed an error already so no
3168 use checking further */
3170 else if(data->set.upload) {
3171 if((-1 != data->set.infilesize) &&
3172 (data->set.infilesize != *ftp->bytecountp) &&
3174 (ftp->transfer == FTPTRANSFER_BODY)) {
3175 failf(data, "Uploaded unaligned file size (%" FORMAT_OFF_T
3176 " out of %" FORMAT_OFF_T " bytes)",
3177 *ftp->bytecountp, data->set.infilesize);
3178 result = CURLE_PARTIAL_FILE;
3182 if((-1 != data->req.size) &&
3183 (data->req.size != *ftp->bytecountp) &&
3184 #ifdef CURL_DO_LINEEND_CONV
3185 /* Most FTP servers don't adjust their file SIZE response for CRLFs, so
3186 * we'll check to see if the discrepancy can be explained by the number
3187 * of CRLFs we've changed to LFs.
3189 ((data->req.size + data->state.crlf_conversions) !=
3190 *ftp->bytecountp) &&
3191 #endif /* CURL_DO_LINEEND_CONV */
3192 (data->req.maxdownload != *ftp->bytecountp)) {
3193 failf(data, "Received only partial file: %" FORMAT_OFF_T " bytes",
3195 result = CURLE_PARTIAL_FILE;
3197 else if(!ftpc->dont_check &&
3198 !*ftp->bytecountp &&
3199 (data->req.size>0)) {
3200 failf(data, "No data was received!");
3201 result = CURLE_FTP_COULDNT_RETR_FILE;
3205 /* clear these for next connection */
3206 ftp->transfer = FTPTRANSFER_BODY;
3207 ftpc->dont_check = FALSE;
3209 /* Send any post-transfer QUOTE strings? */
3210 if(!status && !result && !premature && data->set.postquote)
3211 result = ftp_sendquote(conn, data->set.postquote);
3216 /***********************************************************************
3220 * Where a 'quote' means a list of custom commands to send to the server.
3221 * The quote list is passed as an argument.
3227 CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
3229 struct curl_slist *item;
3233 struct ftp_conn *ftpc = &conn->proto.ftpc;
3234 struct pingpong *pp = &ftpc->pp;
3239 char *cmd = item->data;
3240 bool acceptfail = FALSE;
3242 /* if a command starts with an asterisk, which a legal FTP command never
3243 can, the command will be allowed to fail without it causing any
3244 aborts or cancels etc. It will cause libcurl to act as if the command
3245 is successful, whatever the server reponds. */
3252 FTPSENDF(conn, "%s", cmd);
3254 pp->response = Curl_tvnow(); /* timeout relative now */
3256 result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
3260 if(!acceptfail && (ftpcode >= 400)) {
3261 failf(conn->data, "QUOT string not accepted: %s", cmd);
3262 return CURLE_QUOTE_ERROR;
3272 /***********************************************************************
3276 * Returns TRUE if we in the current situation should send TYPE
3278 static int ftp_need_type(struct connectdata *conn,
3281 return conn->proto.ftpc.transfertype != (ascii_wanted?'A':'I');
3284 /***********************************************************************
3288 * Set TYPE. We only deal with ASCII or BINARY so this function
3290 * If the transfer type is not sent, simulate on OK response in newstate
3292 static CURLcode ftp_nb_type(struct connectdata *conn,
3293 bool ascii, ftpstate newstate)
3295 struct ftp_conn *ftpc = &conn->proto.ftpc;
3297 char want = (char)(ascii?'A':'I');
3299 if(ftpc->transfertype == want) {
3300 state(conn, newstate);
3301 return ftp_state_type_resp(conn, 200, newstate);
3304 PPSENDF(&ftpc->pp, "TYPE %c", want);
3305 state(conn, newstate);
3307 /* keep track of our current transfer type */
3308 ftpc->transfertype = want;
3312 /***************************************************************************
3314 * ftp_pasv_verbose()
3316 * This function only outputs some informationals about this second connection
3317 * when we've issued a PASV command before and thus we have connected to a
3318 * possibly new IP address.
3321 #ifndef CURL_DISABLE_VERBOSE_STRINGS
3323 ftp_pasv_verbose(struct connectdata *conn,
3325 char *newhost, /* ascii version */
3329 Curl_printable_address(ai, buf, sizeof(buf));
3330 infof(conn->data, "Connecting to %s (%s) port %d\n", newhost, buf, port);
3335 Check if this is a range download, and if so, set the internal variables
3339 static CURLcode ftp_range(struct connectdata *conn)
3341 curl_off_t from, to;
3344 struct SessionHandle *data = conn->data;
3345 struct ftp_conn *ftpc = &conn->proto.ftpc;
3347 if(data->state.use_range && data->state.range) {
3348 from=curlx_strtoofft(data->state.range, &ptr, 0);
3349 while(*ptr && (ISSPACE(*ptr) || (*ptr=='-')))
3351 to=curlx_strtoofft(ptr, &ptr2, 0);
3353 /* we didn't get any digit */
3356 if((-1 == to) && (from>=0)) {
3358 data->state.resume_from = from;
3359 DEBUGF(infof(conn->data, "FTP RANGE %" FORMAT_OFF_T " to end of file\n",
3364 data->req.maxdownload = -from;
3365 data->state.resume_from = from;
3366 DEBUGF(infof(conn->data, "FTP RANGE the last %" FORMAT_OFF_T " bytes\n",
3371 data->req.maxdownload = (to-from)+1; /* include last byte */
3372 data->state.resume_from = from;
3373 DEBUGF(infof(conn->data, "FTP RANGE from %" FORMAT_OFF_T
3374 " getting %" FORMAT_OFF_T " bytes\n",
3375 from, data->req.maxdownload));
3377 DEBUGF(infof(conn->data, "range-download from %" FORMAT_OFF_T
3378 " to %" FORMAT_OFF_T ", totally %" FORMAT_OFF_T " bytes\n",
3379 from, to, data->req.maxdownload));
3380 ftpc->dont_check = TRUE; /* dont check for successful transfer */
3383 data->req.maxdownload = -1;
3391 * This function shall be called when the second FTP (data) connection is
3395 static CURLcode ftp_nextconnect(struct connectdata *conn)
3397 struct SessionHandle *data=conn->data;
3398 struct ftp_conn *ftpc = &conn->proto.ftpc;
3399 CURLcode result = CURLE_OK;
3401 /* the ftp struct is inited in ftp_connect() */
3402 struct FTP *ftp = data->state.proto.ftp;
3404 DEBUGF(infof(data, "DO-MORE phase starts\n"));
3406 if(ftp->transfer <= FTPTRANSFER_INFO) {
3407 /* a transfer is about to take place, or if not a file name was given
3408 so we'll do a SIZE on it later and then we need the right TYPE first */
3410 if(data->set.upload) {
3411 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_STOR_TYPE);
3417 ftp->downloadsize = -1; /* unknown as of yet */
3419 result = ftp_range(conn);
3422 else if(data->set.ftp_list_only || !ftpc->file) {
3423 /* The specified path ends with a slash, and therefore we think this
3424 is a directory that is requested, use LIST. But before that we
3425 need to set ASCII transfer mode. */
3427 /* But only if a body transfer was requested. */
3428 if(ftp->transfer == FTPTRANSFER_BODY) {
3429 result = ftp_nb_type(conn, TRUE, FTP_LIST_TYPE);
3433 /* otherwise just fall through */
3436 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_RETR_TYPE);
3441 result = ftp_easy_statemach(conn);
3444 if((result == CURLE_OK) && (ftp->transfer != FTPTRANSFER_BODY))
3445 /* no data to transfer. FIX: it feels like a kludge to have this here
3447 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
3449 /* end of transfer */
3450 DEBUGF(infof(data, "DO-MORE phase ends with %d\n", (int)result));
3457 /***********************************************************************
3461 * This is the actual DO function for FTP. Get a file/directory according to
3462 * the options previously setup.
3466 CURLcode ftp_perform(struct connectdata *conn,
3467 bool *connected, /* connect status after PASV / PORT */
3470 /* this is FTP and no proxy */
3471 CURLcode result=CURLE_OK;
3473 DEBUGF(infof(conn->data, "DO phase starts\n"));
3475 if(conn->data->set.opt_no_body) {
3476 /* requested no body means no transfer... */
3477 struct FTP *ftp = conn->data->state.proto.ftp;
3478 ftp->transfer = FTPTRANSFER_INFO;
3482 *dophase_done = FALSE; /* not done yet */
3484 /* start the first command in the DO phase */
3485 result = ftp_state_quote(conn, TRUE, FTP_QUOTE);
3489 /* run the state-machine */
3490 if(conn->data->state.used_interface == Curl_if_multi)
3491 result = ftp_multi_statemach(conn, dophase_done);
3493 result = ftp_easy_statemach(conn);
3494 *dophase_done = TRUE; /* with the easy interface we are done here */
3496 *connected = conn->bits.tcpconnect[FIRSTSOCKET];
3499 DEBUGF(infof(conn->data, "DO phase is complete\n"));
3504 static void wc_data_dtor(void *ptr)
3506 struct ftp_wc_tmpdata *tmp = ptr;
3508 Curl_ftp_parselist_data_free(&tmp->parser);
3512 static CURLcode init_wc_data(struct connectdata *conn)
3515 char *path = conn->data->state.path;
3516 struct WildcardData *wildcard = &(conn->data->wildcard);
3517 CURLcode ret = CURLE_OK;
3518 struct ftp_wc_tmpdata *ftp_tmp;
3520 last_slash = strrchr(conn->data->state.path, '/');
3523 if(last_slash[0] == '\0') {
3524 wildcard->state = CURLWC_CLEAN;
3525 ret = ftp_parse_url_path(conn);
3529 wildcard->pattern = strdup(last_slash);
3530 if(!wildcard->pattern)
3531 return CURLE_OUT_OF_MEMORY;
3532 last_slash[0] = '\0'; /* cut file from path */
3535 else { /* there is only 'wildcard pattern' or nothing */
3537 wildcard->pattern = strdup(path);
3538 if(!wildcard->pattern)
3539 return CURLE_OUT_OF_MEMORY;
3542 else { /* only list */
3543 wildcard->state = CURLWC_CLEAN;
3544 ret = ftp_parse_url_path(conn);
3549 /* program continues only if URL is not ending with slash, allocate needed
3550 resources for wildcard transfer */
3552 /* allocate ftp protocol specific temporary wildcard data */
3553 ftp_tmp = malloc(sizeof(struct ftp_wc_tmpdata));
3555 return CURLE_OUT_OF_MEMORY;
3558 /* INITIALIZE parselist structure */
3559 ftp_tmp->parser = Curl_ftp_parselist_data_alloc();
3560 if(!ftp_tmp->parser) {
3562 return CURLE_OUT_OF_MEMORY;
3565 wildcard->tmp = ftp_tmp; /* put it to the WildcardData tmp pointer */
3566 wildcard->tmp_dtor = wc_data_dtor;
3568 /* wildcard does not support NOCWD option (assert it?) */
3569 if(conn->data->set.ftp_filemethod == FTPFILE_NOCWD)
3570 conn->data->set.ftp_filemethod = FTPFILE_MULTICWD;
3572 /* try to parse ftp url */
3573 ret = ftp_parse_url_path(conn);
3578 /* backup old write_function */
3579 ftp_tmp->backup.write_function = conn->data->set.fwrite_func;
3580 /* parsing write function */
3581 conn->data->set.fwrite_func = Curl_ftp_parselist;
3582 /* backup old file descriptor */
3583 ftp_tmp->backup.file_descriptor = conn->data->set.out;
3584 /* let the writefunc callback know what curl pointer is working with */
3585 conn->data->set.out = conn;
3587 wildcard->path = strdup(conn->data->state.path);
3588 if(!wildcard->path) {
3589 return CURLE_OUT_OF_MEMORY;
3592 infof(conn->data, "Wildcard - Parsing started\n");
3596 /* This is called recursively */
3597 static CURLcode wc_statemach(struct connectdata *conn)
3599 struct WildcardData * const wildcard = &(conn->data->wildcard);
3600 CURLcode ret = CURLE_OK;
3602 switch (wildcard->state) {
3604 ret = init_wc_data(conn);
3605 if(wildcard->state == CURLWC_CLEAN)
3609 wildcard->state = ret ? CURLWC_ERROR : CURLWC_MATCHING;
3612 case CURLWC_MATCHING: {
3613 /* In this state is LIST response successfully parsed, so lets restore
3614 previous WRITEFUNCTION callback and WRITEDATA pointer */
3615 struct ftp_wc_tmpdata *ftp_tmp = wildcard->tmp;
3616 conn->data->set.fwrite_func = ftp_tmp->backup.write_function;
3617 conn->data->set.out = ftp_tmp->backup.file_descriptor;
3618 wildcard->state = CURLWC_DOWNLOADING;
3620 if(Curl_ftp_parselist_geterror(ftp_tmp->parser)) {
3621 /* error found in LIST parsing */
3622 wildcard->state = CURLWC_CLEAN;
3623 return wc_statemach(conn);
3625 else if(wildcard->filelist->size == 0) {
3626 /* no corresponding file */
3627 wildcard->state = CURLWC_CLEAN;
3628 return CURLE_REMOTE_FILE_NOT_FOUND;
3630 return wc_statemach(conn);
3633 case CURLWC_DOWNLOADING: {
3634 /* filelist has at least one file, lets get first one */
3635 struct ftp_conn *ftpc = &conn->proto.ftpc;
3636 struct curl_fileinfo *finfo = wildcard->filelist->head->ptr;
3637 char *tmp_path = malloc(strlen(conn->data->state.path) +
3638 strlen(finfo->filename) + 1);
3640 return CURLE_OUT_OF_MEMORY;
3644 /* make full path to matched file */
3645 strcat(tmp_path, wildcard->path);
3646 strcat(tmp_path, finfo->filename);
3647 /* switch default "state.pathbuffer" and tmp_path, good to see
3648 ftp_parse_url_path function to understand this trick */
3649 if(conn->data->state.pathbuffer)
3650 free(conn->data->state.pathbuffer);
3651 conn->data->state.pathbuffer = tmp_path;
3652 conn->data->state.path = tmp_path;
3654 infof(conn->data, "Wildcard - START of \"%s\"\n", finfo->filename);
3655 if(conn->data->set.chunk_bgn) {
3656 long userresponse = conn->data->set.chunk_bgn(
3657 finfo, wildcard->customptr, (int)wildcard->filelist->size);
3658 switch(userresponse) {
3659 case CURL_CHUNK_BGN_FUNC_SKIP:
3660 infof(conn->data, "Wildcard - \"%s\" skipped by user\n",
3662 wildcard->state = CURLWC_SKIP;
3663 return wc_statemach(conn);
3664 case CURL_CHUNK_BGN_FUNC_FAIL:
3665 return CURLE_CHUNK_FAILED;
3669 if(finfo->filetype != CURLFILETYPE_FILE) {
3670 wildcard->state = CURLWC_SKIP;
3671 return wc_statemach(conn);
3674 if(finfo->flags & CURLFINFOFLAG_KNOWN_SIZE)
3675 ftpc->known_filesize = finfo->size;
3677 ret = ftp_parse_url_path(conn);
3682 /* we don't need the Curl_fileinfo of first file anymore */
3683 Curl_llist_remove(wildcard->filelist, wildcard->filelist->head, NULL);
3685 if(wildcard->filelist->size == 0) { /* remains only one file to down. */
3686 wildcard->state = CURLWC_CLEAN;
3687 /* after that will be ftp_do called once again and no transfer
3688 will be done because of CURLWC_CLEAN state */
3694 if(conn->data->set.chunk_end)
3695 conn->data->set.chunk_end(conn->data->wildcard.customptr);
3696 Curl_llist_remove(wildcard->filelist, wildcard->filelist->head, NULL);
3697 wildcard->state = (wildcard->filelist->size == 0) ?
3698 CURLWC_CLEAN : CURLWC_DOWNLOADING;
3699 return wc_statemach(conn);
3702 case CURLWC_CLEAN: {
3703 struct ftp_wc_tmpdata *ftp_tmp = wildcard->tmp;
3706 ret = Curl_ftp_parselist_geterror(ftp_tmp->parser);
3708 wildcard->state = ret ? CURLWC_ERROR : CURLWC_DONE;
3719 /***********************************************************************
3723 * This function is registered as 'curl_do' function. It decodes the path
3724 * parts etc as a wrapper to the actual DO function (ftp_perform).
3726 * The input argument is already checked for validity.
3728 static CURLcode ftp_do(struct connectdata *conn, bool *done)
3730 CURLcode retcode = CURLE_OK;
3732 *done = FALSE; /* default to false */
3735 Since connections can be re-used between SessionHandles, this might be a
3736 connection already existing but on a fresh SessionHandle struct so we must
3737 make sure we have a good 'struct FTP' to play with. For new connections,
3738 the struct FTP is allocated and setup in the ftp_connect() function.
3740 Curl_reset_reqproto(conn);
3741 retcode = ftp_init(conn);
3745 if(conn->data->set.wildcardmatch) {
3746 retcode = wc_statemach(conn);
3747 if(conn->data->wildcard.state == CURLWC_SKIP ||
3748 conn->data->wildcard.state == CURLWC_DONE) {
3749 /* do not call ftp_regular_transfer */
3752 if(retcode) /* error, loop or skipping the file */
3755 else { /* no wildcard FSM needed */
3756 retcode = ftp_parse_url_path(conn);
3761 retcode = ftp_regular_transfer(conn, done);
3767 CURLcode Curl_ftpsendf(struct connectdata *conn,
3768 const char *fmt, ...)
3770 ssize_t bytes_written;
3771 #define SBUF_SIZE 1024
3775 CURLcode res = CURLE_OK;
3776 #if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)
3777 enum protection_level data_sec = conn->data_prot;
3782 vsnprintf(s, SBUF_SIZE-3, fmt, ap);
3785 strcat(s, "\r\n"); /* append a trailing CRLF */
3788 write_len = strlen(s);
3790 res = Curl_convert_to_network(conn->data, s, write_len);
3791 /* Curl_convert_to_network calls failf if unsuccessful */
3796 #if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)
3797 conn->data_prot = PROT_CMD;
3799 res = Curl_write(conn, conn->sock[FIRSTSOCKET], sptr, write_len,
3801 #if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)
3802 DEBUGASSERT(data_sec > PROT_NONE && data_sec < PROT_LAST);
3803 conn->data_prot = data_sec;
3809 if(conn->data->set.verbose)
3810 Curl_debug(conn->data, CURLINFO_HEADER_OUT,
3811 sptr, (size_t)bytes_written, conn);
3813 if(bytes_written != (ssize_t)write_len) {
3814 write_len -= bytes_written;
3815 sptr += bytes_written;
3824 /***********************************************************************
3828 * This should be called before calling sclose() on an ftp control connection
3829 * (not data connections). We should then wait for the response from the
3830 * server before returning. The calling code should then try to close the
3834 static CURLcode ftp_quit(struct connectdata *conn)
3836 CURLcode result = CURLE_OK;
3838 if(conn->proto.ftpc.ctl_valid) {
3839 PPSENDF(&conn->proto.ftpc.pp, "QUIT", NULL);
3840 state(conn, FTP_QUIT);
3842 result = ftp_easy_statemach(conn);
3848 /***********************************************************************
3852 * Disconnect from an FTP server. Cleanup protocol-specific per-connection
3853 * resources. BLOCKING.
3855 static CURLcode ftp_disconnect(struct connectdata *conn, bool dead_connection)
3857 struct ftp_conn *ftpc= &conn->proto.ftpc;
3858 struct pingpong *pp = &ftpc->pp;
3860 /* We cannot send quit unconditionally. If this connection is stale or
3861 bad in any way, sending quit and waiting around here will make the
3862 disconnect wait in vain and cause more problems than we need to.
3864 ftp_quit() will check the state of ftp->ctl_valid. If it's ok it
3865 will try to send the QUIT command, otherwise it will just return.
3868 ftpc->ctl_valid = FALSE;
3870 /* The FTP session may or may not have been allocated/setup at this point! */
3871 (void)ftp_quit(conn); /* ignore errors on the QUIT */
3873 if(ftpc->entrypath) {
3874 struct SessionHandle *data = conn->data;
3875 if(data->state.most_recent_ftp_entrypath == ftpc->entrypath) {
3876 data->state.most_recent_ftp_entrypath = NULL;
3878 free(ftpc->entrypath);
3879 ftpc->entrypath = NULL;
3883 if(ftpc->prevpath) {
3884 free(ftpc->prevpath);
3885 ftpc->prevpath = NULL;
3887 if(ftpc->server_os) {
3888 free(ftpc->server_os);
3889 ftpc->server_os = NULL;
3892 Curl_pp_disconnect(pp);
3894 #if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)
3901 /***********************************************************************
3903 * ftp_parse_url_path()
3905 * Parse the URL path into separate path components.
3909 CURLcode ftp_parse_url_path(struct connectdata *conn)
3911 struct SessionHandle *data = conn->data;
3912 /* the ftp struct is already inited in ftp_connect() */
3913 struct FTP *ftp = data->state.proto.ftp;
3914 struct ftp_conn *ftpc = &conn->proto.ftpc;
3915 const char *slash_pos; /* position of the first '/' char in curpos */
3916 const char *path_to_use = data->state.path;
3917 const char *cur_pos;
3918 const char *filename = NULL;
3920 cur_pos = path_to_use; /* current position in path. point at the begin
3921 of next path component */
3923 ftpc->ctl_valid = FALSE;
3924 ftpc->cwdfail = FALSE;
3926 switch(data->set.ftp_filemethod) {
3928 /* fastest, but less standard-compliant */
3931 The best time to check whether the path is a file or directory is right
3934 the first condition in the if() right here, is there just in case
3935 someone decides to set path to NULL one day
3937 if(data->state.path &&
3938 data->state.path[0] &&
3939 (data->state.path[strlen(data->state.path) - 1] != '/') )
3940 filename = data->state.path; /* this is a full file path */
3942 ftpc->file is not used anywhere other than for operations on a file.
3943 In other words, never for directory operations.
3944 So we can safely leave filename as NULL here and use it as a
3945 argument in dir/file decisions.
3949 case FTPFILE_SINGLECWD:
3950 /* get the last slash */
3951 if(!path_to_use[0]) {
3952 /* no dir, no file */
3956 slash_pos=strrchr(cur_pos, '/');
3957 if(slash_pos || !*cur_pos) {
3958 ftpc->dirs = calloc(1, sizeof(ftpc->dirs[0]));
3960 return CURLE_OUT_OF_MEMORY;
3962 ftpc->dirs[0] = curl_easy_unescape(conn->data, slash_pos ? cur_pos : "/",
3963 slash_pos?(int)(slash_pos-cur_pos):1,
3965 if(!ftpc->dirs[0]) {
3967 return CURLE_OUT_OF_MEMORY;
3969 ftpc->dirdepth = 1; /* we consider it to be a single dir */
3970 filename = slash_pos ? slash_pos+1 : cur_pos; /* rest is file name */
3973 filename = cur_pos; /* this is a file name only */
3976 default: /* allow pretty much anything */
3977 case FTPFILE_MULTICWD:
3979 ftpc->diralloc = 5; /* default dir depth to allocate */
3980 ftpc->dirs = calloc(ftpc->diralloc, sizeof(ftpc->dirs[0]));
3982 return CURLE_OUT_OF_MEMORY;
3984 /* we have a special case for listing the root dir only */
3985 if(strequal(path_to_use, "/")) {
3986 cur_pos++; /* make it point to the zero byte */
3987 ftpc->dirs[0] = strdup("/");
3991 /* parse the URL path into separate path components */
3992 while((slash_pos = strchr(cur_pos, '/')) != NULL) {
3993 /* 1 or 0 pointer offset to indicate absolute directory */
3994 ssize_t absolute_dir = ((cur_pos - data->state.path > 0) &&
3995 (ftpc->dirdepth == 0))?1:0;
3997 /* seek out the next path component */
3998 if(slash_pos-cur_pos) {
3999 /* we skip empty path components, like "x//y" since the FTP command
4000 CWD requires a parameter and a non-existent parameter a) doesn't
4001 work on many servers and b) has no effect on the others. */
4002 int len = (int)(slash_pos - cur_pos + absolute_dir);
4003 ftpc->dirs[ftpc->dirdepth] =
4004 curl_easy_unescape(conn->data, cur_pos - absolute_dir, len, NULL);
4005 if(!ftpc->dirs[ftpc->dirdepth]) { /* run out of memory ... */
4006 failf(data, "no memory");
4008 return CURLE_OUT_OF_MEMORY;
4010 if(isBadFtpString(ftpc->dirs[ftpc->dirdepth])) {
4011 free(ftpc->dirs[ftpc->dirdepth]);
4013 return CURLE_URL_MALFORMAT;
4017 cur_pos = slash_pos + 1; /* jump to the rest of the string */
4021 cur_pos = slash_pos + 1; /* jump to the rest of the string */
4022 if(++ftpc->dirdepth >= ftpc->diralloc) {
4025 ftpc->diralloc *= 2; /* double the size each time */
4026 bigger = realloc(ftpc->dirs, ftpc->diralloc * sizeof(ftpc->dirs[0]));
4029 return CURLE_OUT_OF_MEMORY;
4031 ftpc->dirs = bigger;
4035 filename = cur_pos; /* the rest is the file name */
4039 if(filename && *filename) {
4040 ftpc->file = curl_easy_unescape(conn->data, filename, 0, NULL);
4041 if(NULL == ftpc->file) {
4043 failf(data, "no memory");
4044 return CURLE_OUT_OF_MEMORY;
4046 if(isBadFtpString(ftpc->file)) {
4048 return CURLE_URL_MALFORMAT;
4052 ftpc->file=NULL; /* instead of point to a zero byte, we make it a NULL
4055 if(data->set.upload && !ftpc->file && (ftp->transfer == FTPTRANSFER_BODY)) {
4056 /* We need a file name when uploading. Return error! */
4057 failf(data, "Uploading to a URL without a file name!");
4058 return CURLE_URL_MALFORMAT;
4061 ftpc->cwddone = FALSE; /* default to not done */
4063 if(ftpc->prevpath) {
4064 /* prevpath is "raw" so we convert the input path before we compare the
4067 char *path = curl_easy_unescape(conn->data, data->state.path, 0, &dlen);
4070 return CURLE_OUT_OF_MEMORY;
4073 dlen -= ftpc->file?(int)strlen(ftpc->file):0;
4074 if((dlen == (int)strlen(ftpc->prevpath)) &&
4075 strnequal(path, ftpc->prevpath, dlen)) {
4076 infof(data, "Request has same path as previous transfer\n");
4077 ftpc->cwddone = TRUE;
4085 /* call this when the DO phase has completed */
4086 static CURLcode ftp_dophase_done(struct connectdata *conn,
4089 CURLcode result = CURLE_OK;
4090 struct FTP *ftp = conn->data->state.proto.ftp;
4091 struct ftp_conn *ftpc = &conn->proto.ftpc;
4094 result = ftp_nextconnect(conn);
4096 if(result && (conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD)) {
4097 /* Failure detected, close the second socket if it was created already */
4098 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
4099 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
4103 if(ftp->transfer != FTPTRANSFER_BODY)
4104 /* no data to transfer */
4105 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
4107 /* since we didn't connect now, we want do_more to get called */
4108 conn->bits.do_more = TRUE;
4110 ftpc->ctl_valid = TRUE; /* seems good */
4115 /* called from multi.c while DOing */
4116 static CURLcode ftp_doing(struct connectdata *conn,
4119 CURLcode result = ftp_multi_statemach(conn, dophase_done);
4122 DEBUGF(infof(conn->data, "DO phase failed\n"));
4123 else if(*dophase_done) {
4124 result = ftp_dophase_done(conn, FALSE /* not connected */);
4126 DEBUGF(infof(conn->data, "DO phase is complete\n"));
4131 /***********************************************************************
4133 * ftp_regular_transfer()
4135 * The input argument is already checked for validity.
4137 * Performs all commands done before a regular transfer between a local and a
4140 * ftp->ctl_valid starts out as FALSE, and gets set to TRUE if we reach the
4141 * ftp_done() function without finding any major problem.
4144 CURLcode ftp_regular_transfer(struct connectdata *conn,
4147 CURLcode result=CURLE_OK;
4148 bool connected=FALSE;
4149 struct SessionHandle *data = conn->data;
4150 struct ftp_conn *ftpc = &conn->proto.ftpc;
4151 data->req.size = -1; /* make sure this is unknown at this point */
4153 Curl_pgrsSetUploadCounter(data, 0);
4154 Curl_pgrsSetDownloadCounter(data, 0);
4155 Curl_pgrsSetUploadSize(data, 0);
4156 Curl_pgrsSetDownloadSize(data, 0);
4158 ftpc->ctl_valid = TRUE; /* starts good */
4160 result = ftp_perform(conn,
4161 &connected, /* have we connected after PASV/PORT */
4162 dophase_done); /* all commands in the DO-phase done? */
4164 if(CURLE_OK == result) {
4167 /* the DO phase has not completed yet */
4170 result = ftp_dophase_done(conn, connected);
4180 static CURLcode ftp_setup_connection(struct connectdata * conn)
4182 struct SessionHandle *data = conn->data;
4186 if(conn->bits.httpproxy && !data->set.tunnel_thru_httpproxy) {
4187 /* Unless we have asked to tunnel ftp operations through the proxy, we
4188 switch and use HTTP operations only */
4189 #ifndef CURL_DISABLE_HTTP
4190 if(conn->handler == &Curl_handler_ftp)
4191 conn->handler = &Curl_handler_ftp_proxy;
4194 conn->handler = &Curl_handler_ftps_proxy;
4196 failf(data, "FTPS not supported!");
4197 return CURLE_UNSUPPORTED_PROTOCOL;
4201 * We explicitly mark this connection as persistent here as we're doing
4202 * FTP over HTTP and thus we accidentally avoid setting this value
4205 conn->bits.close = FALSE;
4207 failf(data, "FTP over http proxy requires HTTP support built-in!");
4208 return CURLE_UNSUPPORTED_PROTOCOL;
4212 data->state.path++; /* don't include the initial slash */
4213 data->state.slash_removed = TRUE; /* we've skipped the slash */
4215 /* FTP URLs support an extension like ";type=<typecode>" that
4216 * we'll try to get now! */
4217 type = strstr(data->state.path, ";type=");
4220 type = strstr(conn->host.rawalloc, ";type=");
4223 *type = 0; /* it was in the middle of the hostname */
4224 command = Curl_raw_toupper(type[6]);
4225 conn->bits.type_set = TRUE;
4228 case 'A': /* ASCII mode */
4229 data->set.prefer_ascii = TRUE;
4232 case 'D': /* directory mode */
4233 data->set.ftp_list_only = TRUE;
4236 case 'I': /* binary mode */
4238 /* switch off ASCII */
4239 data->set.prefer_ascii = FALSE;
4247 #endif /* CURL_DISABLE_FTP */