2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
6 This file is part of GNU Wget.
8 GNU Wget is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 GNU Wget is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Wget. If not, see <http://www.gnu.org/licenses/>.
21 Additional permission under GNU GPL version 3 section 7
23 If you modify this program, or any covered work, by linking or
24 combining it with the OpenSSL project's OpenSSL library (or a
25 modified version of that library), containing parts covered by the
26 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
27 grants you additional permission to convey the resulting work.
28 Corresponding Source for a non-source form of such a combination
29 shall include the source code for the parts of OpenSSL used as well
30 as that of the covered work. */
47 char ftp_last_respline[128];
50 /* Get the response of FTP server and allocate enough room to handle
51 it. <CR> and <LF> characters are stripped from the line, and the
52 line is 0-terminated. All the response lines but the last one are
53 skipped. The last line is determined as described in RFC959.
55 If the line is successfully read, FTPOK is returned, and *ret_line
56 is assigned a freshly allocated line. Otherwise, FTPRERR is
57 returned, and the value of *ret_line should be ignored. */
60 ftp_response (int fd, char **ret_line)
65 char *line = fd_read_line (fd);
69 /* Strip trailing CRLF before printing the line, so that
70 quotting doesn't include bogus \012 and \015. */
71 p = strchr (line, '\0');
72 if (p > line && p[-1] == '\n')
74 if (p > line && p[-1] == '\r')
77 if (opt.server_response)
78 logprintf (LOG_NOTQUIET, "%s\n",
79 quotearg_style (escape_quoting_style, line));
81 DEBUGP (("%s\n", quotearg_style (escape_quoting_style, line)));
83 /* The last line of output is the one that begins with "ddd ". */
84 if (c_isdigit (line[0]) && c_isdigit (line[1]) && c_isdigit (line[2])
87 strncpy (ftp_last_respline, line, sizeof (ftp_last_respline));
88 ftp_last_respline[sizeof (ftp_last_respline) - 1] = '\0';
96 /* Returns the malloc-ed FTP request, ending with <CR><LF>, printing
97 it if printing is required. If VALUE is NULL, just use
100 ftp_request (const char *command, const char *value)
105 /* Check for newlines in VALUE (possibly injected by the %0A URL
106 escape) making the callers inadvertently send multiple FTP
107 commands at once. Without this check an attacker could
108 intentionally redirect to ftp://server/fakedir%0Acommand.../
109 and execute arbitrary FTP command on a remote FTP server. */
110 if (strpbrk (value, "\r\n"))
112 /* Copy VALUE to the stack and modify CR/LF to space. */
114 STRDUP_ALLOCA (defanged, value);
115 for (p = defanged; *p; p++)
116 if (*p == '\r' || *p == '\n')
118 DEBUGP (("\nDetected newlines in %s \"%s\"; changing to %s \"%s\"\n",
119 command, quotearg_style (escape_quoting_style, value),
120 command, quotearg_style (escape_quoting_style, defanged)));
121 /* Make VALUE point to the defanged copy of the string. */
124 res = concat_strings (command, " ", value, "\r\n", (char *) 0);
127 res = concat_strings (command, "\r\n", (char *) 0);
128 if (opt.server_response)
130 /* Hack: don't print out password. */
131 if (strncmp (res, "PASS", 4) != 0)
132 logprintf (LOG_ALWAYS, "--> %s\n", res);
134 logputs (LOG_ALWAYS, "--> PASS Turtle Power!\n\n");
137 DEBUGP (("\n--> %s\n", res));
141 /* Sends the USER and PASS commands to the server, to control
142 connection socket csock. */
144 ftp_login (int csock, const char *acc, const char *pass)
147 char *request, *respline;
151 err = ftp_response (csock, &respline);
154 if (*respline != '2')
160 /* Send USER username. */
161 request = ftp_request ("USER", acc);
162 nwritten = fd_write (csock, request, strlen (request), -1);
169 /* Get appropriate response. */
170 err = ftp_response (csock, &respline);
173 /* An unprobable possibility of logging without a password. */
174 if (*respline == '2')
179 /* Else, only response 3 is appropriate. */
180 if (*respline != '3')
183 return FTPLOGREFUSED;
187 static const char *skey_head[] = {
192 const char *seed = NULL;
194 for (i = 0; i < countof (skey_head); i++)
196 int l = strlen (skey_head[i]);
197 if (0 == strncasecmp (skey_head[i], respline, l))
205 int skey_sequence = 0;
207 /* Extract the sequence from SEED. */
208 for (; c_isdigit (*seed); seed++)
209 skey_sequence = 10 * skey_sequence + *seed - '0';
215 return FTPLOGREFUSED;
217 /* Replace the password with the SKEY response to the
219 pass = skey_response (skey_sequence, seed, pass);
222 #endif /* ENABLE_OPIE */
224 /* Send PASS password. */
225 request = ftp_request ("PASS", pass);
226 nwritten = fd_write (csock, request, strlen (request), -1);
233 /* Get appropriate response. */
234 err = ftp_response (csock, &respline);
237 if (*respline != '2')
248 ip_address_to_port_repr (const ip_address *addr, int port, char *buf,
253 assert (addr->family == AF_INET);
254 /* buf must contain the argument of PORT (of the form a,b,c,d,e,f). */
255 assert (buflen >= 6 * 4);
257 ptr = IP_INADDR_DATA (addr);
258 snprintf (buf, buflen, "%d,%d,%d,%d,%d,%d", ptr[0], ptr[1],
259 ptr[2], ptr[3], (port & 0xff00) >> 8, port & 0xff);
260 buf[buflen - 1] = '\0';
263 /* Bind a port and send the appropriate PORT command to the FTP
264 server. Use acceptport after RETR, to get the socket of data
267 ftp_port (int csock, int *local_sock)
270 char *request, *respline;
274 /* Must contain the argument of PORT (of the form a,b,c,d,e,f). */
275 char bytes[6 * 4 + 1];
277 /* Get the address of this side of the connection. */
278 if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
281 assert (addr.family == AF_INET);
283 /* Setting port to 0 lets the system choose a free port. */
287 *local_sock = bind_local (&addr, &port);
291 /* Construct the argument of PORT (of the form a,b,c,d,e,f). */
292 ip_address_to_port_repr (&addr, port, bytes, sizeof (bytes));
294 /* Send PORT request. */
295 request = ftp_request ("PORT", bytes);
296 nwritten = fd_write (csock, request, strlen (request), -1);
300 fd_close (*local_sock);
305 /* Get appropriate response. */
306 err = ftp_response (csock, &respline);
309 fd_close (*local_sock);
312 if (*respline != '2')
315 fd_close (*local_sock);
324 ip_address_to_lprt_repr (const ip_address *addr, int port, char *buf,
327 unsigned char *ptr = IP_INADDR_DATA (addr);
329 /* buf must contain the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
330 assert (buflen >= 21 * 4);
332 /* Construct the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
333 switch (addr->family)
336 snprintf (buf, buflen, "%d,%d,%d,%d,%d,%d,%d,%d,%d", 4, 4,
337 ptr[0], ptr[1], ptr[2], ptr[3], 2,
338 (port & 0xff00) >> 8, port & 0xff);
341 snprintf (buf, buflen,
342 "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
344 ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7],
345 ptr[8], ptr[9], ptr[10], ptr[11], ptr[12], ptr[13], ptr[14], ptr[15],
346 2, (port & 0xff00) >> 8, port & 0xff);
353 /* Bind a port and send the appropriate PORT command to the FTP
354 server. Use acceptport after RETR, to get the socket of data
357 ftp_lprt (int csock, int *local_sock)
360 char *request, *respline;
364 /* Must contain the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
365 char bytes[21 * 4 + 1];
367 /* Get the address of this side of the connection. */
368 if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
371 assert (addr.family == AF_INET || addr.family == AF_INET6);
373 /* Setting port to 0 lets the system choose a free port. */
377 *local_sock = bind_local (&addr, &port);
381 /* Construct the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
382 ip_address_to_lprt_repr (&addr, port, bytes, sizeof (bytes));
384 /* Send PORT request. */
385 request = ftp_request ("LPRT", bytes);
386 nwritten = fd_write (csock, request, strlen (request), -1);
390 fd_close (*local_sock);
394 /* Get appropriate response. */
395 err = ftp_response (csock, &respline);
398 fd_close (*local_sock);
401 if (*respline != '2')
404 fd_close (*local_sock);
412 ip_address_to_eprt_repr (const ip_address *addr, int port, char *buf,
417 /* buf must contain the argument of EPRT (of the form |af|addr|port|).
418 * 4 chars for the | separators, INET6_ADDRSTRLEN chars for addr
419 * 1 char for af (1-2) and 5 chars for port (0-65535) */
420 assert (buflen >= 4 + INET6_ADDRSTRLEN + 1 + 5);
422 /* Construct the argument of EPRT (of the form |af|addr|port|). */
423 afnum = (addr->family == AF_INET ? 1 : 2);
424 snprintf (buf, buflen, "|%d|%s|%d|", afnum, print_address (addr), port);
425 buf[buflen - 1] = '\0';
428 /* Bind a port and send the appropriate PORT command to the FTP
429 server. Use acceptport after RETR, to get the socket of data
432 ftp_eprt (int csock, int *local_sock)
435 char *request, *respline;
439 /* Must contain the argument of EPRT (of the form |af|addr|port|).
440 * 4 chars for the | separators, INET6_ADDRSTRLEN chars for addr
441 * 1 char for af (1-2) and 5 chars for port (0-65535) */
442 char bytes[4 + INET6_ADDRSTRLEN + 1 + 5 + 1];
444 /* Get the address of this side of the connection. */
445 if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
448 /* Setting port to 0 lets the system choose a free port. */
452 *local_sock = bind_local (&addr, &port);
456 /* Construct the argument of EPRT (of the form |af|addr|port|). */
457 ip_address_to_eprt_repr (&addr, port, bytes, sizeof (bytes));
459 /* Send PORT request. */
460 request = ftp_request ("EPRT", bytes);
461 nwritten = fd_write (csock, request, strlen (request), -1);
465 fd_close (*local_sock);
469 /* Get appropriate response. */
470 err = ftp_response (csock, &respline);
473 fd_close (*local_sock);
476 if (*respline != '2')
479 fd_close (*local_sock);
487 /* Similar to ftp_port, but uses `PASV' to initiate the passive FTP
488 transfer. Reads the response from server and parses it. Reads the
489 host and port addresses and returns them. */
491 ftp_pasv (int csock, ip_address *addr, int *port)
493 char *request, *respline, *s;
496 unsigned char tmp[6];
498 assert (addr != NULL);
499 assert (port != NULL);
503 /* Form the request. */
504 request = ftp_request ("PASV", NULL);
506 nwritten = fd_write (csock, request, strlen (request), -1);
513 /* Get the server response. */
514 err = ftp_response (csock, &respline);
517 if (*respline != '2')
522 /* Parse the request. */
524 for (s += 4; *s && !c_isdigit (*s); s++)
531 for (i = 0; i < 6; i++)
534 for (; c_isdigit (*s); s++)
535 tmp[i] = (*s - '0') + 10 * tmp[i];
540 /* When on the last number, anything can be a terminator. */
547 addr->family = AF_INET;
548 memcpy (IP_INADDR_DATA (addr), tmp, 4);
549 *port = ((tmp[4] << 8) & 0xff00) + tmp[5];
555 /* Similar to ftp_lprt, but uses `LPSV' to initiate the passive FTP
556 transfer. Reads the response from server and parses it. Reads the
557 host and port addresses and returns them. */
559 ftp_lpsv (int csock, ip_address *addr, int *port)
561 char *request, *respline, *s;
562 int nwritten, i, af, addrlen, portlen;
564 unsigned char tmp[16];
565 unsigned char tmpprt[2];
567 assert (addr != NULL);
568 assert (port != NULL);
572 /* Form the request. */
573 request = ftp_request ("LPSV", NULL);
576 nwritten = fd_write (csock, request, strlen (request), -1);
584 /* Get the server response. */
585 err = ftp_response (csock, &respline);
588 if (*respline != '2')
594 /* Parse the response. */
596 for (s += 4; *s && !c_isdigit (*s); s++)
604 /* First, get the address family */
606 for (; c_isdigit (*s); s++)
607 af = (*s - '0') + 10 * af;
609 if (af != 4 && af != 6)
615 if (!*s || *s++ != ',')
621 /* Then, get the address length */
623 for (; c_isdigit (*s); s++)
624 addrlen = (*s - '0') + 10 * addrlen;
626 if (!*s || *s++ != ',')
638 if ((af == 4 && addrlen != 4)
639 || (af == 6 && addrlen != 16))
645 /* Now, we get the actual address */
646 for (i = 0; i < addrlen; i++)
649 for (; c_isdigit (*s); s++)
650 tmp[i] = (*s - '0') + 10 * tmp[i];
660 /* Now, get the port length */
662 for (; c_isdigit (*s); s++)
663 portlen = (*s - '0') + 10 * portlen;
665 if (!*s || *s++ != ',')
677 /* Finally, we get the port number */
679 for (; c_isdigit (*s); s++)
680 tmpprt[0] = (*s - '0') + 10 * tmpprt[0];
682 if (!*s || *s++ != ',')
689 for (; c_isdigit (*s); s++)
690 tmpprt[1] = (*s - '0') + 10 * tmpprt[1];
696 addr->family = AF_INET;
697 memcpy (IP_INADDR_DATA (addr), tmp, 4);
698 *port = ((tmpprt[0] << 8) & 0xff00) + tmpprt[1];
699 DEBUGP (("lpsv addr is: %s\n", print_address(addr)));
700 DEBUGP (("tmpprt[0] is: %d\n", tmpprt[0]));
701 DEBUGP (("tmpprt[1] is: %d\n", tmpprt[1]));
702 DEBUGP (("*port is: %d\n", *port));
707 addr->family = AF_INET6;
708 memcpy (IP_INADDR_DATA (addr), tmp, 16);
709 *port = ((tmpprt[0] << 8) & 0xff00) + tmpprt[1];
710 DEBUGP (("lpsv addr is: %s\n", print_address(addr)));
711 DEBUGP (("tmpprt[0] is: %d\n", tmpprt[0]));
712 DEBUGP (("tmpprt[1] is: %d\n", tmpprt[1]));
713 DEBUGP (("*port is: %d\n", *port));
720 /* Similar to ftp_eprt, but uses `EPSV' to initiate the passive FTP
721 transfer. Reads the response from server and parses it. Reads the
722 host and port addresses and returns them. */
724 ftp_epsv (int csock, ip_address *ip, int *port)
726 char *request, *respline, *start, delim, *s;
732 assert (port != NULL);
734 /* IP already contains the IP address of the control connection's
735 peer, so we don't need to call socket_ip_address here. */
737 /* Form the request. */
738 /* EPSV 1 means that we ask for IPv4 and EPSV 2 means that we ask for IPv6. */
739 request = ftp_request ("EPSV", (ip->family == AF_INET ? "1" : "2"));
742 nwritten = fd_write (csock, request, strlen (request), -1);
750 /* Get the server response. */
751 err = ftp_response (csock, &respline);
754 if (*respline != '2')
760 assert (respline != NULL);
762 DEBUGP(("respline is %s\n", respline));
764 /* Skip the useless stuff and get what's inside the parentheses */
765 start = strchr (respline, '(');
772 /* Skip the first two void fields */
775 if (delim < 33 || delim > 126)
781 for (i = 0; i < 2; i++)
790 /* Finally, get the port number */
792 for (i = 1; c_isdigit (*s); s++)
799 tport = (*s - '0') + 10 * tport;
802 /* Make sure that the response terminates correcty */
822 /* Sends the TYPE request to the server. */
824 ftp_type (int csock, int type)
826 char *request, *respline;
831 /* Construct argument. */
834 /* Send TYPE request. */
835 request = ftp_request ("TYPE", stype);
836 nwritten = fd_write (csock, request, strlen (request), -1);
843 /* Get appropriate response. */
844 err = ftp_response (csock, &respline);
847 if (*respline != '2')
850 return FTPUNKNOWNTYPE;
857 /* Changes the working directory by issuing a CWD command to the
860 ftp_cwd (int csock, const char *dir)
862 char *request, *respline;
866 /* Send CWD request. */
867 request = ftp_request ("CWD", dir);
868 nwritten = fd_write (csock, request, strlen (request), -1);
875 /* Get appropriate response. */
876 err = ftp_response (csock, &respline);
879 if (*respline == '5')
884 if (*respline != '2')
894 /* Sends REST command to the FTP server. */
896 ftp_rest (int csock, wgint offset)
898 char *request, *respline;
902 request = ftp_request ("REST", number_to_static_string (offset));
903 nwritten = fd_write (csock, request, strlen (request), -1);
910 /* Get appropriate response. */
911 err = ftp_response (csock, &respline);
914 if (*respline != '3')
924 /* Sends RETR command to the FTP server. */
926 ftp_retr (int csock, const char *file)
928 char *request, *respline;
932 /* Send RETR request. */
933 request = ftp_request ("RETR", file);
934 nwritten = fd_write (csock, request, strlen (request), -1);
941 /* Get appropriate response. */
942 err = ftp_response (csock, &respline);
945 if (*respline == '5')
950 if (*respline != '1')
960 /* Sends the LIST command to the server. If FILE is NULL, send just
961 `LIST' (no space). */
963 ftp_list (int csock, const char *file, bool avoid_list_a, bool avoid_list,
966 char *request, *respline;
972 *list_a_used = false;
974 /* 2013-10-12 Andrea Urbani (matfanjol)
975 For more information about LIST and "LIST -a" please look at ftp.c,
976 function getftp, text "__LIST_A_EXPLANATION__".
978 If somebody changes the following commands, please, checks also the
979 later "i" variable. */
980 const char *list_commands[] = { "LIST -a",
985 i = countof (list_commands)- 1;
986 DEBUGP (("(skipping \"LIST -a\")"));
992 request = ftp_request (list_commands[i], file);
993 nwritten = fd_write (csock, request, strlen (request), -1);
1000 /* Get appropriate response. */
1001 err = ftp_response (csock, &respline);
1004 if (*respline == '5')
1008 else if (*respline == '1')
1012 /* Which list command was used? */
1013 *list_a_used = (i == 0);
1022 if ((avoid_list) && (i == 1))
1026 DEBUGP (("(skipping \"LIST\")"));
1028 } while (i < countof (list_commands) && !ok);
1033 /* Sends the SYST command to the server. */
1035 ftp_syst (int csock, enum stype *server_type, enum ustype *unix_type)
1037 char *request, *respline;
1041 /* Send SYST request. */
1042 request = ftp_request ("SYST", NULL);
1043 nwritten = fd_write (csock, request, strlen (request), -1);
1051 /* Get appropriate response. */
1052 err = ftp_response (csock, &respline);
1055 if (*respline == '5')
1061 /* Skip the number (215, but 200 (!!!) in case of VMS) */
1062 strtok (respline, " ");
1064 /* Which system type has been reported (we are interested just in the
1065 first word of the server response)? */
1066 request = strtok (NULL, " ");
1068 *unix_type = UST_OTHER;
1070 if (request == NULL)
1071 *server_type = ST_OTHER;
1072 else if (!strcasecmp (request, "VMS"))
1073 *server_type = ST_VMS;
1074 else if (!strcasecmp (request, "UNIX"))
1076 *server_type = ST_UNIX;
1077 /* 2013-10-17 Andrea Urbani (matfanjol)
1078 I check more in depth the system type */
1079 if (!strncasecmp (ftp_last_respline, "215 UNIX Type: L8", 17))
1080 *unix_type = UST_TYPE_L8;
1081 else if (!strncasecmp (ftp_last_respline,
1082 "215 UNIX MultiNet Unix Emulation V5.3(93)", 41))
1083 *unix_type = UST_MULTINET;
1085 else if (!strcasecmp (request, "WINDOWS_NT")
1086 || !strcasecmp (request, "WINDOWS2000"))
1087 *server_type = ST_WINNT;
1088 else if (!strcasecmp (request, "MACOS"))
1089 *server_type = ST_MACOS;
1090 else if (!strcasecmp (request, "OS/400"))
1091 *server_type = ST_OS400;
1093 *server_type = ST_OTHER;
1100 /* Sends the PWD command to the server. */
1102 ftp_pwd (int csock, char **pwd)
1104 char *request, *respline;
1108 /* Send PWD request. */
1109 request = ftp_request ("PWD", NULL);
1110 nwritten = fd_write (csock, request, strlen (request), -1);
1117 /* Get appropriate response. */
1118 err = ftp_response (csock, &respline);
1121 if (*respline == '5')
1128 /* Skip the number (257), leading citation mark, trailing citation mark
1129 and everything following it. */
1130 strtok (respline, "\"");
1131 request = strtok (NULL, "\"");
1133 /* Treat the malformed response as an error, which the caller has
1134 to handle gracefully anyway. */
1137 /* Has the `pwd' been already allocated? Free! */
1140 *pwd = xstrdup (request);
1147 /* Sends the SIZE command to the server, and returns the value in 'size'.
1148 * If an error occurs, size is set to zero. */
1150 ftp_size (int csock, const char *file, wgint *size)
1152 char *request, *respline;
1156 /* Send PWD request. */
1157 request = ftp_request ("SIZE", file);
1158 nwritten = fd_write (csock, request, strlen (request), -1);
1166 /* Get appropriate response. */
1167 err = ftp_response (csock, &respline);
1173 if (*respline == '5')
1176 * Probably means SIZE isn't supported on this server.
1177 * Error is nonfatal since SIZE isn't in RFC 959
1185 *size = str_to_wgint (respline + 4, NULL, 10);
1189 * Couldn't parse the response for some reason. On the (few)
1190 * tests I've done, the response is 213 <SIZE> with nothing else -
1191 * maybe something a bit more resilient is necessary. It's not a
1192 * fatal error, however.
1204 /* If URL's params are of the form "type=X", return character X.
1205 Otherwise, return 'I' (the default type). */
1207 ftp_process_type (const char *params)
1210 && 0 == strncasecmp (params, "type=", 5)
1211 && params[5] != '\0')
1212 return c_toupper (params[5]);