1 /* File Transfer Protocol support.
2 Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Wget.
7 GNU Wget is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 GNU Wget is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Wget; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 In addition, as a special exception, the Free Software Foundation
22 gives permission to link the code of its release of Wget with the
23 OpenSSL project's "OpenSSL" library (or with modified versions of it
24 that use the same license as the "OpenSSL" library), and distribute
25 the linked executables. You must obey the GNU General Public License
26 in all respects for all of the code used other than "OpenSSL". If you
27 modify this file, you may extend this exception to your version of the
28 file, but you are not obligated to do so. If you do not wish to do
29 so, delete this exception statement from your version. */
43 #include <sys/types.h>
56 #include "convert.h" /* for downloaded_file */
57 #include "recur.h" /* for INFINITE_RECURSION */
63 extern LARGE_INT total_downloaded_bytes;
65 /* File where the "ls -al" listing will be saved. */
66 #define LIST_FILENAME ".listing"
68 extern char ftp_last_respline[];
72 int st; /* connection status */
73 int cmd; /* command code */
74 struct rbuf rbuf; /* control connection buffer */
75 double dltime; /* time of the download in msecs */
76 enum stype rs; /* remote system reported by ftp server */
77 char *id; /* initial directory */
78 char *target; /* target file name */
79 struct url *proxy; /* FTWK-style proxy */
83 /* Look for regexp "( *[0-9]+ *byte" (literal parenthesis) anywhere in
84 the string S, and return the number converted to long, if found, 0
87 ftp_expected_bytes (const char *s)
93 while (*s && *s != '(')
97 for (++s; *s && ISSPACE (*s); s++);
105 res = (*s - '0') + 10 * res;
108 while (*s && ISDIGIT (*s));
111 while (*s && ISSPACE (*s))
115 if (TOLOWER (*s) != 'b')
117 if (strncasecmp (s, "byte", 4))
127 * This function sets up a passive data connection with the FTP server.
128 * It is merely a wrapper around ftp_epsv, ftp_lpsv and ftp_pasv.
131 ftp_do_pasv (struct rbuf *rbuf, ip_address *addr, int *port)
135 /* We need to determine the address family and need to call
136 getpeername, so while we're at it, store the address to ADDR.
137 ftp_pasv and ftp_lpsv can simply override it. */
138 if (!socket_ip_address (RBUF_FD (rbuf), addr, ENDPOINT_PEER))
141 /* If our control connection is over IPv6, then we first try EPSV and then
142 * LPSV if the former is not supported. If the control connection is over
143 * IPv4, we simply issue the good old PASV request. */
147 if (!opt.server_response)
148 logputs (LOG_VERBOSE, "==> PASV ... ");
149 err = ftp_pasv (rbuf, addr, port);
152 if (!opt.server_response)
153 logputs (LOG_VERBOSE, "==> EPSV ... ");
154 err = ftp_epsv (rbuf, addr, port);
156 /* If EPSV is not supported try LPSV */
157 if (err == FTPNOPASV)
159 if (!opt.server_response)
160 logputs (LOG_VERBOSE, "==> LPSV ... ");
161 err = ftp_lpsv (rbuf, addr, port);
172 * This function sets up an active data connection with the FTP server.
173 * It is merely a wrapper around ftp_eprt, ftp_lprt and ftp_port.
176 ftp_do_port (struct rbuf *rbuf, int *local_sock)
181 assert (rbuf != NULL);
182 assert (rbuf_initialized_p (rbuf));
184 if (!socket_ip_address (RBUF_FD (rbuf), &cip, ENDPOINT_PEER))
187 /* If our control connection is over IPv6, then we first try EPRT and then
188 * LPRT if the former is not supported. If the control connection is over
189 * IPv4, we simply issue the good old PORT request. */
193 if (!opt.server_response)
194 logputs (LOG_VERBOSE, "==> PORT ... ");
195 err = ftp_port (rbuf, local_sock);
198 if (!opt.server_response)
199 logputs (LOG_VERBOSE, "==> EPRT ... ");
200 err = ftp_eprt (rbuf, local_sock);
202 /* If EPRT is not supported try LPRT */
203 if (err == FTPPORTERR)
205 if (!opt.server_response)
206 logputs (LOG_VERBOSE, "==> LPRT ... ");
207 err = ftp_lprt (rbuf, local_sock);
218 ftp_do_pasv (struct rbuf *rbuf, ip_address *addr, int *port)
220 if (!opt.server_response)
221 logputs (LOG_VERBOSE, "==> PASV ... ");
222 return ftp_pasv (rbuf, addr, port);
226 ftp_do_port (struct rbuf *rbuf, int *local_sock)
228 if (!opt.server_response)
229 logputs (LOG_VERBOSE, "==> PORT ... ");
230 return ftp_port (rbuf, local_sock);
234 /* Retrieves a file with denoted parameters through opening an FTP
235 connection to the server. It always closes the data connection,
236 and closes the control connection in case of error. */
238 getftp (struct url *u, long *len, long restval, ccon *con)
240 int csock, dtsock, local_sock, res;
243 char *user, *passwd, *respline;
246 int pasv_mode_open = 0;
247 long expected_bytes = 0L;
249 assert (con != NULL);
250 assert (con->target != NULL);
252 /* Debug-check of the sanity of the request by making sure that LIST
253 and RETR are never both requested (since we can handle only one
255 assert (!((cmd & DO_LIST) && (cmd & DO_RETR)));
256 /* Make sure that at least *something* is requested. */
257 assert ((cmd & (DO_LIST | DO_CWD | DO_RETR | DO_LOGIN)) != 0);
261 search_netrc (u->host, (const char **)&user, (const char **)&passwd, 1);
262 user = user ? user : opt.ftp_acc;
263 passwd = passwd ? passwd : opt.ftp_pass;
264 assert (user && passwd);
270 if (!(cmd & DO_LOGIN))
271 csock = RBUF_FD (&con->rbuf);
272 else /* cmd & DO_LOGIN */
275 char *host = con->proxy ? con->proxy->host : u->host;
276 int port = con->proxy ? con->proxy->port : u->port;
277 char *logname = user;
281 /* If proxy is in use, log in as username@target-site. */
282 logname = xmalloc (strlen (user) + 1 + strlen (u->host) + 1);
283 sprintf (logname, "%s@%s", user, u->host);
286 /* Login to the server: */
288 /* First: Establish the control connection. */
290 csock = connect_to_host (host, port);
294 return (retryable_socket_connect_error (errno)
295 ? CONERROR : CONIMPOSSIBLE);
297 if (cmd & LEAVE_PENDING)
298 rbuf_initialize (&con->rbuf, csock);
300 rbuf_uninitialize (&con->rbuf);
302 /* Since this is a new connection, we may safely discard
303 anything left in the buffer. */
304 rbuf_discard (&con->rbuf);
306 /* Second: Login with proper USER/PASS sequence. */
307 logprintf (LOG_VERBOSE, _("Logging in as %s ... "), user);
308 if (opt.server_response)
309 logputs (LOG_ALWAYS, "\n");
310 err = ftp_login (&con->rbuf, logname, passwd);
315 /* FTPRERR, FTPSRVERR, WRITEFAILED, FTPLOGREFUSED, FTPLOGINC */
319 logputs (LOG_VERBOSE, "\n");
320 logputs (LOG_NOTQUIET, _("\
321 Error in server response, closing control connection.\n"));
323 rbuf_uninitialize (&con->rbuf);
327 logputs (LOG_VERBOSE, "\n");
328 logputs (LOG_NOTQUIET, _("Error in server greeting.\n"));
330 rbuf_uninitialize (&con->rbuf);
334 logputs (LOG_VERBOSE, "\n");
335 logputs (LOG_NOTQUIET,
336 _("Write failed, closing control connection.\n"));
338 rbuf_uninitialize (&con->rbuf);
342 logputs (LOG_VERBOSE, "\n");
343 logputs (LOG_NOTQUIET, _("The server refuses login.\n"));
345 rbuf_uninitialize (&con->rbuf);
346 return FTPLOGREFUSED;
349 logputs (LOG_VERBOSE, "\n");
350 logputs (LOG_NOTQUIET, _("Login incorrect.\n"));
352 rbuf_uninitialize (&con->rbuf);
356 if (!opt.server_response)
357 logputs (LOG_VERBOSE, _("Logged in!\n"));
364 /* Third: Get the system type */
365 if (!opt.server_response)
366 logprintf (LOG_VERBOSE, "==> SYST ... ");
367 err = ftp_syst (&con->rbuf, &con->rs);
372 logputs (LOG_VERBOSE, "\n");
373 logputs (LOG_NOTQUIET, _("\
374 Error in server response, closing control connection.\n"));
376 rbuf_uninitialize (&con->rbuf);
380 logputs (LOG_VERBOSE, "\n");
381 logputs (LOG_NOTQUIET,
382 _("Server error, can't determine system type.\n"));
385 /* Everything is OK. */
391 if (!opt.server_response && err != FTPSRVERR)
392 logputs (LOG_VERBOSE, _("done. "));
394 /* Fourth: Find the initial ftp directory */
396 if (!opt.server_response)
397 logprintf (LOG_VERBOSE, "==> PWD ... ");
398 err = ftp_pwd(&con->rbuf, &con->id);
403 logputs (LOG_VERBOSE, "\n");
404 logputs (LOG_NOTQUIET, _("\
405 Error in server response, closing control connection.\n"));
407 rbuf_uninitialize (&con->rbuf);
411 /* PWD unsupported -- assume "/". */
412 xfree_null (con->id);
413 con->id = xstrdup ("/");
416 /* Everything is OK. */
422 /* VMS will report something like "PUB$DEVICE:[INITIAL.FOLDER]".
423 Convert it to "/INITIAL/FOLDER" */
424 if (con->rs == ST_VMS)
426 char *path = strchr (con->id, '[');
427 char *pathend = path ? strchr (path + 1, ']') : NULL;
428 if (!path || !pathend)
429 DEBUGP (("Initial VMS directory not in the form [...]!\n"));
432 char *idir = con->id;
433 DEBUGP (("Preprocessing the initial VMS directory\n"));
434 DEBUGP ((" old = '%s'\n", con->id));
435 /* We do the conversion in-place by copying the stuff
436 between [ and ] to the beginning, and changing dots
437 to slashes at the same time. */
439 for (++path; path < pathend; path++, idir++)
440 *idir = *path == '.' ? '/' : *path;
442 DEBUGP ((" new = '%s'\n\n", con->id));
445 if (!opt.server_response)
446 logputs (LOG_VERBOSE, _("done.\n"));
448 /* Fifth: Set the FTP type. */
449 type_char = ftp_process_type (u->params);
450 if (!opt.server_response)
451 logprintf (LOG_VERBOSE, "==> TYPE %c ... ", type_char);
452 err = ftp_type (&con->rbuf, type_char);
453 /* FTPRERR, WRITEFAILED, FTPUNKNOWNTYPE */
457 logputs (LOG_VERBOSE, "\n");
458 logputs (LOG_NOTQUIET, _("\
459 Error in server response, closing control connection.\n"));
461 rbuf_uninitialize (&con->rbuf);
465 logputs (LOG_VERBOSE, "\n");
466 logputs (LOG_NOTQUIET,
467 _("Write failed, closing control connection.\n"));
469 rbuf_uninitialize (&con->rbuf);
473 logputs (LOG_VERBOSE, "\n");
474 logprintf (LOG_NOTQUIET,
475 _("Unknown type `%c', closing control connection.\n"),
478 rbuf_uninitialize (&con->rbuf);
481 /* Everything is OK. */
487 if (!opt.server_response)
488 logputs (LOG_VERBOSE, _("done. "));
494 logputs (LOG_VERBOSE, _("==> CWD not needed.\n"));
497 char *target = u->dir;
499 DEBUGP (("changing working directory\n"));
501 /* Change working directory. To change to a non-absolute
502 Unix directory, we need to prepend initial directory
503 (con->id) to it. Absolute directories "just work".
505 A relative directory is one that does not begin with '/'
506 and, on non-Unix OS'es, one that doesn't begin with
509 This is not done for OS400, which doesn't use
510 "/"-delimited directories, nor does it support directory
511 hierarchies. "CWD foo" followed by "CWD bar" leaves us
512 in "bar", not in "foo/bar", as would be customary
516 && !(con->rs != ST_UNIX
517 && ISALPHA (target[0])
519 && con->rs != ST_OS400)
521 int idlen = strlen (con->id);
524 /* Strip trailing slash(es) from con->id. */
525 while (idlen > 0 && con->id[idlen - 1] == '/')
527 p = ntarget = (char *)alloca (idlen + 1 + strlen (u->dir) + 1);
528 memcpy (p, con->id, idlen);
533 DEBUGP (("Prepended initial PWD to relative path:\n"));
534 DEBUGP ((" pwd: '%s'\n old: '%s'\n new: '%s'\n",
535 con->id, target, ntarget));
539 /* If the FTP host runs VMS, we will have to convert the absolute
540 directory path in UNIX notation to absolute directory path in
541 VMS notation as VMS FTP servers do not like UNIX notation of
542 absolute paths. "VMS notation" is [dir.subdir.subsubdir]. */
544 if (con->rs == ST_VMS)
547 char *ntarget = (char *)alloca (strlen (target) + 2);
548 /* We use a converted initial dir, so directories in
549 TARGET will be separated with slashes, something like
550 "/INITIAL/FOLDER/DIR/SUBDIR". Convert that to
551 "[INITIAL.FOLDER.DIR.SUBDIR]". */
552 strcpy (ntarget, target);
553 assert (*ntarget == '/');
555 for (tmpp = ntarget + 1; *tmpp; tmpp++)
560 DEBUGP (("Changed file name to VMS syntax:\n"));
561 DEBUGP ((" Unix: '%s'\n VMS: '%s'\n", target, ntarget));
565 if (!opt.server_response)
566 logprintf (LOG_VERBOSE, "==> CWD %s ... ", target);
567 err = ftp_cwd (&con->rbuf, target);
568 /* FTPRERR, WRITEFAILED, FTPNSFOD */
572 logputs (LOG_VERBOSE, "\n");
573 logputs (LOG_NOTQUIET, _("\
574 Error in server response, closing control connection.\n"));
576 rbuf_uninitialize (&con->rbuf);
580 logputs (LOG_VERBOSE, "\n");
581 logputs (LOG_NOTQUIET,
582 _("Write failed, closing control connection.\n"));
584 rbuf_uninitialize (&con->rbuf);
588 logputs (LOG_VERBOSE, "\n");
589 logprintf (LOG_NOTQUIET, _("No such directory `%s'.\n\n"),
592 rbuf_uninitialize (&con->rbuf);
602 if (!opt.server_response)
603 logputs (LOG_VERBOSE, _("done.\n"));
606 else /* do not CWD */
607 logputs (LOG_VERBOSE, _("==> CWD not required.\n"));
609 if ((cmd & DO_RETR) && restval && *len == 0)
613 if (!opt.server_response)
614 logprintf (LOG_VERBOSE, "==> SIZE %s ... ", u->file);
617 err = ftp_size(&con->rbuf, u->file, len);
623 logputs (LOG_VERBOSE, "\n");
624 logputs (LOG_NOTQUIET, _("\
625 Error in server response, closing control connection.\n"));
627 rbuf_uninitialize (&con->rbuf);
631 /* Everything is OK. */
637 if (!opt.server_response)
638 logputs (LOG_VERBOSE, _("done.\n"));
641 /* If anything is to be retrieved, PORT (or PASV) must be sent. */
642 if (cmd & (DO_LIST | DO_RETR))
644 if (opt.ftp_pasv > 0)
646 ip_address passive_addr;
648 err = ftp_do_pasv (&con->rbuf, &passive_addr, &passive_port);
649 /* FTPRERR, WRITEFAILED, FTPNOPASV, FTPINVPASV */
653 logputs (LOG_VERBOSE, "\n");
654 logputs (LOG_NOTQUIET, _("\
655 Error in server response, closing control connection.\n"));
657 rbuf_uninitialize (&con->rbuf);
661 logputs (LOG_VERBOSE, "\n");
662 logputs (LOG_NOTQUIET,
663 _("Write failed, closing control connection.\n"));
665 rbuf_uninitialize (&con->rbuf);
669 logputs (LOG_VERBOSE, "\n");
670 logputs (LOG_NOTQUIET, _("Cannot initiate PASV transfer.\n"));
673 logputs (LOG_VERBOSE, "\n");
674 logputs (LOG_NOTQUIET, _("Cannot parse PASV response.\n"));
685 DEBUGP (("trying to connect to %s port %d\n",
686 pretty_print_address (&passive_addr),
688 dtsock = connect_to_ip (&passive_addr, passive_port, NULL);
691 int save_errno = errno;
693 rbuf_uninitialize (&con->rbuf);
694 logprintf (LOG_VERBOSE, _("couldn't connect to %s port %hu: %s\n"),
695 pretty_print_address (&passive_addr), passive_port,
696 strerror (save_errno));
697 return (retryable_socket_connect_error (save_errno)
698 ? CONERROR : CONIMPOSSIBLE);
701 pasv_mode_open = 1; /* Flag to avoid accept port */
702 if (!opt.server_response)
703 logputs (LOG_VERBOSE, _("done. "));
707 if (!pasv_mode_open) /* Try to use a port command if PASV failed */
709 err = ftp_do_port (&con->rbuf, &local_sock);
710 /* FTPRERR, WRITEFAILED, bindport (FTPSYSERR), HOSTERR,
715 logputs (LOG_VERBOSE, "\n");
716 logputs (LOG_NOTQUIET, _("\
717 Error in server response, closing control connection.\n"));
721 rbuf_uninitialize (&con->rbuf);
725 logputs (LOG_VERBOSE, "\n");
726 logputs (LOG_NOTQUIET,
727 _("Write failed, closing control connection.\n"));
731 rbuf_uninitialize (&con->rbuf);
735 logputs (LOG_VERBOSE, "\n");
736 logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
740 rbuf_uninitialize (&con->rbuf);
744 logputs (LOG_VERBOSE, "\n");
745 logprintf (LOG_NOTQUIET, _("Bind error (%s).\n"),
751 logputs (LOG_VERBOSE, "\n");
752 logputs (LOG_NOTQUIET, _("Invalid PORT.\n"));
756 rbuf_uninitialize (&con->rbuf);
766 if (!opt.server_response)
767 logputs (LOG_VERBOSE, _("done. "));
769 } /* cmd & (DO_LIST | DO_RETR) */
771 /* Restart if needed. */
772 if (restval && (cmd & DO_RETR))
774 if (!opt.server_response)
775 logprintf (LOG_VERBOSE, "==> REST %ld ... ", restval);
776 err = ftp_rest (&con->rbuf, restval);
778 /* FTPRERR, WRITEFAILED, FTPRESTFAIL */
782 logputs (LOG_VERBOSE, "\n");
783 logputs (LOG_NOTQUIET, _("\
784 Error in server response, closing control connection.\n"));
788 rbuf_uninitialize (&con->rbuf);
792 logputs (LOG_VERBOSE, "\n");
793 logputs (LOG_NOTQUIET,
794 _("Write failed, closing control connection.\n"));
798 rbuf_uninitialize (&con->rbuf);
802 /* If `-c' is specified and the file already existed when
803 Wget was started, it would be a bad idea for us to start
804 downloading it from scratch, effectively truncating it. */
805 if (opt.always_rest && (cmd & NO_TRUNCATE))
807 logprintf (LOG_NOTQUIET,
808 _("\nREST failed; will not truncate `%s'.\n"),
813 rbuf_uninitialize (&con->rbuf);
814 return CONTNOTSUPPORTED;
816 logputs (LOG_VERBOSE, _("\nREST failed, starting from scratch.\n"));
826 if (err != FTPRESTFAIL && !opt.server_response)
827 logputs (LOG_VERBOSE, _("done. "));
828 } /* restval && cmd & DO_RETR */
832 /* If we're in spider mode, don't really retrieve anything. The
833 fact that we got to this point should be proof enough that
834 the file exists, vaguely akin to HTTP's concept of a "HEAD"
841 rbuf_uninitialize (&con->rbuf);
847 if (!opt.server_response)
850 logputs (LOG_VERBOSE, "\n");
851 logprintf (LOG_VERBOSE, "==> RETR %s ... ", u->file);
855 err = ftp_retr (&con->rbuf, u->file);
856 /* FTPRERR, WRITEFAILED, FTPNSFOD */
860 logputs (LOG_VERBOSE, "\n");
861 logputs (LOG_NOTQUIET, _("\
862 Error in server response, closing control connection.\n"));
866 rbuf_uninitialize (&con->rbuf);
870 logputs (LOG_VERBOSE, "\n");
871 logputs (LOG_NOTQUIET,
872 _("Write failed, closing control connection.\n"));
876 rbuf_uninitialize (&con->rbuf);
880 logputs (LOG_VERBOSE, "\n");
881 logprintf (LOG_NOTQUIET, _("No such file `%s'.\n\n"), u->file);
894 if (!opt.server_response)
895 logputs (LOG_VERBOSE, _("done.\n"));
896 expected_bytes = ftp_expected_bytes (ftp_last_respline);
901 if (!opt.server_response)
902 logputs (LOG_VERBOSE, "==> LIST ... ");
903 /* As Maciej W. Rozycki (macro@ds2.pg.gda.pl) says, `LIST'
904 without arguments is better than `LIST .'; confirmed by
906 err = ftp_list (&con->rbuf, NULL);
907 /* FTPRERR, WRITEFAILED */
911 logputs (LOG_VERBOSE, "\n");
912 logputs (LOG_NOTQUIET, _("\
913 Error in server response, closing control connection.\n"));
917 rbuf_uninitialize (&con->rbuf);
921 logputs (LOG_VERBOSE, "\n");
922 logputs (LOG_NOTQUIET,
923 _("Write failed, closing control connection.\n"));
927 rbuf_uninitialize (&con->rbuf);
931 logputs (LOG_VERBOSE, "\n");
932 logprintf (LOG_NOTQUIET, _("No such file or directory `%s'.\n\n"),
945 if (!opt.server_response)
946 logputs (LOG_VERBOSE, _("done.\n"));
947 expected_bytes = ftp_expected_bytes (ftp_last_respline);
948 } /* cmd & DO_LIST */
950 if (!(cmd & (DO_LIST | DO_RETR)) || (opt.spider && !(cmd & DO_LIST)))
953 /* Some FTP servers return the total length of file after REST
954 command, others just return the remaining size. */
955 if (*len && restval && expected_bytes
956 && (expected_bytes == *len - restval))
958 DEBUGP (("Lying FTP server found, adjusting.\n"));
959 expected_bytes = *len;
962 /* If no transmission was required, then everything is OK. */
963 if (!pasv_mode_open) /* we are not using pasive mode so we need
966 /* Wait for the server to connect to the address we're waiting
968 dtsock = accept_connection (local_sock);
971 logprintf (LOG_NOTQUIET, "accept: %s\n", strerror (errno));
976 /* Open the file -- if opt.dfp is set, use it instead. */
977 if (!opt.dfp || con->cmd & DO_LIST)
979 mkalldirs (con->target);
981 rotate_backups (con->target);
982 /* #### Is this correct? */
983 chmod (con->target, 0600);
985 fp = fopen (con->target, restval ? "ab" : "wb");
988 logprintf (LOG_NOTQUIET, "%s: %s\n", con->target, strerror (errno));
990 rbuf_uninitialize (&con->rbuf);
998 extern int global_download_count;
1001 /* Rewind the output document if the download starts over and if
1002 this is the first download. See gethttp() for a longer
1004 if (!restval && global_download_count == 0 && opt.dfp != stdout)
1006 /* This will silently fail for streams that don't correspond
1007 to regular files, but that's OK. */
1009 /* ftruncate is needed because opt.dfp is opened in append
1010 mode if opt.always_rest is set. */
1011 ftruncate (fileno (fp), 0);
1018 logprintf (LOG_VERBOSE, _("Length: %s"), legible (*len));
1020 logprintf (LOG_VERBOSE, _(" [%s to go]"), legible (*len - restval));
1021 logputs (LOG_VERBOSE, "\n");
1022 expected_bytes = *len; /* for get_contents/show_progress */
1024 else if (expected_bytes)
1026 logprintf (LOG_VERBOSE, _("Length: %s"), legible (expected_bytes));
1028 logprintf (LOG_VERBOSE, _(" [%s to go]"),
1029 legible (expected_bytes - restval));
1030 logputs (LOG_VERBOSE, _(" (unauthoritative)\n"));
1033 /* Get the contents of the document. */
1034 res = get_contents (dtsock, fp, len, restval, expected_bytes, &con->rbuf,
1036 tms = time_str (NULL);
1037 tmrate = retr_rate (*len - restval, con->dltime, 0);
1038 /* Close data connection socket. */
1040 xclose (local_sock);
1041 /* Close the local file. */
1043 /* Close or flush the file. We have to be careful to check for
1044 error here. Checking the result of fwrite() is not enough --
1045 errors could go unnoticed! */
1047 if (!opt.dfp || con->cmd & DO_LIST)
1048 flush_res = fclose (fp);
1050 flush_res = fflush (fp);
1051 if (flush_res == EOF)
1055 /* If get_contents couldn't write to fp, bail out. */
1058 logprintf (LOG_NOTQUIET, _("%s: %s, closing control connection.\n"),
1059 con->target, strerror (errno));
1061 rbuf_uninitialize (&con->rbuf);
1066 logprintf (LOG_NOTQUIET, _("%s (%s) - Data connection: %s; "),
1067 tms, tmrate, strerror (errno));
1068 if (opt.server_response)
1069 logputs (LOG_ALWAYS, "\n");
1072 /* Get the server to tell us if everything is retrieved. */
1073 err = ftp_response (&con->rbuf, &respline);
1074 /* ...and empty the buffer. */
1075 rbuf_discard (&con->rbuf);
1079 /* The control connection is decidedly closed. Print the time
1080 only if it hasn't already been printed. */
1082 logprintf (LOG_NOTQUIET, "%s (%s) - ", tms, tmrate);
1083 logputs (LOG_NOTQUIET, _("Control connection closed.\n"));
1084 /* If there is an error on the control connection, close it, but
1085 return FTPRETRINT, since there is a possibility that the
1086 whole file was retrieved nevertheless (but that is for
1087 ftp_loop_internal to decide). */
1089 rbuf_uninitialize (&con->rbuf);
1091 } /* err != FTPOK */
1092 /* If retrieval failed for any reason, return FTPRETRINT, but do not
1093 close socket, since the control connection is still alive. If
1094 there is something wrong with the control connection, it will
1095 become apparent later. */
1096 if (*respline != '2')
1100 logprintf (LOG_NOTQUIET, "%s (%s) - ", tms, tmrate);
1101 logputs (LOG_NOTQUIET, _("Data transfer aborted.\n"));
1108 /* What now? The data connection was erroneous, whereas the
1109 response says everything is OK. We shall play it safe. */
1113 if (!(cmd & LEAVE_PENDING))
1115 /* I should probably send 'QUIT' and check for a reply, but this
1116 is faster. #### Is it OK, though? */
1118 rbuf_uninitialize (&con->rbuf);
1120 /* If it was a listing, and opt.server_response is true,
1122 if (opt.server_response && (con->cmd & DO_LIST))
1124 mkalldirs (con->target);
1125 fp = fopen (con->target, "r");
1127 logprintf (LOG_ALWAYS, "%s: %s\n", con->target, strerror (errno));
1131 /* The lines are being read with read_whole_line because of
1132 no-buffering on opt.lfile. */
1133 while ((line = read_whole_line (fp)))
1135 logprintf (LOG_ALWAYS, "%s\n", line);
1140 } /* con->cmd & DO_LIST && server_response */
1142 return RETRFINISHED;
1145 /* A one-file FTP loop. This is the part where FTP retrieval is
1146 retried, and retried, and retried, and...
1148 This loop either gets commands from con, or (if ON_YOUR_OWN is
1149 set), makes them up to retrieve the file given by the URL. */
1151 ftp_loop_internal (struct url *u, struct fileinfo *f, ccon *con)
1156 char *tmrate = NULL;
1161 con->target = url_file_name (u);
1163 if (opt.noclobber && file_exists_p (con->target))
1165 logprintf (LOG_VERBOSE,
1166 _("File `%s' already there, not retrieving.\n"), con->target);
1167 /* If the file is there, we suppose it's retrieved OK. */
1171 /* Remove it if it's a link. */
1172 remove_link (con->target);
1173 if (!opt.output_document)
1176 locf = opt.output_document;
1180 if (con->st & ON_YOUR_OWN)
1181 con->st = ON_YOUR_OWN;
1183 orig_lp = con->cmd & LEAVE_PENDING ? 1 : 0;
1188 /* Increment the pass counter. */
1190 sleep_between_retrievals (count);
1191 if (con->st & ON_YOUR_OWN)
1194 con->cmd |= (DO_RETR | LEAVE_PENDING);
1195 if (rbuf_initialized_p (&con->rbuf))
1196 con->cmd &= ~ (DO_LOGIN | DO_CWD);
1198 con->cmd |= (DO_LOGIN | DO_CWD);
1200 else /* not on your own */
1202 if (rbuf_initialized_p (&con->rbuf))
1203 con->cmd &= ~DO_LOGIN;
1205 con->cmd |= DO_LOGIN;
1206 if (con->st & DONE_CWD)
1207 con->cmd &= ~DO_CWD;
1212 /* Assume no restarting. */
1214 if ((count > 1 || opt.always_rest)
1215 && !(con->cmd & DO_LIST)
1216 && file_exists_p (locf))
1217 if (stat (locf, &st) == 0 && S_ISREG (st.st_mode))
1218 restval = st.st_size;
1220 /* In `-c' is used, check whether the file we're writing to
1221 exists and is of non-zero length. If so, we'll refuse to
1222 truncate it if the server doesn't support continued
1224 if (opt.always_rest && restval > 0)
1225 con->cmd |= NO_TRUNCATE;
1227 /* Get the current time string. */
1228 tms = time_str (NULL);
1229 /* Print fetch message, if opt.verbose. */
1232 char *hurl = url_string (u, 1);
1236 sprintf (tmp, _("(try:%2d)"), count);
1237 logprintf (LOG_VERBOSE, "--%s-- %s\n %s => `%s'\n",
1238 tms, hurl, tmp, locf);
1240 ws_changetitle (hurl, 1);
1244 /* Send getftp the proper length, if fileinfo was provided. */
1249 err = getftp (u, &len, restval, con);
1251 if (!rbuf_initialized_p (&con->rbuf))
1252 con->st &= ~DONE_CWD;
1254 con->st |= DONE_CWD;
1258 case HOSTERR: case CONIMPOSSIBLE: case FWRITEERR: case FOPENERR:
1259 case FTPNSFOD: case FTPLOGINC: case FTPNOPASV: case CONTNOTSUPPORTED:
1260 /* Fatal errors, give up. */
1263 case CONSOCKERR: case CONERROR: case FTPSRVERR: case FTPRERR:
1264 case WRITEFAILED: case FTPUNKNOWNTYPE: case FTPSYSERR:
1265 case FTPPORTERR: case FTPLOGREFUSED: case FTPINVPASV:
1266 printwhat (count, opt.ntry);
1267 /* non-fatal errors */
1271 /* If the control connection was closed, the retrieval
1272 will be considered OK if f->size == len. */
1273 if (!f || len != f->size)
1275 printwhat (count, opt.ntry);
1287 tms = time_str (NULL);
1289 tmrate = retr_rate (len - restval, con->dltime, 0);
1291 /* If we get out of the switch above without continue'ing, we've
1292 successfully downloaded a file. Remember this fact. */
1293 downloaded_file (FILE_DOWNLOADED_NORMALLY, locf);
1295 if (con->st & ON_YOUR_OWN)
1297 xclose (RBUF_FD (&con->rbuf));
1298 rbuf_uninitialize (&con->rbuf);
1301 logprintf (LOG_VERBOSE, _("%s (%s) - `%s' saved [%ld]\n\n"),
1302 tms, tmrate, locf, len);
1303 if (!opt.verbose && !opt.quiet)
1305 /* Need to hide the password from the URL. The `if' is here
1306 so that we don't do the needless allocation every
1308 char *hurl = url_string (u, 1);
1309 logprintf (LOG_NONVERBOSE, "%s URL: %s [%ld] -> \"%s\" [%d]\n",
1310 tms, hurl, len, locf, count);
1314 if ((con->cmd & DO_LIST))
1315 /* This is a directory listing file. */
1317 if (!opt.remove_listing)
1318 /* --dont-remove-listing was specified, so do count this towards the
1319 number of bytes and files downloaded. */
1321 total_downloaded_bytes += len;
1325 /* Deletion of listing files is not controlled by --delete-after, but
1326 by the more specific option --dont-remove-listing, and the code
1327 to do this deletion is in another function. */
1329 else if (!opt.spider)
1330 /* This is not a directory listing file. */
1332 /* Unlike directory listing files, don't pretend normal files weren't
1333 downloaded if they're going to be deleted. People seeding proxies,
1334 for instance, may want to know how many bytes and files they've
1335 downloaded through it. */
1336 total_downloaded_bytes += len;
1339 if (opt.delete_after)
1341 DEBUGP (("Removing file due to --delete-after in"
1342 " ftp_loop_internal():\n"));
1343 logprintf (LOG_VERBOSE, _("Removing %s.\n"), locf);
1345 logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1349 /* Restore the original leave-pendingness. */
1351 con->cmd |= LEAVE_PENDING;
1353 con->cmd &= ~LEAVE_PENDING;
1355 } while (!opt.ntry || (count < opt.ntry));
1357 if (rbuf_initialized_p (&con->rbuf) && (con->st & ON_YOUR_OWN))
1359 xclose (RBUF_FD (&con->rbuf));
1360 rbuf_uninitialize (&con->rbuf);
1365 /* Return the directory listing in a reusable format. The directory
1366 is specifed in u->dir. */
1368 ftp_get_listing (struct url *u, ccon *con, struct fileinfo **f)
1371 char *uf; /* url file name */
1372 char *lf; /* list file name */
1373 char *old_target = con->target;
1375 con->st &= ~ON_YOUR_OWN;
1376 con->cmd |= (DO_LIST | LEAVE_PENDING);
1377 con->cmd &= ~DO_RETR;
1379 /* Find the listing file name. We do it by taking the file name of
1380 the URL and replacing the last component with the listing file
1382 uf = url_file_name (u);
1383 lf = file_merge (uf, LIST_FILENAME);
1385 DEBUGP ((_("Using `%s' as listing tmp file.\n"), lf));
1388 err = ftp_loop_internal (u, NULL, con);
1389 con->target = old_target;
1392 *f = ftp_parse_ls (lf, con->rs);
1395 if (opt.remove_listing)
1398 logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1400 logprintf (LOG_VERBOSE, _("Removed `%s'.\n"), lf);
1403 con->cmd &= ~DO_LIST;
1407 static uerr_t ftp_retrieve_dirs PARAMS ((struct url *, struct fileinfo *,
1409 static uerr_t ftp_retrieve_glob PARAMS ((struct url *, ccon *, int));
1410 static struct fileinfo *delelement PARAMS ((struct fileinfo *,
1411 struct fileinfo **));
1412 static void freefileinfo PARAMS ((struct fileinfo *f));
1414 /* Retrieve a list of files given in struct fileinfo linked list. If
1415 a file is a symbolic link, do not retrieve it, but rather try to
1416 set up a similar link on the local disk, if the symlinks are
1419 If opt.recursive is set, after all files have been retrieved,
1420 ftp_retrieve_dirs will be called to retrieve the directories. */
1422 ftp_retrieve_list (struct url *u, struct fileinfo *f, ccon *con)
1424 static int depth = 0;
1426 struct fileinfo *orig;
1431 /* Increase the depth. */
1433 if (opt.reclevel != INFINITE_RECURSION && depth > opt.reclevel)
1435 DEBUGP ((_("Recursion depth %d exceeded max. depth %d.\n"),
1436 depth, opt.reclevel));
1444 con->st &= ~ON_YOUR_OWN;
1445 if (!(con->st & DONE_CWD))
1448 con->cmd &= ~DO_CWD;
1449 con->cmd |= (DO_RETR | LEAVE_PENDING);
1451 if (!rbuf_initialized_p (&con->rbuf))
1452 con->cmd |= DO_LOGIN;
1454 con->cmd &= ~DO_LOGIN;
1456 err = RETROK; /* in case it's not used */
1460 char *old_target, *ofile;
1462 if (opt.quota && total_downloaded_bytes > opt.quota)
1467 old_target = con->target;
1469 ofile = xstrdup (u->file);
1470 url_set_file (u, f->name);
1472 con->target = url_file_name (u);
1476 if (opt.timestamping && f->type == FT_PLAINFILE)
1479 /* If conversion of HTML files retrieved via FTP is ever implemented,
1480 we'll need to stat() <file>.orig here when -K has been specified.
1481 I'm not implementing it now since files on an FTP server are much
1482 more likely than files on an HTTP server to legitimately have a
1484 if (!stat (con->target, &st))
1488 /* Else, get it from the file. */
1489 local_size = st.st_size;
1492 /* Modification time granularity is 2 seconds for Windows, so
1493 increase local time by 1 second for later comparison. */
1496 /* Compare file sizes only for servers that tell us correct
1497 values. Assumme sizes being equal for servers that lie
1499 cor_val = (con->rs == ST_UNIX || con->rs == ST_WINNT);
1500 eq_size = cor_val ? (local_size == f->size) : 1 ;
1501 if (f->tstamp <= tml && eq_size)
1503 /* Remote file is older, file sizes can be compared and
1505 logprintf (LOG_VERBOSE, _("\
1506 Remote file no newer than local file `%s' -- not retrieving.\n"), con->target);
1511 /* Remote file is newer or sizes cannot be matched */
1512 logprintf (LOG_VERBOSE, _("\
1513 Remote file is newer than local file `%s' -- retrieving.\n\n"),
1518 /* Sizes do not match */
1519 logprintf (LOG_VERBOSE, _("\
1520 The sizes do not match (local %ld) -- retrieving.\n\n"), local_size);
1523 } /* opt.timestamping && f->type == FT_PLAINFILE */
1527 /* If opt.retr_symlinks is defined, we treat symlinks as
1528 if they were normal files. There is currently no way
1529 to distinguish whether they might be directories, and
1531 if (!opt.retr_symlinks)
1535 logputs (LOG_NOTQUIET,
1536 _("Invalid name of the symlink, skipping.\n"));
1540 /* Check whether we already have the correct
1542 int rc = lstat (con->target, &st);
1545 size_t len = strlen (f->linkto) + 1;
1546 if (S_ISLNK (st.st_mode))
1548 char *link_target = (char *)alloca (len);
1549 size_t n = readlink (con->target, link_target, len);
1551 && (memcmp (link_target, f->linkto, n) == 0))
1553 logprintf (LOG_VERBOSE, _("\
1554 Already have correct symlink %s -> %s\n\n"),
1555 con->target, f->linkto);
1561 logprintf (LOG_VERBOSE, _("Creating symlink %s -> %s\n"),
1562 con->target, f->linkto);
1563 /* Unlink before creating symlink! */
1564 unlink (con->target);
1565 if (symlink (f->linkto, con->target) == -1)
1566 logprintf (LOG_NOTQUIET, "symlink: %s\n",
1568 logputs (LOG_VERBOSE, "\n");
1569 } /* have f->linkto */
1570 #else /* not HAVE_SYMLINK */
1571 logprintf (LOG_NOTQUIET,
1572 _("Symlinks not supported, skipping symlink `%s'.\n"),
1574 #endif /* not HAVE_SYMLINK */
1576 else /* opt.retr_symlinks */
1579 err = ftp_loop_internal (u, f, con);
1580 } /* opt.retr_symlinks */
1584 logprintf (LOG_NOTQUIET, _("Skipping directory `%s'.\n"),
1588 /* Call the retrieve loop. */
1590 err = ftp_loop_internal (u, f, con);
1593 logprintf (LOG_NOTQUIET, _("%s: unknown/unsupported file type.\n"),
1598 /* Set the time-stamp information to the local file. Symlinks
1599 are not to be stamped because it sets the stamp on the
1601 if (!(f->type == FT_SYMLINK && !opt.retr_symlinks)
1604 && file_exists_p (con->target))
1606 /* #### This code repeats in http.c and ftp.c. Move it to a
1608 const char *fl = NULL;
1609 if (opt.output_document)
1611 if (opt.od_known_regular)
1612 fl = opt.output_document;
1617 touch (fl, f->tstamp);
1619 else if (f->tstamp == -1)
1620 logprintf (LOG_NOTQUIET, _("%s: corrupt time-stamp.\n"), con->target);
1622 if (f->perms && f->type == FT_PLAINFILE && dlthis)
1624 if (opt.preserve_perm)
1625 chmod (con->target, f->perms);
1628 DEBUGP (("Unrecognized permissions for %s.\n", con->target));
1630 xfree (con->target);
1631 con->target = old_target;
1633 url_set_file (u, ofile);
1636 /* Break on fatals. */
1637 if (err == QUOTEXC || err == HOSTERR || err == FWRITEERR)
1639 con->cmd &= ~ (DO_CWD | DO_LOGIN);
1643 /* We do not want to call ftp_retrieve_dirs here */
1644 if (opt.recursive &&
1645 !(opt.reclevel != INFINITE_RECURSION && depth >= opt.reclevel))
1646 err = ftp_retrieve_dirs (u, orig, con);
1647 else if (opt.recursive)
1648 DEBUGP ((_("Will not retrieve dirs since depth is %d (max %d).\n"),
1649 depth, opt.reclevel));
1654 /* Retrieve the directories given in a file list. This function works
1655 by simply going through the linked list and calling
1656 ftp_retrieve_glob on each directory entry. The function knows
1657 about excluded directories. */
1659 ftp_retrieve_dirs (struct url *u, struct fileinfo *f, ccon *con)
1661 char *container = NULL;
1662 int container_size = 0;
1664 for (; f; f = f->next)
1667 char *odir, *newdir;
1669 if (opt.quota && total_downloaded_bytes > opt.quota)
1671 if (f->type != FT_DIRECTORY)
1674 /* Allocate u->dir off stack, but reallocate only if a larger
1675 string is needed. It's a pity there's no "realloca" for an
1676 item on the bottom of the stack. */
1677 size = strlen (u->dir) + 1 + strlen (f->name) + 1;
1678 if (size > container_size)
1679 container = (char *)alloca (size);
1684 || (*odir == '/' && *(odir + 1) == '\0'))
1685 /* If ODIR is empty or just "/", simply append f->name to
1686 ODIR. (In the former case, to preserve u->dir being
1687 relative; in the latter case, to avoid double slash.) */
1688 sprintf (newdir, "%s%s", odir, f->name);
1690 /* Else, use a separator. */
1691 sprintf (newdir, "%s/%s", odir, f->name);
1693 DEBUGP (("Composing new CWD relative to the initial directory.\n"));
1694 DEBUGP ((" odir = '%s'\n f->name = '%s'\n newdir = '%s'\n\n",
1695 odir, f->name, newdir));
1696 if (!accdir (newdir, ALLABS))
1698 logprintf (LOG_VERBOSE, _("\
1699 Not descending to `%s' as it is excluded/not-included.\n"), newdir);
1703 con->st &= ~DONE_CWD;
1705 odir = xstrdup (u->dir); /* because url_set_dir will free
1707 url_set_dir (u, newdir);
1708 ftp_retrieve_glob (u, con, GETALL);
1709 url_set_dir (u, odir);
1712 /* Set the time-stamp? */
1715 if (opt.quota && total_downloaded_bytes > opt.quota)
1721 /* Return non-zero if S has a leading '/' or contains '../' */
1723 has_insecure_name_p (const char *s)
1728 if (strstr(s, "../") != 0)
1734 /* A near-top-level function to retrieve the files in a directory.
1735 The function calls ftp_get_listing, to get a linked list of files.
1736 Then it weeds out the file names that do not match the pattern.
1737 ftp_retrieve_list is called with this updated list as an argument.
1739 If the argument ACTION is GETONE, just download the file (but first
1740 get the listing, so that the time-stamp is heeded); if it's GLOBALL,
1741 use globbing; if it's GETALL, download the whole directory. */
1743 ftp_retrieve_glob (struct url *u, ccon *con, int action)
1745 struct fileinfo *f, *start;
1748 con->cmd |= LEAVE_PENDING;
1750 res = ftp_get_listing (u, con, &start);
1753 /* First: weed out that do not conform the global rules given in
1754 opt.accepts and opt.rejects. */
1755 if (opt.accepts || opt.rejects)
1760 if (f->type != FT_DIRECTORY && !acceptable (f->name))
1762 logprintf (LOG_VERBOSE, _("Rejecting `%s'.\n"), f->name);
1763 f = delelement (f, &start);
1769 /* Remove all files with possible harmful names */
1773 if (has_insecure_name_p (f->name))
1775 logprintf (LOG_VERBOSE, _("Rejecting `%s'.\n"), f->name);
1776 f = delelement (f, &start);
1781 /* Now weed out the files that do not match our globbing pattern.
1782 If we are dealing with a globbing pattern, that is. */
1783 if (*u->file && (action == GLOBALL || action == GETONE))
1790 matchres = fnmatch (u->file, f->name, 0);
1793 logprintf (LOG_NOTQUIET, "%s: %s\n", con->target,
1797 if (matchres == FNM_NOMATCH)
1798 f = delelement (f, &start); /* delete the element from the list */
1800 f = f->next; /* leave the element in the list */
1804 freefileinfo (start);
1805 return RETRBADPATTERN;
1811 /* Just get everything. */
1812 ftp_retrieve_list (u, start, con);
1816 if (action == GLOBALL)
1819 /* #### This message SUCKS. We should see what was the
1820 reason that nothing was retrieved. */
1821 logprintf (LOG_VERBOSE, _("No matches on pattern `%s'.\n"), u->file);
1823 else /* GETONE or GETALL */
1825 /* Let's try retrieving it anyway. */
1826 con->st |= ON_YOUR_OWN;
1827 res = ftp_loop_internal (u, NULL, con);
1831 freefileinfo (start);
1832 if (opt.quota && total_downloaded_bytes > opt.quota)
1835 /* #### Should we return `res' here? */
1839 /* The wrapper that calls an appropriate routine according to contents
1840 of URL. Inherently, its capabilities are limited on what can be
1841 encoded into a URL. */
1843 ftp_loop (struct url *u, int *dt, struct url *proxy)
1845 ccon con; /* FTP connection */
1850 memset (&con, 0, sizeof (con));
1852 rbuf_uninitialize (&con.rbuf);
1853 con.st = ON_YOUR_OWN;
1857 res = RETROK; /* in case it's not used */
1859 /* If the file name is empty, the user probably wants a directory
1860 index. We'll provide one, properly HTML-ized. Unless
1861 opt.htmlify is 0, of course. :-) */
1862 if (!*u->file && !opt.recursive)
1865 res = ftp_get_listing (u, &con, &f);
1869 if (opt.htmlify && !opt.spider)
1871 char *filename = (opt.output_document
1872 ? xstrdup (opt.output_document)
1873 : (con.target ? xstrdup (con.target)
1874 : url_file_name (u)));
1875 res = ftp_index (filename, u, f);
1876 if (res == FTPOK && opt.verbose)
1878 if (!opt.output_document)
1882 if (stat (filename, &st) == 0)
1886 logprintf (LOG_NOTQUIET,
1887 _("Wrote HTML-ized index to `%s' [%ld].\n"),
1891 logprintf (LOG_NOTQUIET,
1892 _("Wrote HTML-ized index to `%s'.\n"),
1902 int wild = has_wildcards_p (u->file);
1903 if ((opt.ftp_glob && wild) || opt.recursive || opt.timestamping)
1905 /* ftp_retrieve_glob is a catch-all function that gets called
1906 if we need globbing, time-stamping or recursion. Its
1907 third argument is just what we really need. */
1908 res = ftp_retrieve_glob (u, &con,
1909 (opt.ftp_glob && wild) ? GLOBALL : GETONE);
1912 res = ftp_loop_internal (u, NULL, &con);
1918 /* If a connection was left, quench it. */
1919 if (rbuf_initialized_p (&con.rbuf))
1920 xclose (RBUF_FD (&con.rbuf));
1921 xfree_null (con.id);
1923 xfree_null (con.target);
1928 /* Delete an element from the fileinfo linked list. Returns the
1929 address of the next element, or NULL if the list is exhausted. It
1930 can modify the start of the list. */
1931 static struct fileinfo *
1932 delelement (struct fileinfo *f, struct fileinfo **start)
1934 struct fileinfo *prev = f->prev;
1935 struct fileinfo *next = f->next;
1938 xfree_null (f->linkto);
1950 /* Free the fileinfo linked list of files. */
1952 freefileinfo (struct fileinfo *f)
1956 struct fileinfo *next = f->next;