2 Copyright (C) 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
4 This file is part of GNU Wget.
6 GNU Wget is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 GNU Wget is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with Wget; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 In addition, as a special exception, the Free Software Foundation
21 gives permission to link the code of its release of Wget with the
22 OpenSSL project's "OpenSSL" library (or with modified versions of it
23 that use the same license as the "OpenSSL" library), and distribute
24 the linked executables. You must obey the GNU General Public License
25 in all respects for all of the code used other than "OpenSSL". If you
26 modify this file, you may extend this exception to your version of the
27 file, but you are not obligated to do so. If you do not wish to do
28 so, delete this exception statement from your version. */
49 char ftp_last_respline[128];
52 /* Get the response of FTP server and allocate enough room to handle
53 it. <CR> and <LF> characters are stripped from the line, and the
54 line is 0-terminated. All the response lines but the last one are
55 skipped. The last line is determined as described in RFC959.
57 If the line is successfully read, FTPOK is returned, and *ret_line
58 is assigned a freshly allocated line. Otherwise, FTPRERR is
59 returned, and the value of *ret_line should be ignored. */
62 ftp_response (int fd, char **ret_line)
67 char *line = fd_read_line (fd);
71 /* Strip trailing CRLF before printing the line, so that
72 escnonprint doesn't include bogus \012 and \015. */
73 p = strchr (line, '\0');
74 if (p > line && p[-1] == '\n')
76 if (p > line && p[-1] == '\r')
79 if (opt.server_response)
80 logprintf (LOG_NOTQUIET, "%s\n", escnonprint (line));
82 DEBUGP (("%s\n", escnonprint (line)));
84 /* The last line of output is the one that begins with "ddd ". */
85 if (ISDIGIT (line[0]) && ISDIGIT (line[1]) && ISDIGIT (line[2])
88 strncpy (ftp_last_respline, line, sizeof (ftp_last_respline));
89 ftp_last_respline[sizeof (ftp_last_respline) - 1] = '\0';
97 /* Returns the malloc-ed FTP request, ending with <CR><LF>, printing
98 it if printing is required. If VALUE is NULL, just use
101 ftp_request (const char *command, const char *value)
106 /* Check for newlines in VALUE (possibly injected by the %0A URL
107 escape) making the callers inadvertently send multiple FTP
108 commands at once. Without this check an attacker could
109 intentionally redirect to ftp://server/fakedir%0Acommand.../
110 and execute arbitrary FTP command on a remote FTP server. */
111 if (strpbrk (value, "\r\n"))
113 /* Copy VALUE to the stack and modify CR/LF to space. */
115 STRDUP_ALLOCA (defanged, value);
116 for (p = defanged; *p; p++)
117 if (*p == '\r' || *p == '\n')
119 DEBUGP (("\nDetected newlines in %s \"%s\"; changing to %s \"%s\"\n",
120 command, escnonprint (value), command, escnonprint (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 (; 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 != NULL);
254 assert (addr->type == IPV4_ADDRESS);
255 assert (buf != NULL);
256 /* buf must contain the argument of PORT (of the form a,b,c,d,e,f). */
257 assert (buflen >= 6 * 4);
259 ptr = ADDRESS_IPV4_DATA (addr);
260 snprintf (buf, buflen, "%d,%d,%d,%d,%d,%d", ptr[0], ptr[1],
261 ptr[2], ptr[3], (port & 0xff00) >> 8, port & 0xff);
262 buf[buflen - 1] = '\0';
265 /* Bind a port and send the appropriate PORT command to the FTP
266 server. Use acceptport after RETR, to get the socket of data
269 ftp_port (int csock, int *local_sock)
272 char *request, *respline;
276 /* Must contain the argument of PORT (of the form a,b,c,d,e,f). */
277 char bytes[6 * 4 + 1];
279 /* Get the address of this side of the connection. */
280 if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
283 assert (addr.type == IPV4_ADDRESS);
285 /* Setting port to 0 lets the system choose a free port. */
289 *local_sock = bind_local (&addr, &port);
293 /* Construct the argument of PORT (of the form a,b,c,d,e,f). */
294 ip_address_to_port_repr (&addr, port, bytes, sizeof (bytes));
296 /* Send PORT request. */
297 request = ftp_request ("PORT", bytes);
298 nwritten = fd_write (csock, request, strlen (request), -1);
302 fd_close (*local_sock);
307 /* Get appropriate response. */
308 err = ftp_response (csock, &respline);
311 fd_close (*local_sock);
314 if (*respline != '2')
317 fd_close (*local_sock);
326 ip_address_to_lprt_repr (const ip_address *addr, int port, char *buf,
331 assert (addr != NULL);
332 assert (addr->type == IPV4_ADDRESS || addr->type == IPV6_ADDRESS);
333 assert (buf != NULL);
334 /* buf must contain the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
335 assert (buflen >= 21 * 4);
337 /* Construct the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
341 ptr = ADDRESS_IPV4_DATA (addr);
342 snprintf (buf, buflen, "%d,%d,%d,%d,%d,%d,%d,%d,%d", 4, 4,
343 ptr[0], ptr[1], ptr[2], ptr[3], 2,
344 (port & 0xff00) >> 8, port & 0xff);
345 buf[buflen - 1] = '\0';
348 ptr = ADDRESS_IPV6_DATA (addr);
349 snprintf (buf, buflen, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
350 6, 16, ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7],
351 ptr[8], ptr[9], ptr[10], ptr[11], ptr[12], ptr[13], ptr[14], ptr[15], 2,
352 (port & 0xff00) >> 8, port & 0xff);
353 buf[buflen - 1] = '\0';
358 /* Bind a port and send the appropriate PORT command to the FTP
359 server. Use acceptport after RETR, to get the socket of data
362 ftp_lprt (int csock, int *local_sock)
365 char *request, *respline;
369 /* Must contain the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
370 char bytes[21 * 4 + 1];
372 /* Get the address of this side of the connection. */
373 if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
376 assert (addr.type == IPV4_ADDRESS || addr.type == IPV6_ADDRESS);
378 /* Setting port to 0 lets the system choose a free port. */
382 *local_sock = bind_local (&addr, &port);
386 /* Construct the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
387 ip_address_to_lprt_repr (&addr, port, bytes, sizeof (bytes));
389 /* Send PORT request. */
390 request = ftp_request ("LPRT", bytes);
391 nwritten = fd_write (csock, request, strlen (request), -1);
395 fd_close (*local_sock);
399 /* Get appropriate response. */
400 err = ftp_response (csock, &respline);
403 fd_close (*local_sock);
406 if (*respline != '2')
409 fd_close (*local_sock);
417 ip_address_to_eprt_repr (const ip_address *addr, int port, char *buf,
422 /* buf must contain the argument of EPRT (of the form |af|addr|port|).
423 * 4 chars for the | separators, INET6_ADDRSTRLEN chars for addr
424 * 1 char for af (1-2) and 5 chars for port (0-65535) */
425 assert (buflen >= 4 + INET6_ADDRSTRLEN + 1 + 5);
427 /* Construct the argument of EPRT (of the form |af|addr|port|). */
428 afnum = (addr->type == IPV4_ADDRESS ? 1 : 2);
429 snprintf (buf, buflen, "|%d|%s|%d|", afnum, print_address (addr), port);
430 buf[buflen - 1] = '\0';
433 /* Bind a port and send the appropriate PORT command to the FTP
434 server. Use acceptport after RETR, to get the socket of data
437 ftp_eprt (int csock, int *local_sock)
440 char *request, *respline;
444 /* Must contain the argument of EPRT (of the form |af|addr|port|).
445 * 4 chars for the | separators, INET6_ADDRSTRLEN chars for addr
446 * 1 char for af (1-2) and 5 chars for port (0-65535) */
447 char bytes[4 + INET6_ADDRSTRLEN + 1 + 5 + 1];
449 /* Get the address of this side of the connection. */
450 if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
453 /* Setting port to 0 lets the system choose a free port. */
457 *local_sock = bind_local (&addr, &port);
461 /* Construct the argument of EPRT (of the form |af|addr|port|). */
462 ip_address_to_eprt_repr (&addr, port, bytes, sizeof (bytes));
464 /* Send PORT request. */
465 request = ftp_request ("EPRT", bytes);
466 nwritten = fd_write (csock, request, strlen (request), -1);
470 fd_close (*local_sock);
474 /* Get appropriate response. */
475 err = ftp_response (csock, &respline);
478 fd_close (*local_sock);
481 if (*respline != '2')
484 fd_close (*local_sock);
492 /* Similar to ftp_port, but uses `PASV' to initiate the passive FTP
493 transfer. Reads the response from server and parses it. Reads the
494 host and port addresses and returns them. */
496 ftp_pasv (int csock, ip_address *addr, int *port)
498 char *request, *respline, *s;
501 unsigned char tmp[6];
503 assert (addr != NULL);
504 assert (port != NULL);
508 /* Form the request. */
509 request = ftp_request ("PASV", NULL);
511 nwritten = fd_write (csock, request, strlen (request), -1);
518 /* Get the server response. */
519 err = ftp_response (csock, &respline);
522 if (*respline != '2')
527 /* Parse the request. */
529 for (s += 4; *s && !ISDIGIT (*s); s++);
532 for (i = 0; i < 6; i++)
535 for (; ISDIGIT (*s); s++)
536 tmp[i] = (*s - '0') + 10 * tmp[i];
541 /* When on the last number, anything can be a terminator. */
548 addr->type = IPV4_ADDRESS;
549 memcpy (ADDRESS_IPV4_DATA (addr), tmp, 4);
550 *port = ((tmp[4] << 8) & 0xff00) + tmp[5];
556 /* Similar to ftp_lprt, but uses `LPSV' to initiate the passive FTP
557 transfer. Reads the response from server and parses it. Reads the
558 host and port addresses and returns them. */
560 ftp_lpsv (int csock, ip_address *addr, int *port)
562 char *request, *respline, *s;
563 int nwritten, i, af, addrlen, portlen;
565 unsigned char tmp[16];
566 unsigned char tmpprt[2];
568 assert (addr != NULL);
569 assert (port != NULL);
573 /* Form the request. */
574 request = ftp_request ("LPSV", NULL);
577 nwritten = fd_write (csock, request, strlen (request), -1);
585 /* Get the server response. */
586 err = ftp_response (csock, &respline);
589 if (*respline != '2')
595 /* Parse the response. */
597 for (s += 4; *s && !ISDIGIT (*s); s++);
601 /* First, get the address family */
603 for (; ISDIGIT (*s); s++)
604 af = (*s - '0') + 10 * af;
606 if (af != 4 && af != 6)
612 if (!*s || *s++ != ',')
618 /* Then, get the address length */
620 for (; ISDIGIT (*s); s++)
621 addrlen = (*s - '0') + 10 * addrlen;
623 if (!*s || *s++ != ',')
635 if ((af == 4 && addrlen != 4)
636 || (af == 6 && addrlen != 16))
642 /* Now, we get the actual address */
643 for (i = 0; i < addrlen; i++)
646 for (; ISDIGIT (*s); s++)
647 tmp[i] = (*s - '0') + 10 * tmp[i];
657 /* Now, get the port length */
659 for (; ISDIGIT (*s); s++)
660 portlen = (*s - '0') + 10 * portlen;
662 if (!*s || *s++ != ',')
674 /* Finally, we get the port number */
676 for (; ISDIGIT (*s); s++)
677 tmpprt[0] = (*s - '0') + 10 * tmpprt[0];
679 if (!*s || *s++ != ',')
686 for (; ISDIGIT (*s); s++)
687 tmpprt[1] = (*s - '0') + 10 * tmpprt[1];
693 addr->type = IPV4_ADDRESS;
694 memcpy (ADDRESS_IPV4_DATA (addr), tmp, 4);
695 *port = ((tmpprt[0] << 8) & 0xff00) + tmpprt[1];
696 DEBUGP (("lpsv addr is: %s\n", print_address(addr)));
697 DEBUGP (("tmpprt[0] is: %d\n", tmpprt[0]));
698 DEBUGP (("tmpprt[1] is: %d\n", tmpprt[1]));
699 DEBUGP (("*port is: %d\n", *port));
704 addr->type = IPV6_ADDRESS;
705 memcpy (ADDRESS_IPV6_DATA (addr), tmp, 16);
706 *port = ((tmpprt[0] << 8) & 0xff00) + tmpprt[1];
707 DEBUGP (("lpsv addr is: %s\n", print_address(addr)));
708 DEBUGP (("tmpprt[0] is: %d\n", tmpprt[0]));
709 DEBUGP (("tmpprt[1] is: %d\n", tmpprt[1]));
710 DEBUGP (("*port is: %d\n", *port));
717 /* Similar to ftp_eprt, but uses `EPSV' to initiate the passive FTP
718 transfer. Reads the response from server and parses it. Reads the
719 host and port addresses and returns them. */
721 ftp_epsv (int csock, ip_address *ip, int *port)
723 char *request, *respline, *start, delim, *s;
729 assert (port != NULL);
731 /* IP already contains the IP address of the control connection's
732 peer, so we don't need to call socket_ip_address here. */
734 /* Form the request. */
735 /* EPSV 1 means that we ask for IPv4 and EPSV 2 means that we ask for IPv6. */
736 request = ftp_request ("EPSV", (ip->type == IPV4_ADDRESS ? "1" : "2"));
739 nwritten = fd_write (csock, request, strlen (request), -1);
747 /* Get the server response. */
748 err = ftp_response (csock, &respline);
751 if (*respline != '2')
757 assert (respline != NULL);
759 DEBUGP(("respline is %s\n", respline));
761 /* Parse the response. */
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; 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)
965 char *request, *respline;
969 /* Send LIST request. */
970 request = ftp_request ("LIST", file);
971 nwritten = fd_write (csock, request, strlen (request), -1);
978 /* Get appropriate respone. */
979 err = ftp_response (csock, &respline);
982 if (*respline == '5')
987 if (*respline != '1')
997 /* Sends the SYST command to the server. */
999 ftp_syst (int csock, enum stype *server_type)
1001 char *request, *respline;
1005 /* Send SYST request. */
1006 request = ftp_request ("SYST", NULL);
1007 nwritten = fd_write (csock, request, strlen (request), -1);
1015 /* Get appropriate response. */
1016 err = ftp_response (csock, &respline);
1019 if (*respline == '5')
1025 /* Skip the number (215, but 200 (!!!) in case of VMS) */
1026 strtok (respline, " ");
1028 /* Which system type has been reported (we are interested just in the
1029 first word of the server response)? */
1030 request = strtok (NULL, " ");
1032 if (!strcasecmp (request, "VMS"))
1033 *server_type = ST_VMS;
1034 else if (!strcasecmp (request, "UNIX"))
1035 *server_type = ST_UNIX;
1036 else if (!strcasecmp (request, "WINDOWS_NT")
1037 || !strcasecmp (request, "WINDOWS2000"))
1038 *server_type = ST_WINNT;
1039 else if (!strcasecmp (request, "MACOS"))
1040 *server_type = ST_MACOS;
1041 else if (!strcasecmp (request, "OS/400"))
1042 *server_type = ST_OS400;
1044 *server_type = ST_OTHER;
1051 /* Sends the PWD command to the server. */
1053 ftp_pwd (int csock, char **pwd)
1055 char *request, *respline;
1059 /* Send PWD request. */
1060 request = ftp_request ("PWD", NULL);
1061 nwritten = fd_write (csock, request, strlen (request), -1);
1068 /* Get appropriate response. */
1069 err = ftp_response (csock, &respline);
1072 if (*respline == '5')
1079 /* Skip the number (257), leading citation mark, trailing citation mark
1080 and everything following it. */
1081 strtok (respline, "\"");
1082 request = strtok (NULL, "\"");
1084 /* Treat the malformed response as an error, which the caller has
1085 to handle gracefully anyway. */
1088 /* Has the `pwd' been already allocated? Free! */
1091 *pwd = xstrdup (request);
1098 /* Sends the SIZE command to the server, and returns the value in 'size'.
1099 * If an error occurs, size is set to zero. */
1101 ftp_size (int csock, const char *file, wgint *size)
1103 char *request, *respline;
1107 /* Send PWD request. */
1108 request = ftp_request ("SIZE", file);
1109 nwritten = fd_write (csock, request, strlen (request), -1);
1117 /* Get appropriate response. */
1118 err = ftp_response (csock, &respline);
1124 if (*respline == '5')
1127 * Probably means SIZE isn't supported on this server.
1128 * Error is nonfatal since SIZE isn't in RFC 959
1136 *size = str_to_wgint (respline + 4, NULL, 10);
1140 * Couldn't parse the response for some reason. On the (few)
1141 * tests I've done, the response is 213 <SIZE> with nothing else -
1142 * maybe something a bit more resilient is necessary. It's not a
1143 * fatal error, however.
1155 /* If URL's params are of the form "type=X", return character X.
1156 Otherwise, return 'I' (the default type). */
1158 ftp_process_type (const char *params)
1161 && 0 == strncasecmp (params, "type=", 5)
1162 && params[5] != '\0')
1163 return TOUPPER (params[5]);