sjero.net Git - wget/blob - src/ftp.c

   1 /* File Transfer Protocol support.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3    2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Wget.
   6
   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 3 of the License, or
  10 (at your option) any later version.
  11
  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.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Wget.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 Additional permission under GNU GPL version 3 section 7
  21
  22 If you modify this program, or any covered work, by linking or
  23 combining it with the OpenSSL project's OpenSSL library (or a
  24 modified version of that library), containing parts covered by the
  25 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
  26 grants you additional permission to convey the resulting work.
  27 Corresponding Source for a non-source form of such a combination
  28 shall include the source code for the parts of OpenSSL used as well
  29 as that of the covered work.  */
  30
  31 #include "wget.h"
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #ifdef HAVE_UNISTD_H
  37 # include <unistd.h>
  38 #endif
  39 #include <assert.h>
  40 #include <errno.h>
  41 #include <time.h>
  42
  43 #include "utils.h"
  44 #include "url.h"
  45 #include "retr.h"
  46 #include "ftp.h"
  47 #include "connect.h"
  48 #include "host.h"
  49 #include "netrc.h"
  50 #include "convert.h"            /* for downloaded_file */
  51 #include "recur.h"              /* for INFINITE_RECURSION */
  52
  53 #ifdef __VMS
  54 # include "vms.h"
  55 #endif /* def __VMS */
  56
  57
  58 /* File where the "ls -al" listing will be saved.  */
  59 #ifdef MSDOS
  60 #define LIST_FILENAME "_listing"
  61 #else
  62 #define LIST_FILENAME ".listing"
  63 #endif
  64
  65 typedef struct
  66 {
  67   int st;                       /* connection status */
  68   int cmd;                      /* command code */
  69   int csock;                    /* control connection socket */
  70   double dltime;                /* time of the download in msecs */
  71   enum stype rs;                /* remote system reported by ftp server */
  72   char *id;                     /* initial directory */
  73   char *target;                 /* target file name */
  74   struct url *proxy;            /* FTWK-style proxy */
  75 } ccon;
  76
  77 extern int numurls;
  78
  79 /* Look for regexp "( *[0-9]+ *byte" (literal parenthesis) anywhere in
  80    the string S, and return the number converted to wgint, if found, 0
  81    otherwise.  */
  82 static wgint
  83 ftp_expected_bytes (const char *s)
  84 {
  85   wgint res;
  86
  87   while (1)
  88     {
  89       while (*s && *s != '(')
  90         ++s;
  91       if (!*s)
  92         return 0;
  93       ++s;                      /* skip the '(' */
  94       res = str_to_wgint (s, (char **) &s, 10);
  95       if (!*s)
  96         return 0;
  97       while (*s && c_isspace (*s))
  98         ++s;
  99       if (!*s)
 100         return 0;
 101       if (c_tolower (*s) != 'b')
 102         continue;
 103       if (strncasecmp (s, "byte", 4))
 104         continue;
 105       else
 106         break;
 107     }
 108   return res;
 109 }
 110
 111 #ifdef ENABLE_IPV6
 112 /*
 113  * This function sets up a passive data connection with the FTP server.
 114  * It is merely a wrapper around ftp_epsv, ftp_lpsv and ftp_pasv.
 115  */
 116 static uerr_t
 117 ftp_do_pasv (int csock, ip_address *addr, int *port)
 118 {
 119   uerr_t err;
 120
 121   /* We need to determine the address family and need to call
 122      getpeername, so while we're at it, store the address to ADDR.
 123      ftp_pasv and ftp_lpsv can simply override it.  */
 124   if (!socket_ip_address (csock, addr, ENDPOINT_PEER))
 125     abort ();
 126
 127   /* If our control connection is over IPv6, then we first try EPSV and then
 128    * LPSV if the former is not supported. If the control connection is over
 129    * IPv4, we simply issue the good old PASV request. */
 130   switch (addr->family)
 131     {
 132     case AF_INET:
 133       if (!opt.server_response)
 134         logputs (LOG_VERBOSE, "==> PASV ... ");
 135       err = ftp_pasv (csock, addr, port);
 136       break;
 137     case AF_INET6:
 138       if (!opt.server_response)
 139         logputs (LOG_VERBOSE, "==> EPSV ... ");
 140       err = ftp_epsv (csock, addr, port);
 141
 142       /* If EPSV is not supported try LPSV */
 143       if (err == FTPNOPASV)
 144         {
 145           if (!opt.server_response)
 146             logputs (LOG_VERBOSE, "==> LPSV ... ");
 147           err = ftp_lpsv (csock, addr, port);
 148         }
 149       break;
 150     default:
 151       abort ();
 152     }
 153
 154   return err;
 155 }
 156
 157 /*
 158  * This function sets up an active data connection with the FTP server.
 159  * It is merely a wrapper around ftp_eprt, ftp_lprt and ftp_port.
 160  */
 161 static uerr_t
 162 ftp_do_port (int csock, int *local_sock)
 163 {
 164   uerr_t err;
 165   ip_address cip;
 166
 167   if (!socket_ip_address (csock, &cip, ENDPOINT_PEER))
 168     abort ();
 169
 170   /* If our control connection is over IPv6, then we first try EPRT and then
 171    * LPRT if the former is not supported. If the control connection is over
 172    * IPv4, we simply issue the good old PORT request. */
 173   switch (cip.family)
 174     {
 175     case AF_INET:
 176       if (!opt.server_response)
 177         logputs (LOG_VERBOSE, "==> PORT ... ");
 178       err = ftp_port (csock, local_sock);
 179       break;
 180     case AF_INET6:
 181       if (!opt.server_response)
 182         logputs (LOG_VERBOSE, "==> EPRT ... ");
 183       err = ftp_eprt (csock, local_sock);
 184
 185       /* If EPRT is not supported try LPRT */
 186       if (err == FTPPORTERR)
 187         {
 188           if (!opt.server_response)
 189             logputs (LOG_VERBOSE, "==> LPRT ... ");
 190           err = ftp_lprt (csock, local_sock);
 191         }
 192       break;
 193     default:
 194       abort ();
 195     }
 196   return err;
 197 }
 198 #else
 199
 200 static uerr_t
 201 ftp_do_pasv (int csock, ip_address *addr, int *port)
 202 {
 203   if (!opt.server_response)
 204     logputs (LOG_VERBOSE, "==> PASV ... ");
 205   return ftp_pasv (csock, addr, port);
 206 }
 207
 208 static uerr_t
 209 ftp_do_port (int csock, int *local_sock)
 210 {
 211   if (!opt.server_response)
 212     logputs (LOG_VERBOSE, "==> PORT ... ");
 213   return ftp_port (csock, local_sock);
 214 }
 215 #endif
 216
 217 static void
 218 print_length (wgint size, wgint start, bool authoritative)
 219 {
 220   logprintf (LOG_VERBOSE, _("Length: %s"), number_to_static_string (size));
 221   if (size >= 1024)
 222     logprintf (LOG_VERBOSE, " (%s)", human_readable (size));
 223   if (start > 0)
 224     {
 225       if (size - start >= 1024)
 226         logprintf (LOG_VERBOSE, _(", %s (%s) remaining"),
 227                    number_to_static_string (size - start),
 228                    human_readable (size - start));
 229       else
 230         logprintf (LOG_VERBOSE, _(", %s remaining"),
 231                    number_to_static_string (size - start));
 232     }
 233   logputs (LOG_VERBOSE, !authoritative ? _(" (unauthoritative)\n") : "\n");
 234 }
 235
 236 static uerr_t ftp_get_listing (struct url *, ccon *, struct fileinfo **);
 237
 238 /* Retrieves a file with denoted parameters through opening an FTP
 239    connection to the server.  It always closes the data connection,
 240    and closes the control connection in case of error.  */
 241 static uerr_t
 242 getftp (struct url *u, wgint *len, wgint restval, ccon *con)
 243 {
 244   int csock, dtsock, local_sock, res;
 245   uerr_t err = RETROK;          /* appease the compiler */
 246   FILE *fp;
 247   char *user, *passwd, *respline;
 248   char *tms;
 249   const char *tmrate;
 250   int cmd = con->cmd;
 251   bool pasv_mode_open = false;
 252   wgint expected_bytes = 0;
 253   bool rest_failed = false;
 254   int flags;
 255   wgint rd_size;
 256   char type_char;
 257
 258   assert (con != NULL);
 259   assert (con->target != NULL);
 260
 261   /* Debug-check of the sanity of the request by making sure that LIST
 262      and RETR are never both requested (since we can handle only one
 263      at a time.  */
 264   assert (!((cmd & DO_LIST) && (cmd & DO_RETR)));
 265   /* Make sure that at least *something* is requested.  */
 266   assert ((cmd & (DO_LIST | DO_CWD | DO_RETR | DO_LOGIN)) != 0);
 267
 268   user = u->user;
 269   passwd = u->passwd;
 270   search_netrc (u->host, (const char **)&user, (const char **)&passwd, 1);
 271   user = user ? user : (opt.ftp_user ? opt.ftp_user : opt.user);
 272   if (!user) user = "anonymous";
 273   passwd = passwd ? passwd : (opt.ftp_passwd ? opt.ftp_passwd : opt.passwd);
 274   if (!passwd) passwd = "-wget@";
 275
 276   dtsock = -1;
 277   local_sock = -1;
 278   con->dltime = 0;
 279
 280   if (!(cmd & DO_LOGIN))
 281     csock = con->csock;
 282   else                          /* cmd & DO_LOGIN */
 283     {
 284       char    *host = con->proxy ? con->proxy->host : u->host;
 285       int      port = con->proxy ? con->proxy->port : u->port;
 286       char *logname = user;
 287
 288       if (con->proxy)
 289         {
 290           /* If proxy is in use, log in as username@target-site. */
 291           logname = concat_strings (user, "@", u->host, (char *) 0);
 292         }
 293
 294       /* Login to the server: */
 295
 296       /* First: Establish the control connection.  */
 297
 298       csock = connect_to_host (host, port);
 299       if (csock == E_HOST)
 300         return HOSTERR;
 301       else if (csock < 0)
 302         return (retryable_socket_connect_error (errno)
 303                 ? CONERROR : CONIMPOSSIBLE);
 304
 305       if (cmd & LEAVE_PENDING)
 306         con->csock = csock;
 307       else
 308         con->csock = -1;
 309
 310       /* Second: Login with proper USER/PASS sequence.  */
 311       logprintf (LOG_VERBOSE, _("Logging in as %s ... "),
 312                  quotearg_style (escape_quoting_style, user));
 313       if (opt.server_response)
 314         logputs (LOG_ALWAYS, "\n");
 315       err = ftp_login (csock, logname, passwd);
 316
 317       if (con->proxy)
 318         xfree (logname);
 319
 320       /* FTPRERR, FTPSRVERR, WRITEFAILED, FTPLOGREFUSED, FTPLOGINC */
 321       switch (err)
 322         {
 323         case FTPRERR:
 324           logputs (LOG_VERBOSE, "\n");
 325           logputs (LOG_NOTQUIET, _("\
 326 Error in server response, closing control connection.\n"));
 327           fd_close (csock);
 328           con->csock = -1;
 329           return err;
 330         case FTPSRVERR:
 331           logputs (LOG_VERBOSE, "\n");
 332           logputs (LOG_NOTQUIET, _("Error in server greeting.\n"));
 333           fd_close (csock);
 334           con->csock = -1;
 335           return err;
 336         case WRITEFAILED:
 337           logputs (LOG_VERBOSE, "\n");
 338           logputs (LOG_NOTQUIET,
 339                    _("Write failed, closing control connection.\n"));
 340           fd_close (csock);
 341           con->csock = -1;
 342           return err;
 343         case FTPLOGREFUSED:
 344           logputs (LOG_VERBOSE, "\n");
 345           logputs (LOG_NOTQUIET, _("The server refuses login.\n"));
 346           fd_close (csock);
 347           con->csock = -1;
 348           return FTPLOGREFUSED;
 349         case FTPLOGINC:
 350           logputs (LOG_VERBOSE, "\n");
 351           logputs (LOG_NOTQUIET, _("Login incorrect.\n"));
 352           fd_close (csock);
 353           con->csock = -1;
 354           return FTPLOGINC;
 355         case FTPOK:
 356           if (!opt.server_response)
 357             logputs (LOG_VERBOSE, _("Logged in!\n"));
 358           break;
 359         default:
 360           abort ();
 361         }
 362       /* Third: Get the system type */
 363       if (!opt.server_response)
 364         logprintf (LOG_VERBOSE, "==> SYST ... ");
 365       err = ftp_syst (csock, &con->rs);
 366       /* FTPRERR */
 367       switch (err)
 368         {
 369         case FTPRERR:
 370           logputs (LOG_VERBOSE, "\n");
 371           logputs (LOG_NOTQUIET, _("\
 372 Error in server response, closing control connection.\n"));
 373           fd_close (csock);
 374           con->csock = -1;
 375           return err;
 376         case FTPSRVERR:
 377           logputs (LOG_VERBOSE, "\n");
 378           logputs (LOG_NOTQUIET,
 379                    _("Server error, can't determine system type.\n"));
 380           break;
 381         case FTPOK:
 382           /* Everything is OK.  */
 383           break;
 384         default:
 385           abort ();
 386         }
 387       if (!opt.server_response && err != FTPSRVERR)
 388         logputs (LOG_VERBOSE, _("done.    "));
 389
 390       /* Fourth: Find the initial ftp directory */
 391
 392       if (!opt.server_response)
 393         logprintf (LOG_VERBOSE, "==> PWD ... ");
 394       err = ftp_pwd (csock, &con->id);
 395       /* FTPRERR */
 396       switch (err)
 397         {
 398         case FTPRERR:
 399           logputs (LOG_VERBOSE, "\n");
 400           logputs (LOG_NOTQUIET, _("\
 401 Error in server response, closing control connection.\n"));
 402           fd_close (csock);
 403           con->csock = -1;
 404           return err;
 405         case FTPSRVERR :
 406           /* PWD unsupported -- assume "/". */
 407           xfree_null (con->id);
 408           con->id = xstrdup ("/");
 409           break;
 410         case FTPOK:
 411           /* Everything is OK.  */
 412           break;
 413         default:
 414           abort ();
 415         }
 416
 417 #if 0
 418       /* 2004-09-17 SMS.
 419          Don't help me out.  Please.
 420          A reasonably recent VMS FTP server will cope just fine with
 421          UNIX file specifications.  This code just spoils things.
 422          Discarding the device name, for example, is not a wise move.
 423          This code was disabled but left in as an example of what not
 424          to do.
 425       */
 426
 427       /* VMS will report something like "PUB$DEVICE:[INITIAL.FOLDER]".
 428          Convert it to "/INITIAL/FOLDER" */
 429       if (con->rs == ST_VMS)
 430         {
 431           char *path = strchr (con->id, '[');
 432           char *pathend = path ? strchr (path + 1, ']') : NULL;
 433           if (!path || !pathend)
 434             DEBUGP (("Initial VMS directory not in the form [...]!\n"));
 435           else
 436             {
 437               char *idir = con->id;
 438               DEBUGP (("Preprocessing the initial VMS directory\n"));
 439               DEBUGP (("  old = '%s'\n", con->id));
 440               /* We do the conversion in-place by copying the stuff
 441                  between [ and ] to the beginning, and changing dots
 442                  to slashes at the same time.  */
 443               *idir++ = '/';
 444               for (++path; path < pathend; path++, idir++)
 445                 *idir = *path == '.' ? '/' : *path;
 446               *idir = '\0';
 447               DEBUGP (("  new = '%s'\n\n", con->id));
 448             }
 449         }
 450 #endif /* 0 */
 451
 452       if (!opt.server_response)
 453         logputs (LOG_VERBOSE, _("done.\n"));
 454
 455       /* Fifth: Set the FTP type.  */
 456       type_char = ftp_process_type (u->params);
 457       if (!opt.server_response)
 458         logprintf (LOG_VERBOSE, "==> TYPE %c ... ", type_char);
 459       err = ftp_type (csock, type_char);
 460       /* FTPRERR, WRITEFAILED, FTPUNKNOWNTYPE */
 461       switch (err)
 462         {
 463         case FTPRERR:
 464           logputs (LOG_VERBOSE, "\n");
 465           logputs (LOG_NOTQUIET, _("\
 466 Error in server response, closing control connection.\n"));
 467           fd_close (csock);
 468           con->csock = -1;
 469           return err;
 470         case WRITEFAILED:
 471           logputs (LOG_VERBOSE, "\n");
 472           logputs (LOG_NOTQUIET,
 473                    _("Write failed, closing control connection.\n"));
 474           fd_close (csock);
 475           con->csock = -1;
 476           return err;
 477         case FTPUNKNOWNTYPE:
 478           logputs (LOG_VERBOSE, "\n");
 479           logprintf (LOG_NOTQUIET,
 480                      _("Unknown type `%c', closing control connection.\n"),
 481                      type_char);
 482           fd_close (csock);
 483           con->csock = -1;
 484           return err;
 485         case FTPOK:
 486           /* Everything is OK.  */
 487           break;
 488         default:
 489           abort ();
 490         }
 491       if (!opt.server_response)
 492         logputs (LOG_VERBOSE, _("done.  "));
 493     } /* do login */
 494
 495   if (cmd & DO_CWD)
 496     {
 497       if (!*u->dir)
 498         logputs (LOG_VERBOSE, _("==> CWD not needed.\n"));
 499       else
 500         {
 501           char *targ;
 502           int cwd_count;
 503           int cwd_end;
 504           int cwd_start;
 505
 506           char *target = u->dir;
 507
 508           DEBUGP (("changing working directory\n"));
 509
 510           /* Change working directory.  To change to a non-absolute
 511              Unix directory, we need to prepend initial directory
 512              (con->id) to it.  Absolute directories "just work".
 513
 514              A relative directory is one that does not begin with '/'
 515              and, on non-Unix OS'es, one that doesn't begin with
 516              "[a-z]:".
 517
 518              This is not done for OS400, which doesn't use
 519              "/"-delimited directories, nor does it support directory
 520              hierarchies.  "CWD foo" followed by "CWD bar" leaves us
 521              in "bar", not in "foo/bar", as would be customary
 522              elsewhere.  */
 523
 524             /* 2004-09-20 SMS.
 525                Why is this wise even on UNIX?  It certainly fouls VMS.
 526                See below for a more reliable, more universal method.
 527             */
 528
 529             /* 2008-04-22 MJC.
 530                I'm not crazy about it either. I'm informed it's useful
 531                for misconfigured servers that have some dirs in the path
 532                with +x but -r, but this method is not RFC-conformant. I
 533                understand the need to deal with crappy server
 534                configurations, but it's far better to use the canonical
 535                method first, and fall back to kludges second.
 536             */
 537
 538           if (target[0] != '/'
 539               && !(con->rs != ST_UNIX
 540                    && c_isalpha (target[0])
 541                    && target[1] == ':')
 542               && (con->rs != ST_OS400)
 543               && (con->rs != ST_VMS))
 544             {
 545               int idlen = strlen (con->id);
 546               char *ntarget, *p;
 547
 548               /* Strip trailing slash(es) from con->id. */
 549               while (idlen > 0 && con->id[idlen - 1] == '/')
 550                 --idlen;
 551               p = ntarget = (char *)alloca (idlen + 1 + strlen (u->dir) + 1);
 552               memcpy (p, con->id, idlen);
 553               p += idlen;
 554               *p++ = '/';
 555               strcpy (p, target);
 556
 557               DEBUGP (("Prepended initial PWD to relative path:\n"));
 558               DEBUGP (("   pwd: '%s'\n   old: '%s'\n  new: '%s'\n",
 559                        con->id, target, ntarget));
 560               target = ntarget;
 561             }
 562
 563 #if 0
 564           /* 2004-09-17 SMS.
 565              Don't help me out.  Please.
 566              A reasonably recent VMS FTP server will cope just fine with
 567              UNIX file specifications.  This code just spoils things.
 568              Discarding the device name, for example, is not a wise
 569              move.
 570              This code was disabled but left in as an example of what
 571              not to do.
 572           */
 573
 574           /* If the FTP host runs VMS, we will have to convert the absolute
 575              directory path in UNIX notation to absolute directory path in
 576              VMS notation as VMS FTP servers do not like UNIX notation of
 577              absolute paths.  "VMS notation" is [dir.subdir.subsubdir]. */
 578
 579           if (con->rs == ST_VMS)
 580             {
 581               char *tmpp;
 582               char *ntarget = (char *)alloca (strlen (target) + 2);
 583               /* We use a converted initial dir, so directories in
 584                  TARGET will be separated with slashes, something like
 585                  "/INITIAL/FOLDER/DIR/SUBDIR".  Convert that to
 586                  "[INITIAL.FOLDER.DIR.SUBDIR]".  */
 587               strcpy (ntarget, target);
 588               assert (*ntarget == '/');
 589               *ntarget = '[';
 590               for (tmpp = ntarget + 1; *tmpp; tmpp++)
 591                 if (*tmpp == '/')
 592                   *tmpp = '.';
 593               *tmpp++ = ']';
 594               *tmpp = '\0';
 595               DEBUGP (("Changed file name to VMS syntax:\n"));
 596               DEBUGP (("  Unix: '%s'\n  VMS: '%s'\n", target, ntarget));
 597               target = ntarget;
 598             }
 599 #endif /* 0 */
 600
 601           /* 2004-09-20 SMS.
 602              A relative directory is relative to the initial directory.
 603              Thus, what _is_ useful on VMS (and probably elsewhere) is
 604              to CWD to the initial directory (ideally, whatever the
 605              server reports, _exactly_, NOT badly UNIX-ixed), and then
 606              CWD to the (new) relative directory.  This should probably
 607              be restructured as a function, called once or twice, but
 608              I'm lazy enough to take the badly indented loop short-cut
 609              for now.
 610           */
 611
 612           /* Decide on one pass (absolute) or two (relative).
 613              The VMS restriction may be relaxed when the squirrely code
 614              above is reformed.
 615           */
 616           if ((con->rs == ST_VMS) && (target[0] != '/'))
 617             {
 618               cwd_start = 0;
 619               DEBUGP (("Using two-step CWD for relative path.\n"));
 620             }
 621           else
 622             {
 623               /* Go straight to the target. */
 624               cwd_start = 1;
 625             }
 626
 627           /* At least one VMS FTP server (TCPware V5.6-2) can switch to
 628              a UNIX emulation mode when given a UNIX-like directory
 629              specification (like "a/b/c").  If allowed to continue this
 630              way, LIST interpretation will be confused, because the
 631              system type (SYST response) will not be re-checked, and
 632              future UNIX-format directory listings (for multiple URLs or
 633              "-r") will be horribly misinterpreted.
 634
 635              The cheap and nasty work-around is to do a "CWD []" after a
 636              UNIX-like directory specification is used.  (A single-level
 637              directory is harmless.)  This puts the TCPware server back
 638              into VMS mode, and does no harm on other servers.
 639
 640              Unlike the rest of this block, this particular behavior
 641              _is_ VMS-specific, so it gets its own VMS test.
 642           */
 643           if ((con->rs == ST_VMS) && (strchr( target, '/') != NULL))
 644             {
 645               cwd_end = 3;
 646               DEBUGP (("Using extra \"CWD []\" step for VMS server.\n"));
 647             }
 648           else
 649             {
 650               cwd_end = 2;
 651             }
 652
 653           /* 2004-09-20 SMS. */
 654           /* Sorry about the deviant indenting.  Laziness. */
 655
 656           for (cwd_count = cwd_start; cwd_count < cwd_end; cwd_count++)
 657         {
 658           switch (cwd_count)
 659             {
 660               case 0:
 661                 /* Step one (optional): Go to the initial directory,
 662                    exactly as reported by the server.
 663                 */
 664                 targ = con->id;
 665                 break;
 666
 667               case 1:
 668                 /* Step two: Go to the target directory.  (Absolute or
 669                    relative will work now.)
 670                 */
 671                 targ = target;
 672                 break;
 673
 674               case 2:
 675                 /* Step three (optional): "CWD []" to restore server
 676                    VMS-ness.
 677                 */
 678                 targ = "[]";
 679                 break;
 680
 681               default:
 682                 /* Can't happen. */
 683                 assert (1);
 684             }
 685
 686           if (!opt.server_response)
 687             logprintf (LOG_VERBOSE, "==> CWD (%d) %s ... ", cwd_count,
 688                        quotearg_style (escape_quoting_style, target));
 689           err = ftp_cwd (csock, target);
 690           /* FTPRERR, WRITEFAILED, FTPNSFOD */
 691           switch (err)
 692             {
 693             case FTPRERR:
 694               logputs (LOG_VERBOSE, "\n");
 695               logputs (LOG_NOTQUIET, _("\
 696 Error in server response, closing control connection.\n"));
 697               fd_close (csock);
 698               con->csock = -1;
 699               return err;
 700             case WRITEFAILED:
 701               logputs (LOG_VERBOSE, "\n");
 702               logputs (LOG_NOTQUIET,
 703                        _("Write failed, closing control connection.\n"));
 704               fd_close (csock);
 705               con->csock = -1;
 706               return err;
 707             case FTPNSFOD:
 708               logputs (LOG_VERBOSE, "\n");
 709               logprintf (LOG_NOTQUIET, _("No such directory %s.\n\n"),
 710                          quote (u->dir));
 711               fd_close (csock);
 712               con->csock = -1;
 713               return err;
 714             case FTPOK:
 715               break;
 716             default:
 717               abort ();
 718             }
 719           if (!opt.server_response)
 720             logputs (LOG_VERBOSE, _("done.\n"));
 721
 722         } /* for */
 723
 724           /* 2004-09-20 SMS. */
 725           /* End of deviant indenting. */
 726
 727         } /* else */
 728     }
 729   else /* do not CWD */
 730     logputs (LOG_VERBOSE, _("==> CWD not required.\n"));
 731
 732   if ((cmd & DO_RETR) && *len == 0)
 733     {
 734       if (opt.verbose)
 735         {
 736           if (!opt.server_response)
 737             logprintf (LOG_VERBOSE, "==> SIZE %s ... ",
 738                        quotearg_style (escape_quoting_style, u->file));
 739         }
 740
 741       err = ftp_size (csock, u->file, len);
 742       /* FTPRERR */
 743       switch (err)
 744         {
 745         case FTPRERR:
 746         case FTPSRVERR:
 747           logputs (LOG_VERBOSE, "\n");
 748           logputs (LOG_NOTQUIET, _("\
 749 Error in server response, closing control connection.\n"));
 750           fd_close (csock);
 751           con->csock = -1;
 752           return err;
 753         case FTPOK:
 754           /* Everything is OK.  */
 755           break;
 756         default:
 757           abort ();
 758         }
 759         if (!opt.server_response)
 760           logprintf (LOG_VERBOSE, *len ? "%s\n" : _("done.\n"),
 761                      number_to_static_string (*len));
 762     }
 763
 764   /* If anything is to be retrieved, PORT (or PASV) must be sent.  */
 765   if (cmd & (DO_LIST | DO_RETR))
 766     {
 767       if (opt.ftp_pasv)
 768         {
 769           ip_address passive_addr;
 770           int        passive_port;
 771           err = ftp_do_pasv (csock, &passive_addr, &passive_port);
 772           /* FTPRERR, WRITEFAILED, FTPNOPASV, FTPINVPASV */
 773           switch (err)
 774             {
 775             case FTPRERR:
 776               logputs (LOG_VERBOSE, "\n");
 777               logputs (LOG_NOTQUIET, _("\
 778 Error in server response, closing control connection.\n"));
 779               fd_close (csock);
 780               con->csock = -1;
 781               return err;
 782             case WRITEFAILED:
 783               logputs (LOG_VERBOSE, "\n");
 784               logputs (LOG_NOTQUIET,
 785                        _("Write failed, closing control connection.\n"));
 786               fd_close (csock);
 787               con->csock = -1;
 788               return err;
 789             case FTPNOPASV:
 790               logputs (LOG_VERBOSE, "\n");
 791               logputs (LOG_NOTQUIET, _("Cannot initiate PASV transfer.\n"));
 792               break;
 793             case FTPINVPASV:
 794               logputs (LOG_VERBOSE, "\n");
 795               logputs (LOG_NOTQUIET, _("Cannot parse PASV response.\n"));
 796               break;
 797             case FTPOK:
 798               break;
 799             default:
 800               abort ();
 801             }   /* switch (err) */
 802           if (err==FTPOK)
 803             {
 804               DEBUGP (("trying to connect to %s port %d\n",
 805                       print_address (&passive_addr), passive_port));
 806               dtsock = connect_to_ip (&passive_addr, passive_port, NULL);
 807               if (dtsock < 0)
 808                 {
 809                   int save_errno = errno;
 810                   fd_close (csock);
 811                   con->csock = -1;
 812                   logprintf (LOG_VERBOSE, _("couldn't connect to %s port %d: %s\n"),
 813                              print_address (&passive_addr), passive_port,
 814                              strerror (save_errno));
 815                   return (retryable_socket_connect_error (save_errno)
 816                           ? CONERROR : CONIMPOSSIBLE);
 817                 }
 818
 819               pasv_mode_open = true;  /* Flag to avoid accept port */
 820               if (!opt.server_response)
 821                 logputs (LOG_VERBOSE, _("done.    "));
 822             } /* err==FTP_OK */
 823         }
 824
 825       if (!pasv_mode_open)   /* Try to use a port command if PASV failed */
 826         {
 827           err = ftp_do_port (csock, &local_sock);
 828           /* FTPRERR, WRITEFAILED, bindport (FTPSYSERR), HOSTERR,
 829              FTPPORTERR */
 830           switch (err)
 831             {
 832             case FTPRERR:
 833               logputs (LOG_VERBOSE, "\n");
 834               logputs (LOG_NOTQUIET, _("\
 835 Error in server response, closing control connection.\n"));
 836               fd_close (csock);
 837               con->csock = -1;
 838               fd_close (dtsock);
 839               fd_close (local_sock);
 840               return err;
 841             case WRITEFAILED:
 842               logputs (LOG_VERBOSE, "\n");
 843               logputs (LOG_NOTQUIET,
 844                        _("Write failed, closing control connection.\n"));
 845               fd_close (csock);
 846               con->csock = -1;
 847               fd_close (dtsock);
 848               fd_close (local_sock);
 849               return err;
 850             case CONSOCKERR:
 851               logputs (LOG_VERBOSE, "\n");
 852               logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
 853               fd_close (csock);
 854               con->csock = -1;
 855               fd_close (dtsock);
 856               fd_close (local_sock);
 857               return err;
 858             case FTPSYSERR:
 859               logputs (LOG_VERBOSE, "\n");
 860               logprintf (LOG_NOTQUIET, _("Bind error (%s).\n"),
 861                          strerror (errno));
 862               fd_close (dtsock);
 863               return err;
 864             case FTPPORTERR:
 865               logputs (LOG_VERBOSE, "\n");
 866               logputs (LOG_NOTQUIET, _("Invalid PORT.\n"));
 867               fd_close (csock);
 868               con->csock = -1;
 869               fd_close (dtsock);
 870               fd_close (local_sock);
 871               return err;
 872             case FTPOK:
 873               break;
 874             default:
 875               abort ();
 876             } /* port switch */
 877           if (!opt.server_response)
 878             logputs (LOG_VERBOSE, _("done.    "));
 879         } /* dtsock == -1 */
 880     } /* cmd & (DO_LIST | DO_RETR) */
 881
 882   /* Restart if needed.  */
 883   if (restval && (cmd & DO_RETR))
 884     {
 885       if (!opt.server_response)
 886         logprintf (LOG_VERBOSE, "==> REST %s ... ",
 887                    number_to_static_string (restval));
 888       err = ftp_rest (csock, restval);
 889
 890       /* FTPRERR, WRITEFAILED, FTPRESTFAIL */
 891       switch (err)
 892         {
 893         case FTPRERR:
 894           logputs (LOG_VERBOSE, "\n");
 895           logputs (LOG_NOTQUIET, _("\
 896 Error in server response, closing control connection.\n"));
 897           fd_close (csock);
 898           con->csock = -1;
 899           fd_close (dtsock);
 900           fd_close (local_sock);
 901           return err;
 902         case WRITEFAILED:
 903           logputs (LOG_VERBOSE, "\n");
 904           logputs (LOG_NOTQUIET,
 905                    _("Write failed, closing control connection.\n"));
 906           fd_close (csock);
 907           con->csock = -1;
 908           fd_close (dtsock);
 909           fd_close (local_sock);
 910           return err;
 911         case FTPRESTFAIL:
 912           logputs (LOG_VERBOSE, _("\nREST failed, starting from scratch.\n"));
 913           rest_failed = true;
 914           break;
 915         case FTPOK:
 916           break;
 917         default:
 918           abort ();
 919         }
 920       if (err != FTPRESTFAIL && !opt.server_response)
 921         logputs (LOG_VERBOSE, _("done.    "));
 922     } /* restval && cmd & DO_RETR */
 923
 924   if (cmd & DO_RETR)
 925     {
 926       /* If we're in spider mode, don't really retrieve anything except
 927          the directory listing and verify whether the given "file" exists.  */
 928       if (opt.spider)
 929         {
 930           bool exists = false;
 931           uerr_t res;
 932           struct fileinfo *f;
 933           res = ftp_get_listing (u, con, &f);
 934           /* Set the DO_RETR command flag again, because it gets unset when
 935              calling ftp_get_listing() and would otherwise cause an assertion
 936              failure earlier on when this function gets repeatedly called
 937              (e.g., when recursing).  */
 938           con->cmd |= DO_RETR;
 939           if (res == RETROK)
 940             {
 941               while (f)
 942                 {
 943                   if (!strcmp (f->name, u->file))
 944                     {
 945                       exists = true;
 946                       break;
 947                     }
 948                   f = f->next;
 949                 }
 950               if (exists)
 951                 {
 952                   logputs (LOG_VERBOSE, "\n");
 953                   logprintf (LOG_NOTQUIET, _("File %s exists.\n"),
 954                              quote (u->file));
 955                 }
 956               else
 957                 {
 958                   logputs (LOG_VERBOSE, "\n");
 959                   logprintf (LOG_NOTQUIET, _("No such file %s.\n"),
 960                              quote (u->file));
 961                 }
 962             }
 963           fd_close (csock);
 964           con->csock = -1;
 965           fd_close (dtsock);
 966           fd_close (local_sock);
 967           return RETRFINISHED;
 968         }
 969
 970       if (opt.verbose)
 971         {
 972           if (!opt.server_response)
 973             {
 974               if (restval)
 975                 logputs (LOG_VERBOSE, "\n");
 976               logprintf (LOG_VERBOSE, "==> RETR %s ... ",
 977                          quotearg_style (escape_quoting_style, u->file));
 978             }
 979         }
 980
 981       err = ftp_retr (csock, u->file);
 982       /* FTPRERR, WRITEFAILED, FTPNSFOD */
 983       switch (err)
 984         {
 985         case FTPRERR:
 986           logputs (LOG_VERBOSE, "\n");
 987           logputs (LOG_NOTQUIET, _("\
 988 Error in server response, closing control connection.\n"));
 989           fd_close (csock);
 990           con->csock = -1;
 991           fd_close (dtsock);
 992           fd_close (local_sock);
 993           return err;
 994         case WRITEFAILED:
 995           logputs (LOG_VERBOSE, "\n");
 996           logputs (LOG_NOTQUIET,
 997                    _("Write failed, closing control connection.\n"));
 998           fd_close (csock);
 999           con->csock = -1;
1000           fd_close (dtsock);
1001           fd_close (local_sock);
1002           return err;
1003         case FTPNSFOD:
1004           logputs (LOG_VERBOSE, "\n");
1005           logprintf (LOG_NOTQUIET, _("No such file %s.\n\n"),
1006                      quote (u->file));
1007           fd_close (dtsock);
1008           fd_close (local_sock);
1009           return err;
1010         case FTPOK:
1011           if (getenv( "FTP_DELETE") != NULL)
1012           {
1013             err = ftp_dele (csock, u->file);
1014           }
1015           break;
1016         default:
1017           abort ();
1018         }
1019
1020       if (!opt.server_response)
1021         logputs (LOG_VERBOSE, _("done.\n"));
1022       expected_bytes = ftp_expected_bytes (ftp_last_respline);
1023     } /* do retrieve */
1024
1025   if (cmd & DO_LIST)
1026     {
1027       if (!opt.server_response)
1028         logputs (LOG_VERBOSE, "==> LIST ... ");
1029       /* As Maciej W. Rozycki (macro@ds2.pg.gda.pl) says, `LIST'
1030          without arguments is better than `LIST .'; confirmed by
1031          RFC959.  */
1032       err = ftp_list (csock, NULL, con->rs);
1033       /* FTPRERR, WRITEFAILED */
1034       switch (err)
1035         {
1036         case FTPRERR:
1037           logputs (LOG_VERBOSE, "\n");
1038           logputs (LOG_NOTQUIET, _("\
1039 Error in server response, closing control connection.\n"));
1040           fd_close (csock);
1041           con->csock = -1;
1042           fd_close (dtsock);
1043           fd_close (local_sock);
1044           return err;
1045         case WRITEFAILED:
1046           logputs (LOG_VERBOSE, "\n");
1047           logputs (LOG_NOTQUIET,
1048                    _("Write failed, closing control connection.\n"));
1049           fd_close (csock);
1050           con->csock = -1;
1051           fd_close (dtsock);
1052           fd_close (local_sock);
1053           return err;
1054         case FTPNSFOD:
1055           logputs (LOG_VERBOSE, "\n");
1056           logprintf (LOG_NOTQUIET, _("No such file or directory %s.\n\n"),
1057                      quote ("."));
1058           fd_close (dtsock);
1059           fd_close (local_sock);
1060           return err;
1061         case FTPOK:
1062           break;
1063         default:
1064           abort ();
1065         }
1066       if (!opt.server_response)
1067         logputs (LOG_VERBOSE, _("done.\n"));
1068       expected_bytes = ftp_expected_bytes (ftp_last_respline);
1069     } /* cmd & DO_LIST */
1070
1071   if (!(cmd & (DO_LIST | DO_RETR)) || (opt.spider && !(cmd & DO_LIST)))
1072     return RETRFINISHED;
1073
1074   /* Some FTP servers return the total length of file after REST
1075      command, others just return the remaining size. */
1076   if (*len && restval && expected_bytes
1077       && (expected_bytes == *len - restval))
1078     {
1079       DEBUGP (("Lying FTP server found, adjusting.\n"));
1080       expected_bytes = *len;
1081     }
1082
1083   /* If no transmission was required, then everything is OK.  */
1084   if (!pasv_mode_open)  /* we are not using pasive mode so we need
1085                               to accept */
1086     {
1087       /* Wait for the server to connect to the address we're waiting
1088          at.  */
1089       dtsock = accept_connection (local_sock);
1090       if (dtsock < 0)
1091         {
1092           logprintf (LOG_NOTQUIET, "accept: %s\n", strerror (errno));
1093           return CONERROR;
1094         }
1095     }
1096
1097   /* Open the file -- if output_stream is set, use it instead.  */
1098
1099   /* 2005-04-17 SMS.
1100      Note that having the output_stream ("-O") file opened in main()
1101      (main.c) rather limits the ability in VMS to open the file
1102      differently for ASCII versus binary FTP here.  (Of course, doing it
1103      there allows a open failure to be detected immediately, without first
1104      connecting to the server.)
1105   */
1106   if (!output_stream || con->cmd & DO_LIST)
1107     {
1108 /* On VMS, alter the name as required. */
1109 #ifdef __VMS
1110       char *targ;
1111
1112       targ = ods_conform( con->target);
1113       if (targ != con->target)
1114         {
1115           xfree( con->target);
1116           con->target = targ;
1117         }
1118 #endif /* def __VMS */
1119
1120       mkalldirs (con->target);
1121       if (opt.backups)
1122         rotate_backups (con->target);
1123
1124 /* 2005-04-15 SMS.
1125    For VMS, define common fopen() optional arguments, and a handy macro
1126    for use as a variable "binary" flag.
1127    Elsewhere, define a constant "binary" flag.
1128    Isn't it nice to have distinct text and binary file types?
1129 */
1130 # define BIN_TYPE_TRANSFER (type_char != 'A')
1131 #ifdef __VMS
1132 # define FOPEN_OPT_ARGS "fop=sqo", "acc", acc_cb, &open_id
1133 # define FOPEN_OPT_ARGS_BIN "ctx=bin,stm", "rfm=fix", "mrs=512" FOPEN_OPT_ARGS
1134 # define BIN_TYPE_FILE (BIN_TYPE_TRANSFER && (opt.ftp_stmlf == 0))
1135 #else /* def __VMS */
1136 # define BIN_TYPE_FILE 1
1137 #endif /* def __VMS [else] */
1138
1139       if (restval && !(con->cmd & DO_LIST))
1140         {
1141 #ifdef __VMS
1142           int open_id;
1143
1144           if (BIN_TYPE_FILE)
1145             {
1146               open_id = 3;
1147               fp = fopen (con->target, "ab", FOPEN_OPT_ARGS_BIN);
1148             }
1149           else
1150             {
1151               open_id = 4;
1152               fp = fopen (con->target, "a", FOPEN_OPT_ARGS);
1153             }
1154 #else /* def __VMS */
1155           fp = fopen (con->target, "ab");
1156 #endif /* def __VMS [else] */
1157         }
1158       else if (opt.noclobber || opt.always_rest || opt.timestamping || opt.dirstruct
1159                || opt.output_document)
1160         {
1161 #ifdef __VMS
1162           int open_id;
1163
1164           if (BIN_TYPE_FILE)
1165             {
1166               open_id = 5;
1167               fp = fopen (con->target, "wb", FOPEN_OPT_ARGS_BIN);
1168             }
1169           else
1170             {
1171               open_id = 6;
1172               fp = fopen (con->target, "w", FOPEN_OPT_ARGS);
1173             }
1174 #else /* def __VMS */
1175           fp = fopen (con->target, "wb");
1176 #endif /* def __VMS [else] */
1177         }
1178       else
1179         {
1180           fp = fopen_excl (con->target, true);
1181           if (!fp && errno == EEXIST)
1182             {
1183               /* We cannot just invent a new name and use it (which is
1184                  what functions like unique_create typically do)
1185                  because we told the user we'd use this name.
1186                  Instead, return and retry the download.  */
1187               logprintf (LOG_NOTQUIET, _("%s has sprung into existence.\n"),
1188                          con->target);
1189               fd_close (csock);
1190               con->csock = -1;
1191               fd_close (dtsock);
1192               fd_close (local_sock);
1193               return FOPEN_EXCL_ERR;
1194             }
1195         }
1196       if (!fp)
1197         {
1198           logprintf (LOG_NOTQUIET, "%s: %s\n", con->target, strerror (errno));
1199           fd_close (csock);
1200           con->csock = -1;
1201           fd_close (dtsock);
1202           fd_close (local_sock);
1203           return FOPENERR;
1204         }
1205     }
1206   else
1207     fp = output_stream;
1208
1209   if (*len)
1210     {
1211       print_length (*len, restval, true);
1212       expected_bytes = *len;    /* for fd_read_body's progress bar */
1213     }
1214   else if (expected_bytes)
1215     print_length (expected_bytes, restval, false);
1216
1217   /* Get the contents of the document.  */
1218   flags = 0;
1219   if (restval && rest_failed)
1220     flags |= rb_skip_startpos;
1221   *len = restval;
1222   rd_size = 0;
1223   res = fd_read_body (dtsock, fp,
1224                       expected_bytes ? expected_bytes - restval : 0,
1225                       restval, &rd_size, len, &con->dltime, flags);
1226
1227   tms = datetime_str (time (NULL));
1228   tmrate = retr_rate (rd_size, con->dltime);
1229   total_download_time += con->dltime;
1230
1231   fd_close (local_sock);
1232   /* Close the local file.  */
1233   if (!output_stream || con->cmd & DO_LIST)
1234     fclose (fp);
1235
1236   /* If fd_read_body couldn't write to fp, bail out.  */
1237   if (res == -2)
1238     {
1239       logprintf (LOG_NOTQUIET, _("%s: %s, closing control connection.\n"),
1240                  con->target, strerror (errno));
1241       fd_close (csock);
1242       con->csock = -1;
1243       fd_close (dtsock);
1244       return FWRITEERR;
1245     }
1246   else if (res == -1)
1247     {
1248       logprintf (LOG_NOTQUIET, _("%s (%s) - Data connection: %s; "),
1249                  tms, tmrate, fd_errstr (dtsock));
1250       if (opt.server_response)
1251         logputs (LOG_ALWAYS, "\n");
1252     }
1253   fd_close (dtsock);
1254
1255   /* Get the server to tell us if everything is retrieved.  */
1256   err = ftp_response (csock, &respline);
1257   if (err != FTPOK)
1258     {
1259       /* The control connection is decidedly closed.  Print the time
1260          only if it hasn't already been printed.  */
1261       if (res != -1)
1262         logprintf (LOG_NOTQUIET, "%s (%s) - ", tms, tmrate);
1263       logputs (LOG_NOTQUIET, _("Control connection closed.\n"));
1264       /* If there is an error on the control connection, close it, but
1265          return FTPRETRINT, since there is a possibility that the
1266          whole file was retrieved nevertheless (but that is for
1267          ftp_loop_internal to decide).  */
1268       fd_close (csock);
1269       con->csock = -1;
1270       return FTPRETRINT;
1271     } /* err != FTPOK */
1272   /* If retrieval failed for any reason, return FTPRETRINT, but do not
1273      close socket, since the control connection is still alive.  If
1274      there is something wrong with the control connection, it will
1275      become apparent later.  */
1276   if (*respline != '2')
1277     {
1278       xfree (respline);
1279       if (res != -1)
1280         logprintf (LOG_NOTQUIET, "%s (%s) - ", tms, tmrate);
1281       logputs (LOG_NOTQUIET, _("Data transfer aborted.\n"));
1282       return FTPRETRINT;
1283     }
1284   xfree (respline);
1285
1286   if (res == -1)
1287     {
1288       /* What now?  The data connection was erroneous, whereas the
1289          response says everything is OK.  We shall play it safe.  */
1290       return FTPRETRINT;
1291     }
1292
1293   if (!(cmd & LEAVE_PENDING))
1294     {
1295       /* Closing the socket is faster than sending 'QUIT' and the
1296          effect is the same.  */
1297       fd_close (csock);
1298       con->csock = -1;
1299     }
1300   /* If it was a listing, and opt.server_response is true,
1301      print it out.  */
1302   if (opt.server_response && (con->cmd & DO_LIST))
1303     {
1304 /* 2005-02-25 SMS.
1305    Much of this work may already have been done, but repeating it should
1306    do no damage beyond wasting time.
1307 */
1308 /* On VMS, alter the name as required. */
1309 #ifdef __VMS
1310       char *targ;
1311
1312       targ = ods_conform( con->target);
1313       if (targ != con->target)
1314         {
1315           xfree( con->target);
1316           con->target = targ;
1317         }
1318 #endif /* def __VMS */
1319
1320       mkalldirs (con->target);
1321       fp = fopen (con->target, "r");
1322       if (!fp)
1323         logprintf (LOG_ALWAYS, "%s: %s\n", con->target, strerror (errno));
1324       else
1325         {
1326           char *line;
1327           /* The lines are being read with read_whole_line because of
1328              no-buffering on opt.lfile.  */
1329           while ((line = read_whole_line (fp)) != NULL)
1330             {
1331               char *p = strchr (line, '\0');
1332               while (p > line && (p[-1] == '\n' || p[-1] == '\r'))
1333                 *--p = '\0';
1334               logprintf (LOG_ALWAYS, "%s\n",
1335                          quotearg_style (escape_quoting_style, line));
1336               xfree (line);
1337             }
1338           fclose (fp);
1339         }
1340     } /* con->cmd & DO_LIST && server_response */
1341
1342   return RETRFINISHED;
1343 }
1344
1345 /* A one-file FTP loop.  This is the part where FTP retrieval is
1346    retried, and retried, and retried, and...
1347
1348    This loop either gets commands from con, or (if ON_YOUR_OWN is
1349    set), makes them up to retrieve the file given by the URL.  */
1350 static uerr_t
1351 ftp_loop_internal (struct url *u, struct fileinfo *f, ccon *con)
1352 {
1353   int count, orig_lp;
1354   wgint restval, len = 0;
1355   char *tms, *locf;
1356   const char *tmrate = NULL;
1357   uerr_t err;
1358   struct_stat st;
1359
1360   /* Get the target, and set the name for the message accordingly. */
1361   if ((f == NULL) && (con->target))
1362     {
1363       /* Explicit file (like ".listing"). */
1364       locf = con->target;
1365     }
1366   else
1367     {
1368       /* URL-derived file.  Consider "-O file" name. */
1369       con->target = url_file_name (u);
1370       if (!opt.output_document)
1371         locf = con->target;
1372       else
1373         locf = opt.output_document;
1374     }
1375
1376   /* If the output_document was given, then this check was already done and
1377      the file didn't exist. Hence the !opt.output_document */
1378   if (opt.noclobber && !opt.output_document && file_exists_p (con->target))
1379     {
1380       logprintf (LOG_VERBOSE,
1381                  _("File %s already there; not retrieving.\n"), quote (con->target));
1382       /* If the file is there, we suppose it's retrieved OK.  */
1383       return RETROK;
1384     }
1385
1386   /* Remove it if it's a link.  */
1387   remove_link (con->target);
1388
1389   count = 0;
1390
1391   if (con->st & ON_YOUR_OWN)
1392     con->st = ON_YOUR_OWN;
1393
1394   orig_lp = con->cmd & LEAVE_PENDING ? 1 : 0;
1395
1396   /* THE loop.  */
1397   do
1398     {
1399       /* Increment the pass counter.  */
1400       ++count;
1401       sleep_between_retrievals (count);
1402       if (con->st & ON_YOUR_OWN)
1403         {
1404           con->cmd = 0;
1405           con->cmd |= (DO_RETR | LEAVE_PENDING);
1406           if (con->csock != -1)
1407             con->cmd &= ~ (DO_LOGIN | DO_CWD);
1408           else
1409             con->cmd |= (DO_LOGIN | DO_CWD);
1410         }
1411       else /* not on your own */
1412         {
1413           if (con->csock != -1)
1414             con->cmd &= ~DO_LOGIN;
1415           else
1416             con->cmd |= DO_LOGIN;
1417           if (con->st & DONE_CWD)
1418             con->cmd &= ~DO_CWD;
1419           else
1420             con->cmd |= DO_CWD;
1421         }
1422
1423       /* Decide whether or not to restart.  */
1424       if (con->cmd & DO_LIST)
1425         restval = 0;
1426       else if (opt.always_rest
1427           && stat (locf, &st) == 0
1428           && S_ISREG (st.st_mode))
1429         /* When -c is used, continue from on-disk size.  (Can't use
1430            hstat.len even if count>1 because we don't want a failed
1431            first attempt to clobber existing data.)  */
1432         restval = st.st_size;
1433       else if (count > 1)
1434         restval = len;          /* start where the previous run left off */
1435       else
1436         restval = 0;
1437
1438       /* Get the current time string.  */
1439       tms = datetime_str (time (NULL));
1440       /* Print fetch message, if opt.verbose.  */
1441       if (opt.verbose)
1442         {
1443           char *hurl = url_string (u, URL_AUTH_HIDE_PASSWD);
1444           char tmp[256];
1445           strcpy (tmp, "        ");
1446           if (count > 1)
1447             sprintf (tmp, _("(try:%2d)"), count);
1448           logprintf (LOG_VERBOSE, "--%s--  %s\n  %s => %s\n",
1449                      tms, hurl, tmp, quote (locf));
1450 #ifdef WINDOWS
1451           ws_changetitle (hurl);
1452 #endif
1453           xfree (hurl);
1454         }
1455       /* Send getftp the proper length, if fileinfo was provided.  */
1456       if (f)
1457         len = f->size;
1458       else
1459         len = 0;
1460       err = getftp (u, &len, restval, con);
1461
1462       if (con->csock == -1)
1463         con->st &= ~DONE_CWD;
1464       else
1465         con->st |= DONE_CWD;
1466
1467       switch (err)
1468         {
1469         case HOSTERR: case CONIMPOSSIBLE: case FWRITEERR: case FOPENERR:
1470         case FTPNSFOD: case FTPLOGINC: case FTPNOPASV: case CONTNOTSUPPORTED:
1471           /* Fatal errors, give up.  */
1472           return err;
1473         case CONSOCKERR: case CONERROR: case FTPSRVERR: case FTPRERR:
1474         case WRITEFAILED: case FTPUNKNOWNTYPE: case FTPSYSERR:
1475         case FTPPORTERR: case FTPLOGREFUSED: case FTPINVPASV:
1476         case FOPEN_EXCL_ERR:
1477           printwhat (count, opt.ntry);
1478           /* non-fatal errors */
1479           if (err == FOPEN_EXCL_ERR)
1480             {
1481               /* Re-determine the file name. */
1482               xfree_null (con->target);
1483               con->target = url_file_name (u);
1484               locf = con->target;
1485             }
1486           continue;
1487         case FTPRETRINT:
1488           /* If the control connection was closed, the retrieval
1489              will be considered OK if f->size == len.  */
1490           if (!f || len != f->size)
1491             {
1492               printwhat (count, opt.ntry);
1493               continue;
1494             }
1495           break;
1496         case RETRFINISHED:
1497           /* Great!  */
1498           break;
1499         default:
1500           /* Not as great.  */
1501           abort ();
1502         }
1503       tms = datetime_str (time (NULL));
1504       if (!opt.spider)
1505         tmrate = retr_rate (len - restval, con->dltime);
1506
1507       /* If we get out of the switch above without continue'ing, we've
1508          successfully downloaded a file.  Remember this fact. */
1509       downloaded_file (FILE_DOWNLOADED_NORMALLY, locf);
1510
1511       if (con->st & ON_YOUR_OWN)
1512         {
1513           fd_close (con->csock);
1514           con->csock = -1;
1515         }
1516       if (!opt.spider)
1517         {
1518           bool write_to_stdout = (opt.output_document && HYPHENP (opt.output_document));
1519
1520           logprintf (LOG_VERBOSE,
1521                      write_to_stdout
1522                      ? _("%s (%s) - written to stdout %s[%s]\n\n")
1523                      : _("%s (%s) - %s saved [%s]\n\n"),
1524                      tms, tmrate,
1525                      write_to_stdout ? "" : quote (locf),
1526                      number_to_static_string (len));
1527         }
1528       if (!opt.verbose && !opt.quiet)
1529         {
1530           /* Need to hide the password from the URL.  The `if' is here
1531              so that we don't do the needless allocation every
1532              time. */
1533           char *hurl = url_string (u, URL_AUTH_HIDE_PASSWD);
1534           logprintf (LOG_NONVERBOSE, "%s URL: %s [%s] -> \"%s\" [%d]\n",
1535                      tms, hurl, number_to_static_string (len), locf, count);
1536           xfree (hurl);
1537         }
1538
1539       if ((con->cmd & DO_LIST))
1540         /* This is a directory listing file. */
1541         {
1542           if (!opt.remove_listing)
1543             /* --dont-remove-listing was specified, so do count this towards the
1544                number of bytes and files downloaded. */
1545             {
1546               total_downloaded_bytes += len;
1547               numurls++;
1548             }
1549
1550           /* Deletion of listing files is not controlled by --delete-after, but
1551              by the more specific option --dont-remove-listing, and the code
1552              to do this deletion is in another function. */
1553         }
1554       else if (!opt.spider)
1555         /* This is not a directory listing file. */
1556         {
1557           /* Unlike directory listing files, don't pretend normal files weren't
1558              downloaded if they're going to be deleted.  People seeding proxies,
1559              for instance, may want to know how many bytes and files they've
1560              downloaded through it. */
1561           total_downloaded_bytes += len;
1562           numurls++;
1563
1564           if (opt.delete_after)
1565             {
1566               DEBUGP (("\
1567 Removing file due to --delete-after in ftp_loop_internal():\n"));
1568               logprintf (LOG_VERBOSE, _("Removing %s.\n"), locf);
1569               if (unlink (locf))
1570                 logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1571             }
1572         }
1573
1574       /* Restore the original leave-pendingness.  */
1575       if (orig_lp)
1576         con->cmd |= LEAVE_PENDING;
1577       else
1578         con->cmd &= ~LEAVE_PENDING;
1579       return RETROK;
1580     } while (!opt.ntry || (count < opt.ntry));
1581
1582   if (con->csock != -1 && (con->st & ON_YOUR_OWN))
1583     {
1584       fd_close (con->csock);
1585       con->csock = -1;
1586     }
1587   return TRYLIMEXC;
1588 }
1589
1590 /* Return the directory listing in a reusable format.  The directory
1591    is specifed in u->dir.  */
1592 static uerr_t
1593 ftp_get_listing (struct url *u, ccon *con, struct fileinfo **f)
1594 {
1595   uerr_t err;
1596   char *uf;                     /* url file name */
1597   char *lf;                     /* list file name */
1598   char *old_target = con->target;
1599
1600   con->st &= ~ON_YOUR_OWN;
1601   con->cmd |= (DO_LIST | LEAVE_PENDING);
1602   con->cmd &= ~DO_RETR;
1603
1604   /* Find the listing file name.  We do it by taking the file name of
1605      the URL and replacing the last component with the listing file
1606      name.  */
1607   uf = url_file_name (u);
1608   lf = file_merge (uf, LIST_FILENAME);
1609   xfree (uf);
1610   DEBUGP ((_("Using %s as listing tmp file.\n"), quote (lf)));
1611
1612   con->target = xstrdup (lf);
1613   xfree (lf);
1614   err = ftp_loop_internal (u, NULL, con);
1615   lf = xstrdup (con->target);
1616   xfree (con->target);
1617   con->target = old_target;
1618
1619   if (err == RETROK)
1620     {
1621       *f = ftp_parse_ls (lf, con->rs);
1622       if (opt.remove_listing)
1623         {
1624           if (unlink (lf))
1625             logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1626           else
1627             logprintf (LOG_VERBOSE, _("Removed %s.\n"), quote (lf));
1628         }
1629     }
1630   else
1631     *f = NULL;
1632   xfree (lf);
1633   con->cmd &= ~DO_LIST;
1634   return err;
1635 }
1636
1637 static uerr_t ftp_retrieve_dirs (struct url *, struct fileinfo *, ccon *);
1638 static uerr_t ftp_retrieve_glob (struct url *, ccon *, int);
1639 static struct fileinfo *delelement (struct fileinfo *, struct fileinfo **);
1640 static void freefileinfo (struct fileinfo *f);
1641
1642 /* Retrieve a list of files given in struct fileinfo linked list.  If
1643    a file is a symbolic link, do not retrieve it, but rather try to
1644    set up a similar link on the local disk, if the symlinks are
1645    supported.
1646
1647    If opt.recursive is set, after all files have been retrieved,
1648    ftp_retrieve_dirs will be called to retrieve the directories.  */
1649 static uerr_t
1650 ftp_retrieve_list (struct url *u, struct fileinfo *f, ccon *con)
1651 {
1652   static int depth = 0;
1653   uerr_t err;
1654   struct fileinfo *orig;
1655   wgint local_size;
1656   time_t tml;
1657   bool dlthis; /* Download this (file). */
1658   const char *actual_target = NULL;
1659
1660   /* Increase the depth.  */
1661   ++depth;
1662   if (opt.reclevel != INFINITE_RECURSION && depth > opt.reclevel)
1663     {
1664       DEBUGP ((_("Recursion depth %d exceeded max. depth %d.\n"),
1665                depth, opt.reclevel));
1666       --depth;
1667       return RECLEVELEXC;
1668     }
1669
1670   assert (f != NULL);
1671   orig = f;
1672
1673   con->st &= ~ON_YOUR_OWN;
1674   if (!(con->st & DONE_CWD))
1675     con->cmd |= DO_CWD;
1676   else
1677     con->cmd &= ~DO_CWD;
1678   con->cmd |= (DO_RETR | LEAVE_PENDING);
1679
1680   if (con->csock < 0)
1681     con->cmd |= DO_LOGIN;
1682   else
1683     con->cmd &= ~DO_LOGIN;
1684
1685   err = RETROK;                 /* in case it's not used */
1686
1687   while (f)
1688     {
1689       char *old_target, *ofile;
1690
1691       if (opt.quota && total_downloaded_bytes > opt.quota)
1692         {
1693           --depth;
1694           return QUOTEXC;
1695         }
1696       old_target = con->target;
1697
1698       ofile = xstrdup (u->file);
1699       url_set_file (u, f->name);
1700
1701       con->target = url_file_name (u);
1702       err = RETROK;
1703
1704       dlthis = true;
1705       if (opt.timestamping && f->type == FT_PLAINFILE)
1706         {
1707           struct_stat st;
1708           /* If conversion of HTML files retrieved via FTP is ever implemented,
1709              we'll need to stat() <file>.orig here when -K has been specified.
1710              I'm not implementing it now since files on an FTP server are much
1711              more likely than files on an HTTP server to legitimately have a
1712              .orig suffix. */
1713           if (!stat (con->target, &st))
1714             {
1715               bool eq_size;
1716               bool cor_val;
1717               /* Else, get it from the file.  */
1718               local_size = st.st_size;
1719               tml = st.st_mtime;
1720 #ifdef WINDOWS
1721               /* Modification time granularity is 2 seconds for Windows, so
1722                  increase local time by 1 second for later comparison. */
1723               tml++;
1724 #endif
1725               /* Compare file sizes only for servers that tell us correct
1726                  values. Assume sizes being equal for servers that lie
1727                  about file size.  */
1728               cor_val = (con->rs == ST_UNIX || con->rs == ST_WINNT);
1729               eq_size = cor_val ? (local_size == f->size) : true;
1730               if (f->tstamp <= tml && eq_size)
1731                 {
1732                   /* Remote file is older, file sizes can be compared and
1733                      are both equal. */
1734                   logprintf (LOG_VERBOSE, _("\
1735 Remote file no newer than local file %s -- not retrieving.\n"), quote (con->target));
1736                   dlthis = false;
1737                 }
1738               else if (eq_size)
1739                 {
1740                   /* Remote file is newer or sizes cannot be matched */
1741                   logprintf (LOG_VERBOSE, _("\
1742 Remote file is newer than local file %s -- retrieving.\n\n"),
1743                              quote (con->target));
1744                 }
1745               else
1746                 {
1747                   /* Sizes do not match */
1748                   logprintf (LOG_VERBOSE, _("\
1749 The sizes do not match (local %s) -- retrieving.\n\n"),
1750                              number_to_static_string (local_size));
1751                 }
1752             }
1753         }       /* opt.timestamping && f->type == FT_PLAINFILE */
1754       switch (f->type)
1755         {
1756         case FT_SYMLINK:
1757           /* If opt.retr_symlinks is defined, we treat symlinks as
1758              if they were normal files.  There is currently no way
1759              to distinguish whether they might be directories, and
1760              follow them.  */
1761           if (!opt.retr_symlinks)
1762             {
1763 #ifdef HAVE_SYMLINK
1764               if (!f->linkto)
1765                 logputs (LOG_NOTQUIET,
1766                          _("Invalid name of the symlink, skipping.\n"));
1767               else
1768                 {
1769                   struct_stat st;
1770                   /* Check whether we already have the correct
1771                      symbolic link.  */
1772                   int rc = lstat (con->target, &st);
1773                   if (rc == 0)
1774                     {
1775                       size_t len = strlen (f->linkto) + 1;
1776                       if (S_ISLNK (st.st_mode))
1777                         {
1778                           char *link_target = (char *)alloca (len);
1779                           size_t n = readlink (con->target, link_target, len);
1780                           if ((n == len - 1)
1781                               && (memcmp (link_target, f->linkto, n) == 0))
1782                             {
1783                               logprintf (LOG_VERBOSE, _("\
1784 Already have correct symlink %s -> %s\n\n"),
1785                                          quote (con->target),
1786                                          quote (f->linkto));
1787                               dlthis = false;
1788                               break;
1789                             }
1790                         }
1791                     }
1792                   logprintf (LOG_VERBOSE, _("Creating symlink %s -> %s\n"),
1793                              quote (con->target), quote (f->linkto));
1794                   /* Unlink before creating symlink!  */
1795                   unlink (con->target);
1796                   if (symlink (f->linkto, con->target) == -1)
1797                     logprintf (LOG_NOTQUIET, "symlink: %s\n", strerror (errno));
1798                   logputs (LOG_VERBOSE, "\n");
1799                 } /* have f->linkto */
1800 #else  /* not HAVE_SYMLINK */
1801               logprintf (LOG_NOTQUIET,
1802                          _("Symlinks not supported, skipping symlink %s.\n"),
1803                          quote (con->target));
1804 #endif /* not HAVE_SYMLINK */
1805             }
1806           else                /* opt.retr_symlinks */
1807             {
1808               if (dlthis)
1809                 err = ftp_loop_internal (u, f, con);
1810             } /* opt.retr_symlinks */
1811           break;
1812         case FT_DIRECTORY:
1813           if (!opt.recursive)
1814             logprintf (LOG_NOTQUIET, _("Skipping directory %s.\n"),
1815                        quote (f->name));
1816           break;
1817         case FT_PLAINFILE:
1818           /* Call the retrieve loop.  */
1819           if (dlthis)
1820             err = ftp_loop_internal (u, f, con);
1821           break;
1822         case FT_UNKNOWN:
1823           logprintf (LOG_NOTQUIET, _("%s: unknown/unsupported file type.\n"),
1824                      quote (f->name));
1825           break;
1826         }       /* switch */
1827
1828
1829       /* 2004-12-15 SMS.
1830        * Set permissions _before_ setting the times, as setting the
1831        * permissions changes the modified-time, at least on VMS.
1832        * Also, use the opt.output_document name here, too, as
1833        * appropriate.  (Do the test once, and save the result.)
1834        */
1835
1836       set_local_file (&actual_target, con->target);
1837
1838       /* If downloading a plain file, set valid (non-zero) permissions. */
1839       if (dlthis && (actual_target != NULL) && (f->type == FT_PLAINFILE))
1840         {
1841           if (f->perms)
1842             chmod (actual_target, f->perms);
1843           else
1844             DEBUGP (("Unrecognized permissions for %s.\n", actual_target));
1845         }
1846
1847       /* Set the time-stamp information to the local file.  Symlinks
1848          are not to be stamped because it sets the stamp on the
1849          original.  :( */
1850       if (actual_target != NULL)
1851         {
1852           if (!(f->type == FT_SYMLINK && !opt.retr_symlinks)
1853               && f->tstamp != -1
1854               && dlthis
1855               && file_exists_p (con->target))
1856             {
1857               touch (actual_target, f->tstamp);
1858             }
1859           else if (f->tstamp == -1)
1860             logprintf (LOG_NOTQUIET, _("%s: corrupt time-stamp.\n"),
1861                        actual_target);
1862         }
1863
1864       xfree (con->target);
1865       con->target = old_target;
1866
1867       url_set_file (u, ofile);
1868       xfree (ofile);
1869
1870       /* Break on fatals.  */
1871       if (err == QUOTEXC || err == HOSTERR || err == FWRITEERR)
1872         break;
1873       con->cmd &= ~ (DO_CWD | DO_LOGIN);
1874       f = f->next;
1875     }
1876
1877   /* We do not want to call ftp_retrieve_dirs here */
1878   if (opt.recursive &&
1879       !(opt.reclevel != INFINITE_RECURSION && depth >= opt.reclevel))
1880     err = ftp_retrieve_dirs (u, orig, con);
1881   else if (opt.recursive)
1882     DEBUGP ((_("Will not retrieve dirs since depth is %d (max %d).\n"),
1883              depth, opt.reclevel));
1884   --depth;
1885   return err;
1886 }
1887
1888 /* Retrieve the directories given in a file list.  This function works
1889    by simply going through the linked list and calling
1890    ftp_retrieve_glob on each directory entry.  The function knows
1891    about excluded directories.  */
1892 static uerr_t
1893 ftp_retrieve_dirs (struct url *u, struct fileinfo *f, ccon *con)
1894 {
1895   char *container = NULL;
1896   int container_size = 0;
1897
1898   for (; f; f = f->next)
1899     {
1900       int size;
1901       char *odir, *newdir;
1902
1903       if (opt.quota && total_downloaded_bytes > opt.quota)
1904         break;
1905       if (f->type != FT_DIRECTORY)
1906         continue;
1907
1908       /* Allocate u->dir off stack, but reallocate only if a larger
1909          string is needed.  It's a pity there's no "realloca" for an
1910          item on the bottom of the stack.  */
1911       size = strlen (u->dir) + 1 + strlen (f->name) + 1;
1912       if (size > container_size)
1913         container = (char *)alloca (size);
1914       newdir = container;
1915
1916       odir = u->dir;
1917       if (*odir == '\0'
1918           || (*odir == '/' && *(odir + 1) == '\0'))
1919         /* If ODIR is empty or just "/", simply append f->name to
1920            ODIR.  (In the former case, to preserve u->dir being
1921            relative; in the latter case, to avoid double slash.)  */
1922         sprintf (newdir, "%s%s", odir, f->name);
1923       else
1924         /* Else, use a separator. */
1925         sprintf (newdir, "%s/%s", odir, f->name);
1926
1927       DEBUGP (("Composing new CWD relative to the initial directory.\n"));
1928       DEBUGP (("  odir = '%s'\n  f->name = '%s'\n  newdir = '%s'\n\n",
1929                odir, f->name, newdir));
1930       if (!accdir (newdir))
1931         {
1932           logprintf (LOG_VERBOSE, _("\
1933 Not descending to %s as it is excluded/not-included.\n"),
1934                      quote (newdir));
1935           continue;
1936         }
1937
1938       con->st &= ~DONE_CWD;
1939
1940       odir = xstrdup (u->dir);  /* because url_set_dir will free
1941                                    u->dir. */
1942       url_set_dir (u, newdir);
1943       ftp_retrieve_glob (u, con, GLOB_GETALL);
1944       url_set_dir (u, odir);
1945       xfree (odir);
1946
1947       /* Set the time-stamp?  */
1948     }
1949
1950   if (opt.quota && total_downloaded_bytes > opt.quota)
1951     return QUOTEXC;
1952   else
1953     return RETROK;
1954 }
1955
1956 /* Return true if S has a leading '/'  or contains '../' */
1957 static bool
1958 has_insecure_name_p (const char *s)
1959 {
1960   if (*s == '/')
1961     return true;
1962
1963   if (strstr (s, "../") != 0)
1964     return true;
1965
1966   return false;
1967 }
1968
1969 /* A near-top-level function to retrieve the files in a directory.
1970    The function calls ftp_get_listing, to get a linked list of files.
1971    Then it weeds out the file names that do not match the pattern.
1972    ftp_retrieve_list is called with this updated list as an argument.
1973
1974    If the argument ACTION is GLOB_GETONE, just download the file (but
1975    first get the listing, so that the time-stamp is heeded); if it's
1976    GLOB_GLOBALL, use globbing; if it's GLOB_GETALL, download the whole
1977    directory.  */
1978 static uerr_t
1979 ftp_retrieve_glob (struct url *u, ccon *con, int action)
1980 {
1981   struct fileinfo *f, *start;
1982   uerr_t res;
1983
1984   con->cmd |= LEAVE_PENDING;
1985
1986   res = ftp_get_listing (u, con, &start);
1987   if (res != RETROK)
1988     return res;
1989   /* First: weed out that do not conform the global rules given in
1990      opt.accepts and opt.rejects.  */
1991   if (opt.accepts || opt.rejects)
1992     {
1993       f = start;
1994       while (f)
1995         {
1996           if (f->type != FT_DIRECTORY && !acceptable (f->name))
1997             {
1998               logprintf (LOG_VERBOSE, _("Rejecting %s.\n"),
1999                          quote (f->name));
2000               f = delelement (f, &start);
2001             }
2002           else
2003             f = f->next;
2004         }
2005     }
2006   /* Remove all files with possible harmful names */
2007   f = start;
2008   while (f)
2009     {
2010       if (has_insecure_name_p (f->name))
2011         {
2012           logprintf (LOG_VERBOSE, _("Rejecting %s.\n"),
2013                      quote (f->name));
2014           f = delelement (f, &start);
2015         }
2016       else
2017         f = f->next;
2018     }
2019   /* Now weed out the files that do not match our globbing pattern.
2020      If we are dealing with a globbing pattern, that is.  */
2021   if (*u->file)
2022     {
2023       if (action == GLOB_GLOBALL)
2024         {
2025           int (*matcher) (const char *, const char *, int)
2026             = opt.ignore_case ? fnmatch_nocase : fnmatch;
2027           int matchres = 0;
2028
2029           f = start;
2030           while (f)
2031             {
2032               matchres = matcher (u->file, f->name, 0);
2033               if (matchres == -1)
2034                 {
2035                   logprintf (LOG_NOTQUIET, _("Error matching %s against %s: %s\n"),
2036                              u->file, quotearg_style (escape_quoting_style, f->name),
2037                              strerror (errno));
2038                   break;
2039                 }
2040               if (matchres == FNM_NOMATCH)
2041                 f = delelement (f, &start); /* delete the element from the list */
2042               else
2043                 f = f->next;        /* leave the element in the list */
2044             }
2045           if (matchres == -1)
2046             {
2047               freefileinfo (start);
2048               return RETRBADPATTERN;
2049             }
2050         }
2051       else if (action == GLOB_GETONE)
2052         {
2053           int (*cmp) (const char *, const char *)
2054             = opt.ignore_case ? strcasecmp : strcmp;
2055           f = start;
2056           while (f)
2057             {
2058               if (0 != cmp(u->file, f->name))
2059                 f = delelement (f, &start);
2060               else
2061                 f = f->next;
2062             }
2063         }
2064     }
2065   if (start)
2066     {
2067       /* Just get everything.  */
2068       ftp_retrieve_list (u, start, con);
2069     }
2070   else
2071     {
2072       if (action == GLOB_GLOBALL)
2073         {
2074           /* No luck.  */
2075           /* #### This message SUCKS.  We should see what was the
2076              reason that nothing was retrieved.  */
2077           logprintf (LOG_VERBOSE, _("No matches on pattern %s.\n"),
2078                      quote (u->file));
2079         }
2080       else if (action == GLOB_GETONE) /* GLOB_GETONE or GLOB_GETALL */
2081         {
2082           /* Let's try retrieving it anyway.  */
2083           con->st |= ON_YOUR_OWN;
2084           res = ftp_loop_internal (u, NULL, con);
2085           return res;
2086         }
2087
2088       /* If action == GLOB_GETALL, and the file list is empty, there's
2089          no point in trying to download anything or in complaining about
2090          it.  (An empty directory should not cause complaints.)
2091       */
2092     }
2093   freefileinfo (start);
2094   if (opt.quota && total_downloaded_bytes > opt.quota)
2095     return QUOTEXC;
2096   else
2097     /* #### Should we return `res' here?  */
2098     return RETROK;
2099 }
2100
2101 /* The wrapper that calls an appropriate routine according to contents
2102    of URL.  Inherently, its capabilities are limited on what can be
2103    encoded into a URL.  */
2104 uerr_t
2105 ftp_loop (struct url *u, int *dt, struct url *proxy, bool recursive, bool glob)
2106 {
2107   ccon con;                     /* FTP connection */
2108   uerr_t res;
2109
2110   *dt = 0;
2111
2112   xzero (con);
2113
2114   con.csock = -1;
2115   con.st = ON_YOUR_OWN;
2116   con.rs = ST_UNIX;
2117   con.id = NULL;
2118   con.proxy = proxy;
2119
2120   /* If the file name is empty, the user probably wants a directory
2121      index.  We'll provide one, properly HTML-ized.  Unless
2122      opt.htmlify is 0, of course.  :-) */
2123   if (!*u->file && !recursive)
2124     {
2125       struct fileinfo *f;
2126       res = ftp_get_listing (u, &con, &f);
2127
2128       if (res == RETROK)
2129         {
2130           if (opt.htmlify && !opt.spider)
2131             {
2132               char *filename = (opt.output_document
2133                                 ? xstrdup (opt.output_document)
2134                                 : (con.target ? xstrdup (con.target)
2135                                    : url_file_name (u)));
2136               res = ftp_index (filename, u, f);
2137               if (res == FTPOK && opt.verbose)
2138                 {
2139                   if (!opt.output_document)
2140                     {
2141                       struct_stat st;
2142                       wgint sz;
2143                       if (stat (filename, &st) == 0)
2144                         sz = st.st_size;
2145                       else
2146                         sz = -1;
2147                       logprintf (LOG_NOTQUIET,
2148                                  _("Wrote HTML-ized index to %s [%s].\n"),
2149                                  quote (filename), number_to_static_string (sz));
2150                     }
2151                   else
2152                     logprintf (LOG_NOTQUIET,
2153                                _("Wrote HTML-ized index to %s.\n"),
2154                                quote (filename));
2155                 }
2156               xfree (filename);
2157             }
2158           freefileinfo (f);
2159         }
2160     }
2161   else
2162     {
2163       bool ispattern = false;
2164       if (glob)
2165         {
2166           /* Treat the URL as a pattern if the file name part of the
2167              URL path contains wildcards.  (Don't check for u->file
2168              because it is unescaped and therefore doesn't leave users
2169              the option to escape literal '*' as %2A.)  */
2170           char *file_part = strrchr (u->path, '/');
2171           if (!file_part)
2172             file_part = u->path;
2173           ispattern = has_wildcards_p (file_part);
2174         }
2175       if (ispattern || recursive || opt.timestamping)
2176         {
2177           /* ftp_retrieve_glob is a catch-all function that gets called
2178              if we need globbing, time-stamping or recursion.  Its
2179              third argument is just what we really need.  */
2180           res = ftp_retrieve_glob (u, &con,
2181                                    ispattern ? GLOB_GLOBALL : GLOB_GETONE);
2182         }
2183       else
2184         res = ftp_loop_internal (u, NULL, &con);
2185     }
2186   if (res == FTPOK)
2187     res = RETROK;
2188   if (res == RETROK)
2189     *dt |= RETROKF;
2190   /* If a connection was left, quench it.  */
2191   if (con.csock != -1)
2192     fd_close (con.csock);
2193   xfree_null (con.id);
2194   con.id = NULL;
2195   xfree_null (con.target);
2196   con.target = NULL;
2197   return res;
2198 }
2199
2200 /* Delete an element from the fileinfo linked list.  Returns the
2201    address of the next element, or NULL if the list is exhausted.  It
2202    can modify the start of the list.  */
2203 static struct fileinfo *
2204 delelement (struct fileinfo *f, struct fileinfo **start)
2205 {
2206   struct fileinfo *prev = f->prev;
2207   struct fileinfo *next = f->next;
2208
2209   xfree (f->name);
2210   xfree_null (f->linkto);
2211   xfree (f);
2212
2213   if (next)
2214     next->prev = prev;
2215   if (prev)
2216     prev->next = next;
2217   else
2218     *start = next;
2219   return next;
2220 }
2221
2222 /* Free the fileinfo linked list of files.  */
2223 static void
2224 freefileinfo (struct fileinfo *f)
2225 {
2226   while (f)
2227     {
2228       struct fileinfo *next = f->next;
2229       xfree (f->name);
2230       if (f->linkto)
2231         xfree (f->linkto);
2232       xfree (f);
2233       f = next;
2234     }
2235 }