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

   1 /* File Transfer Protocol support.
   2    Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
   3
   4 This file is part of Wget.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #ifdef HAVE_STRING_H
  25 # include <string.h>
  26 #else
  27 # include <strings.h>
  28 #endif
  29 #include <ctype.h>
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33 #include <sys/types.h>
  34 #include <assert.h>
  35 #include <errno.h>
  36
  37 #include "wget.h"
  38 #include "utils.h"
  39 #include "url.h"
  40 #include "rbuf.h"
  41 #include "retr.h"
  42 #include "ftp.h"
  43 #include "html.h"
  44 #include "connect.h"
  45 #include "host.h"
  46 #include "fnmatch.h"
  47 #include "netrc.h"
  48
  49 #ifndef errno
  50 extern int errno;
  51 #endif
  52 #ifndef h_errno
  53 extern int h_errno;
  54 #endif
  55
  56 /* File where the "ls -al" listing will be saved.  */
  57 #define LIST_FILENAME ".listing"
  58
  59 extern char ftp_last_respline[];
  60
  61 /* Look for regexp "( *[0-9]+ *byte" (literal parenthesis) anywhere in
  62    the string S, and return the number converted to long, if found, 0
  63    otherwise.  */
  64 static long
  65 ftp_expected_bytes (const char *s)
  66 {
  67   long res;
  68
  69   while (1)
  70     {
  71       while (*s && *s != '(')
  72         ++s;
  73       if (!*s)
  74         return 0;
  75       for (++s; *s && ISSPACE (*s); s++);
  76       if (!*s)
  77         return 0;
  78       if (!ISDIGIT (*s))
  79         continue;
  80       res = 0;
  81       do
  82         {
  83           res = (*s - '0') + 10 * res;
  84           ++s;
  85         }
  86       while (*s && ISDIGIT (*s));
  87       if (!*s)
  88         return 0;
  89       while (*s && ISSPACE (*s))
  90         ++s;
  91       if (!*s)
  92         return 0;
  93       if (tolower (*s) != 'b')
  94         continue;
  95       if (strncasecmp (s, "byte", 4))
  96         continue;
  97       else
  98         break;
  99     }
 100   return res;
 101 }
 102
 103 /* Retrieves a file with denoted parameters through opening an FTP
 104    connection to the server.  It always closes the data connection,
 105    and closes the control connection in case of error.  */
 106 static uerr_t
 107 getftp (const struct urlinfo *u, long *len, long restval, ccon *con)
 108 {
 109   int csock, dtsock, res;
 110   uerr_t err;
 111   FILE *fp;
 112   char *user, *passwd, *respline;
 113   char *tms, *tmrate;
 114   unsigned char pasv_addr[6];
 115   int cmd = con->cmd;
 116   int passive_mode_open = 0;
 117   long expected_bytes = 0L;
 118
 119   assert (con != NULL);
 120   assert (u->local != NULL);
 121   /* Debug-check of the sanity of the request by making sure that LIST
 122      and RETR are never both requested (since we can handle only one
 123      at a time.  */
 124   assert (!((cmd & DO_LIST) && (cmd & DO_RETR)));
 125   /* Make sure that at least *something* is requested.  */
 126   assert ((cmd & (DO_LIST | DO_CWD | DO_RETR | DO_LOGIN)) != 0);
 127
 128   user = u->user;
 129   passwd = u->passwd;
 130   search_netrc (u->host, (const char **)&user, (const char **)&passwd, 1);
 131   user = user ? user : opt.ftp_acc;
 132   if (!opt.ftp_pass)
 133     opt.ftp_pass = xstrdup (ftp_getaddress ());
 134   passwd = passwd ? passwd : opt.ftp_pass;
 135   assert (user && passwd);
 136
 137   dtsock = -1;
 138   con->dltime = 0;
 139
 140   if (!(cmd & DO_LOGIN))
 141     csock = RBUF_FD (&con->rbuf);
 142   else                          /* cmd & DO_LOGIN */
 143     {
 144       /* Login to the server: */
 145
 146       /* First: Establish the control connection.  */
 147       logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "), u->host, u->port);
 148       err = make_connection (&csock, u->host, u->port);
 149       if (cmd & LEAVE_PENDING)
 150         rbuf_initialize (&con->rbuf, csock);
 151       else
 152         rbuf_uninitialize (&con->rbuf);
 153       switch (err)
 154         {
 155           /* Do not close the socket in first several cases, since it
 156              wasn't created at all.  */
 157         case HOSTERR:
 158           logputs (LOG_VERBOSE, "\n");
 159           logprintf (LOG_NOTQUIET, "%s: %s\n", u->host, herrmsg (h_errno));
 160           return HOSTERR;
 161           break;
 162         case CONSOCKERR:
 163           logputs (LOG_VERBOSE, "\n");
 164           logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
 165           return CONSOCKERR;
 166           break;
 167         case CONREFUSED:
 168           logputs (LOG_VERBOSE, "\n");
 169           logprintf (LOG_NOTQUIET, _("Connection to %s:%hu refused.\n"),
 170                      u->host, u->port);
 171           CLOSE (csock);
 172           rbuf_uninitialize (&con->rbuf);
 173           return CONREFUSED;
 174         case CONERROR:
 175           logputs (LOG_VERBOSE, "\n");
 176           logprintf (LOG_NOTQUIET, "connect: %s\n", strerror (errno));
 177           CLOSE (csock);
 178           rbuf_uninitialize (&con->rbuf);
 179           return CONERROR;
 180           break;
 181         default:
 182           DO_NOTHING;
 183           /* #### Hmm?  */
 184         }
 185       /* Since this is a new connection, we may safely discard
 186          anything left in the buffer.  */
 187       rbuf_discard (&con->rbuf);
 188
 189       /* Second: Login with proper USER/PASS sequence.  */
 190       logputs (LOG_VERBOSE, _("connected!\n"));
 191       logprintf (LOG_VERBOSE, _("Logging in as %s ... "), user);
 192       if (opt.server_response)
 193         logputs (LOG_ALWAYS, "\n");
 194       err = ftp_login (&con->rbuf, user, passwd);
 195       /* FTPRERR, FTPSRVERR, WRITEFAILED, FTPLOGREFUSED, FTPLOGINC */
 196       switch (err)
 197         {
 198         case FTPRERR:
 199           logputs (LOG_VERBOSE, "\n");
 200           logputs (LOG_NOTQUIET, _("\
 201 Error in server response, closing control connection.\n"));
 202           CLOSE (csock);
 203           rbuf_uninitialize (&con->rbuf);
 204           return err;
 205           break;
 206         case FTPSRVERR:
 207           logputs (LOG_VERBOSE, "\n");
 208           logputs (LOG_NOTQUIET, _("Error in server greeting.\n"));
 209           CLOSE (csock);
 210           rbuf_uninitialize (&con->rbuf);
 211           return err;
 212           break;
 213         case WRITEFAILED:
 214           logputs (LOG_VERBOSE, "\n");
 215           logputs (LOG_NOTQUIET,
 216                    _("Write failed, closing control connection.\n"));
 217           CLOSE (csock);
 218           rbuf_uninitialize (&con->rbuf);
 219           return err;
 220           break;
 221         case FTPLOGREFUSED:
 222           logputs (LOG_VERBOSE, "\n");
 223           logputs (LOG_NOTQUIET, _("The server refuses login.\n"));
 224           CLOSE (csock);
 225           rbuf_uninitialize (&con->rbuf);
 226           return FTPLOGREFUSED;
 227           break;
 228         case FTPLOGINC:
 229           logputs (LOG_VERBOSE, "\n");
 230           logputs (LOG_NOTQUIET, _("Login incorrect.\n"));
 231           CLOSE (csock);
 232           rbuf_uninitialize (&con->rbuf);
 233           return FTPLOGINC;
 234           break;
 235         case FTPOK:
 236           if (!opt.server_response)
 237             logputs (LOG_VERBOSE, _("Logged in!\n"));
 238           break;
 239         default:
 240           abort ();
 241           exit (1);
 242           break;
 243         }
 244       /* Third: Set type to Image (binary).  */
 245       if (!opt.server_response)
 246         logprintf (LOG_VERBOSE, "==> TYPE %c ... ", toupper (u->ftp_type));
 247       err = ftp_type (&con->rbuf, toupper (u->ftp_type));
 248       /* FTPRERR, WRITEFAILED, FTPUNKNOWNTYPE */
 249       switch (err)
 250         {
 251         case FTPRERR:
 252           logputs (LOG_VERBOSE, "\n");
 253           logputs (LOG_NOTQUIET, _("\
 254 Error in server response, closing control connection.\n"));
 255           CLOSE (csock);
 256           rbuf_uninitialize (&con->rbuf);
 257           return err;
 258           break;
 259         case WRITEFAILED:
 260           logputs (LOG_VERBOSE, "\n");
 261           logputs (LOG_NOTQUIET,
 262                    _("Write failed, closing control connection.\n"));
 263           CLOSE (csock);
 264           rbuf_uninitialize (&con->rbuf);
 265           return err;
 266           break;
 267         case FTPUNKNOWNTYPE:
 268           logputs (LOG_VERBOSE, "\n");
 269           logprintf (LOG_NOTQUIET,
 270                      _("Unknown type `%c', closing control connection.\n"),
 271                      toupper (u->ftp_type));
 272           CLOSE (csock);
 273           rbuf_uninitialize (&con->rbuf);
 274           return err;
 275         case FTPOK:
 276           /* Everything is OK.  */
 277           break;
 278         default:
 279           abort ();
 280           break;
 281         }
 282       if (!opt.server_response)
 283         logputs (LOG_VERBOSE, _("done.  "));
 284     } /* do login */
 285
 286   if (cmd & DO_CWD)
 287     {
 288       if (!*u->dir)
 289         logputs (LOG_VERBOSE, _("==> CWD not needed.\n"));
 290       else
 291         {
 292           /* Change working directory.  */
 293           if (!opt.server_response)
 294             logprintf (LOG_VERBOSE, "==> CWD %s ... ", u->dir);
 295           err = ftp_cwd (&con->rbuf, u->dir);
 296           /* FTPRERR, WRITEFAILED, FTPNSFOD */
 297           switch (err)
 298             {
 299             case FTPRERR:
 300               logputs (LOG_VERBOSE, "\n");
 301               logputs (LOG_NOTQUIET, _("\
 302 Error in server response, closing control connection.\n"));
 303               CLOSE (csock);
 304               rbuf_uninitialize (&con->rbuf);
 305               return err;
 306               break;
 307             case WRITEFAILED:
 308               logputs (LOG_VERBOSE, "\n");
 309               logputs (LOG_NOTQUIET,
 310                        _("Write failed, closing control connection.\n"));
 311               CLOSE (csock);
 312               rbuf_uninitialize (&con->rbuf);
 313               return err;
 314               break;
 315             case FTPNSFOD:
 316               logputs (LOG_VERBOSE, "\n");
 317               logprintf (LOG_NOTQUIET, _("No such directory `%s'.\n\n"),
 318                          u->dir);
 319               CLOSE (csock);
 320               rbuf_uninitialize (&con->rbuf);
 321               return err;
 322               break;
 323             case FTPOK:
 324               /* fine and dandy */
 325               break;
 326             default:
 327               abort ();
 328               break;
 329             }
 330           if (!opt.server_response)
 331             logputs (LOG_VERBOSE, _("done.\n"));
 332         }
 333     }
 334   else /* do not CWD */
 335     logputs (LOG_VERBOSE, _("==> CWD not required.\n"));
 336
 337   /* If anything is to be retrieved, PORT (or PASV) must be sent.  */
 338   if (cmd & (DO_LIST | DO_RETR))
 339     {
 340       if (opt.ftp_pasv)
 341         {
 342           char thost[256];
 343           unsigned short tport;
 344
 345           if (!opt.server_response)
 346             logputs (LOG_VERBOSE, "==> PASV ... ");
 347           err = ftp_pasv (&con->rbuf, pasv_addr);
 348           /* FTPRERR, WRITEFAILED, FTPNOPASV, FTPINVPASV */
 349           switch (err)
 350             {
 351             case FTPRERR:
 352               logputs (LOG_VERBOSE, "\n");
 353               logputs (LOG_NOTQUIET, _("\
 354 Error in server response, closing control connection.\n"));
 355               CLOSE (csock);
 356               rbuf_uninitialize (&con->rbuf);
 357               return err;
 358               break;
 359             case WRITEFAILED:
 360               logputs (LOG_VERBOSE, "\n");
 361               logputs (LOG_NOTQUIET,
 362                        _("Write failed, closing control connection.\n"));
 363               CLOSE (csock);
 364               rbuf_uninitialize (&con->rbuf);
 365               return err;
 366               break;
 367             case FTPNOPASV:
 368               logputs (LOG_VERBOSE, "\n");
 369               logputs (LOG_NOTQUIET, _("Cannot initiate PASV transfer.\n"));
 370               break;
 371             case FTPINVPASV:
 372               logputs (LOG_VERBOSE, "\n");
 373               logputs (LOG_NOTQUIET, _("Cannot parse PASV response.\n"));
 374               break;
 375             case FTPOK:
 376               /* fine and dandy */
 377               break;
 378             default:
 379               abort ();
 380               break;
 381             }
 382           if (err==FTPOK)
 383             {
 384               sprintf (thost, "%d.%d.%d.%d",
 385                        pasv_addr[0], pasv_addr[1], pasv_addr[2], pasv_addr[3]);
 386               tport = (pasv_addr[4] << 8) + pasv_addr[5];
 387               DEBUGP ((_("Will try connecting to %s:%hu.\n"), thost, tport));
 388               err = make_connection (&dtsock, thost, tport);
 389               switch (err)
 390                 {
 391                   /* Do not close the socket in first several cases,
 392                      since it wasn't created at all.  */
 393                 case HOSTERR:
 394                   logputs (LOG_VERBOSE, "\n");
 395                   logprintf (LOG_NOTQUIET, "%s: %s\n", thost,
 396                              herrmsg (h_errno));
 397                   CLOSE (csock);
 398                   rbuf_uninitialize (&con->rbuf);
 399                   return HOSTERR;
 400                   break;
 401                 case CONSOCKERR:
 402                   logputs (LOG_VERBOSE, "\n");
 403                   logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
 404                   CLOSE (csock);
 405                   rbuf_uninitialize (&con->rbuf);
 406                   return CONSOCKERR;
 407                   break;
 408                 case CONREFUSED:
 409                   logputs (LOG_VERBOSE, "\n");
 410                   logprintf (LOG_NOTQUIET,
 411                              _("Connection to %s:%hu refused.\n"),
 412                              thost, tport);
 413                   CLOSE (csock);
 414                   rbuf_uninitialize (&con->rbuf);
 415                   closeport (dtsock);
 416                   return CONREFUSED;
 417                 case CONERROR:
 418                   logputs (LOG_VERBOSE, "\n");
 419                   logprintf (LOG_NOTQUIET, "connect: %s\n",
 420                              strerror (errno));
 421                   CLOSE (csock);
 422                   rbuf_uninitialize (&con->rbuf);
 423                   closeport (dtsock);
 424                   return CONERROR;
 425                   break;
 426                 default:
 427                   /* #### What?!  */
 428                   DO_NOTHING;
 429                 }
 430               passive_mode_open= 1;  /* Flag to avoid accept port */
 431               if (!opt.server_response)
 432                 logputs (LOG_VERBOSE, _("done.    "));
 433             } /* err==FTP_OK */
 434         }
 435
 436       if (!passive_mode_open)   /* Try to use a port command if PASV failed */
 437         {
 438           if (!opt.server_response)
 439             logputs (LOG_VERBOSE, "==> PORT ... ");
 440           err = ftp_port (&con->rbuf);
 441           /* FTPRERR, WRITEFAILED, bindport (CONSOCKERR, CONPORTERR, BINDERR,
 442              LISTENERR), HOSTERR, FTPPORTERR */
 443           switch (err)
 444             {
 445             case FTPRERR:
 446               logputs (LOG_VERBOSE, "\n");
 447               logputs (LOG_NOTQUIET, _("\
 448 Error in server response, closing control connection.\n"));
 449               CLOSE (csock);
 450               closeport (dtsock);
 451               rbuf_uninitialize (&con->rbuf);
 452               return err;
 453               break;
 454             case WRITEFAILED:
 455               logputs (LOG_VERBOSE, "\n");
 456               logputs (LOG_NOTQUIET,
 457                        _("Write failed, closing control connection.\n"));
 458               CLOSE (csock);
 459               closeport (dtsock);
 460               rbuf_uninitialize (&con->rbuf);
 461               return err;
 462               break;
 463             case CONSOCKERR:
 464               logputs (LOG_VERBOSE, "\n");
 465               logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
 466               CLOSE (csock);
 467               closeport (dtsock);
 468               rbuf_uninitialize (&con->rbuf);
 469               return err;
 470               break;
 471             case CONPORTERR: case BINDERR: case LISTENERR:
 472               /* What now?  These problems are local...  */
 473               logputs (LOG_VERBOSE, "\n");
 474               logprintf (LOG_NOTQUIET, _("Bind error (%s).\n"),
 475                          strerror (errno));
 476               closeport (dtsock);
 477               return err;
 478               break;
 479             case HOSTERR:
 480               logputs (LOG_VERBOSE, "\n");
 481               logprintf (LOG_NOTQUIET, "%s: %s\n", u->host,
 482                          herrmsg (h_errno));
 483               CLOSE (csock);
 484               closeport (dtsock);
 485               rbuf_uninitialize (&con->rbuf);
 486               return HOSTERR;
 487               break;
 488             case FTPPORTERR:
 489               logputs (LOG_VERBOSE, "\n");
 490               logputs (LOG_NOTQUIET, _("Invalid PORT.\n"));
 491               CLOSE (csock);
 492               closeport (dtsock);
 493               rbuf_uninitialize (&con->rbuf);
 494               return err;
 495               break;
 496             case FTPOK:
 497               /* fine and dandy */
 498               break;
 499             default:
 500               abort ();
 501               break;
 502             } /* port switch */
 503           if (!opt.server_response)
 504             logputs (LOG_VERBOSE, _("done.    "));
 505         } /* dtsock == -1 */
 506     } /* cmd & (DO_LIST | DO_RETR) */
 507
 508   /* Restart if needed.  */
 509   if (restval && (cmd & DO_RETR))
 510     {
 511       if (!opt.server_response)
 512         logprintf (LOG_VERBOSE, "==> REST %ld ... ", restval);
 513       err = ftp_rest (&con->rbuf, restval);
 514
 515       /* FTPRERR, WRITEFAILED, FTPRESTFAIL */
 516       switch (err)
 517         {
 518         case FTPRERR:
 519           logputs (LOG_VERBOSE, "\n");
 520           logputs (LOG_NOTQUIET, _("\
 521 Error in server response, closing control connection.\n"));
 522           CLOSE (csock);
 523           closeport (dtsock);
 524           rbuf_uninitialize (&con->rbuf);
 525           return err;
 526           break;
 527         case WRITEFAILED:
 528           logputs (LOG_VERBOSE, "\n");
 529           logputs (LOG_NOTQUIET,
 530                    _("Write failed, closing control connection.\n"));
 531           CLOSE (csock);
 532           closeport (dtsock);
 533           rbuf_uninitialize (&con->rbuf);
 534           return err;
 535           break;
 536         case FTPRESTFAIL:
 537           logputs (LOG_VERBOSE, _("\nREST failed, starting from scratch.\n"));
 538           restval = 0L;
 539           break;
 540         case FTPOK:
 541           /* fine and dandy */
 542           break;
 543         default:
 544           abort ();
 545           break;
 546         }
 547       if (err != FTPRESTFAIL && !opt.server_response)
 548         logputs (LOG_VERBOSE, _("done.    "));
 549     } /* restval && cmd & DO_RETR */
 550
 551   if (cmd & DO_RETR)
 552     {
 553       if (opt.verbose)
 554         {
 555           if (!opt.server_response)
 556             {
 557               if (restval)
 558                 logputs (LOG_VERBOSE, "\n");
 559               logprintf (LOG_VERBOSE, "==> RETR %s ... ", u->file);
 560             }
 561         }
 562       err = ftp_retr (&con->rbuf, u->file);
 563       /* FTPRERR, WRITEFAILED, FTPNSFOD */
 564       switch (err)
 565         {
 566         case FTPRERR:
 567           logputs (LOG_VERBOSE, "\n");
 568           logputs (LOG_NOTQUIET, _("\
 569 Error in server response, closing control connection.\n"));
 570           CLOSE (csock);
 571           closeport (dtsock);
 572           rbuf_uninitialize (&con->rbuf);
 573           return err;
 574           break;
 575         case WRITEFAILED:
 576           logputs (LOG_VERBOSE, "\n");
 577           logputs (LOG_NOTQUIET,
 578                    _("Write failed, closing control connection.\n"));
 579           CLOSE (csock);
 580           closeport (dtsock);
 581           rbuf_uninitialize (&con->rbuf);
 582           return err;
 583           break;
 584         case FTPNSFOD:
 585           logputs (LOG_VERBOSE, "\n");
 586           logprintf (LOG_NOTQUIET, _("No such file `%s'.\n\n"), u->file);
 587           closeport (dtsock);
 588           return err;
 589           break;
 590         case FTPOK:
 591           /* fine and dandy */
 592           break;
 593         default:
 594           abort ();
 595           break;
 596         }
 597
 598       if (!opt.server_response)
 599         logputs (LOG_VERBOSE, _("done.\n"));
 600       expected_bytes = ftp_expected_bytes (ftp_last_respline);
 601     } /* do retrieve */
 602
 603   if (cmd & DO_LIST)
 604     {
 605       if (!opt.server_response)
 606         logputs (LOG_VERBOSE, "==> LIST ... ");
 607       /* As Maciej W. Rozycki (macro@ds2.pg.gda.pl) says, `LIST'
 608          without arguments is better than `LIST .'; confirmed by
 609          RFC959.  */
 610       err = ftp_list (&con->rbuf, NULL);
 611       /* FTPRERR, WRITEFAILED */
 612       switch (err)
 613         {
 614         case FTPRERR:
 615           logputs (LOG_VERBOSE, "\n");
 616           logputs (LOG_NOTQUIET, _("\
 617 Error in server response, closing control connection.\n"));
 618           CLOSE (csock);
 619           closeport (dtsock);
 620           rbuf_uninitialize (&con->rbuf);
 621           return err;
 622           break;
 623         case WRITEFAILED:
 624           logputs (LOG_VERBOSE, "\n");
 625           logputs (LOG_NOTQUIET,
 626                    _("Write failed, closing control connection.\n"));
 627           CLOSE (csock);
 628           closeport (dtsock);
 629           rbuf_uninitialize (&con->rbuf);
 630           return err;
 631           break;
 632         case FTPNSFOD:
 633           logputs (LOG_VERBOSE, "\n");
 634           logprintf (LOG_NOTQUIET, _("No such file or directory `%s'.\n\n"),
 635                      ".");
 636           closeport (dtsock);
 637           return err;
 638           break;
 639         case FTPOK:
 640           /* fine and dandy */
 641           break;
 642         default:
 643           abort ();
 644           break;
 645         }
 646       if (!opt.server_response)
 647         logputs (LOG_VERBOSE, _("done.\n"));
 648       expected_bytes = ftp_expected_bytes (ftp_last_respline);
 649     } /* cmd & DO_LIST */
 650
 651   /* If no transmission was required, then everything is OK.  */
 652   if (!(cmd & (DO_LIST | DO_RETR)))
 653     return RETRFINISHED;
 654
 655   if (!passive_mode_open)  /* we are not using pasive mode so we need
 656                               to accept */
 657     {
 658       /* Open the data transmission socket by calling acceptport().  */
 659       err = acceptport (&dtsock);
 660       /* Possible errors: ACCEPTERR.  */
 661       if (err == ACCEPTERR)
 662         {
 663           logprintf (LOG_NOTQUIET, "accept: %s\n", strerror (errno));
 664           return err;
 665         }
 666     }
 667
 668   /* Open the file -- if opt.dfp is set, use it instead.  */
 669   if (!opt.dfp || con->cmd & DO_LIST)
 670     {
 671       mkalldirs (u->local);
 672       if (opt.backups)
 673         rotate_backups (u->local);
 674       /* #### Is this correct? */
 675       chmod (u->local, 0600);
 676
 677       fp = fopen (u->local, restval ? "ab" : "wb");
 678       if (!fp)
 679         {
 680           logprintf (LOG_NOTQUIET, "%s: %s\n", u->local, strerror (errno));
 681           CLOSE (csock);
 682           rbuf_uninitialize (&con->rbuf);
 683           closeport (dtsock);
 684           return FOPENERR;
 685         }
 686     }
 687   else
 688     fp = opt.dfp;
 689
 690   if (*len)
 691     {
 692       logprintf (LOG_VERBOSE, _("Length: %s"), legible (*len));
 693       if (restval)
 694         logprintf (LOG_VERBOSE, _(" [%s to go]"), legible (*len - restval));
 695       logputs (LOG_VERBOSE, "\n");
 696     }
 697   else if (expected_bytes)
 698     {
 699       logprintf (LOG_VERBOSE, _("Length: %s"), legible (expected_bytes));
 700       if (restval)
 701         logprintf (LOG_VERBOSE, _(" [%s to go]"),
 702                    legible (expected_bytes - restval));
 703       logputs (LOG_VERBOSE, _(" (unauthoritative)\n"));
 704     }
 705   reset_timer ();
 706   /* Get the contents of the document.  */
 707   res = get_contents (dtsock, fp, len, restval, expected_bytes, &con->rbuf);
 708   con->dltime = elapsed_time ();
 709   tms = time_str (NULL);
 710   tmrate = rate (*len - restval, con->dltime);
 711   /* Close data connection socket.  */
 712   closeport (dtsock);
 713   /* Close the local file.  */
 714   if (!opt.dfp || con->cmd & DO_LIST)
 715     fclose (fp);
 716   else
 717     fflush (fp);
 718   /* If get_contents couldn't write to fp, bail out.  */
 719   if (res == -2)
 720     {
 721       logprintf (LOG_NOTQUIET, _("%s: %s, closing control connection.\n"),
 722                  u->local, strerror (errno));
 723       CLOSE (csock);
 724       rbuf_uninitialize (&con->rbuf);
 725       return FWRITEERR;
 726     }
 727   else if (res == -1)
 728     {
 729       logprintf (LOG_NOTQUIET, _("%s (%s) - Data connection: %s; "),
 730                  tms, tmrate, strerror (errno));
 731       if (opt.server_response)
 732         logputs (LOG_ALWAYS, "\n");
 733     }
 734
 735   /* Get the server to tell us if everything is retrieved.  */
 736   err = ftp_response (&con->rbuf, &respline);
 737   /* ...and empty the buffer.  */
 738   rbuf_discard (&con->rbuf);
 739   if (err != FTPOK)
 740     {
 741       free (respline);
 742       /* The control connection is decidedly closed.  Print the time
 743          only if it hasn't already been printed.  */
 744       if (res != -1)
 745         logprintf (LOG_NOTQUIET, "%s (%s) - ", tms, tmrate);
 746       logputs (LOG_NOTQUIET, _("Control connection closed.\n"));
 747       /* If there is an error on the control connection, close it, but
 748          return FTPRETRINT, since there is a possibility that the
 749          whole file was retrieved nevertheless (but that is for
 750          ftp_loop_internal to decide).  */
 751       CLOSE (csock);
 752       rbuf_uninitialize (&con->rbuf);
 753       return FTPRETRINT;
 754     } /* err != FTPOK */
 755   /* If retrieval failed for any reason, return FTPRETRINT, but do not
 756      close socket, since the control connection is still alive.  If
 757      there is something wrong with the control connection, it will
 758      become apparent later.  */
 759   if (*respline != '2')
 760     {
 761       free (respline);
 762       if (res != -1)
 763         logprintf (LOG_NOTQUIET, "%s (%s) - ", tms, tmrate);
 764       logputs (LOG_NOTQUIET, _("Data transfer aborted.\n"));
 765       return FTPRETRINT;
 766     }
 767   free (respline);
 768
 769   if (res == -1)
 770     {
 771       /* What now?  The data connection was erroneous, whereas the
 772          response says everything is OK.  We shall play it safe.  */
 773       return FTPRETRINT;
 774     }
 775
 776   if (!(cmd & LEAVE_PENDING))
 777     {
 778       /* I should probably send 'QUIT' and check for a reply, but this
 779          is faster.  #### Is it OK, though?  */
 780       CLOSE (csock);
 781       rbuf_uninitialize (&con->rbuf);
 782     }
 783   /* If it was a listing, and opt.server_response is true,
 784      print it out.  */
 785   if (opt.server_response && (con->cmd & DO_LIST))
 786     {
 787       mkalldirs (u->local);
 788       fp = fopen (u->local, "r");
 789       if (!fp)
 790         logprintf (LOG_ALWAYS, "%s: %s\n", u->local, strerror (errno));
 791       else
 792         {
 793           char *line;
 794           /* The lines are being read with read_whole_line because of
 795              no-buffering on opt.lfile.  */
 796           while ((line = read_whole_line (fp)))
 797             {
 798               logprintf (LOG_ALWAYS, "%s\n", line);
 799               free (line);
 800             }
 801           fclose (fp);
 802         }
 803     } /* con->cmd & DO_LIST && server_response */
 804
 805   return RETRFINISHED;
 806 }
 807
 808 /* A one-file FTP loop.  This is the part where FTP retrieval is
 809    retried, and retried, and retried, and...
 810
 811    This loop either gets commands from con, or (if ON_YOUR_OWN is
 812    set), makes them up to retrieve the file given by the URL.  */
 813 static uerr_t
 814 ftp_loop_internal (struct urlinfo *u, struct fileinfo *f, ccon *con)
 815 {
 816   static int first_retrieval = 1;
 817
 818   int count, orig_lp;
 819   long restval, len;
 820   char *tms, *tmrate, *locf;
 821   uerr_t err;
 822   struct stat st;
 823
 824   if (!u->local)
 825     u->local = url_filename (u);
 826
 827   if (opt.noclobber && file_exists_p (u->local))
 828     {
 829       logprintf (LOG_VERBOSE,
 830                  _("File `%s' already there, not retrieving.\n"), u->local);
 831       /* If the file is there, we suppose it's retrieved OK.  */
 832       return RETROK;
 833     }
 834
 835   /* Remove it if it's a link.  */
 836   remove_link (u->local);
 837   if (!opt.output_document)
 838     locf = u->local;
 839   else
 840     locf = opt.output_document;
 841
 842   count = 0;
 843
 844   if (con->st & ON_YOUR_OWN)
 845     con->st = ON_YOUR_OWN;
 846
 847   orig_lp = con->cmd & LEAVE_PENDING ? 1 : 0;
 848
 849   /* THE loop.  */
 850   do
 851     {
 852       /* Increment the pass counter.  */
 853       ++count;
 854       /* Wait before the retrieval (unless this is the very first
 855          retrieval).  */
 856       if (!first_retrieval && opt.wait)
 857         sleep (opt.wait);
 858       if (first_retrieval)
 859         first_retrieval = 0;
 860       if (con->st & ON_YOUR_OWN)
 861         {
 862           con->cmd = 0;
 863           con->cmd |= (DO_RETR | LEAVE_PENDING);
 864           if (rbuf_initialized_p (&con->rbuf))
 865             con->cmd &= ~ (DO_LOGIN | DO_CWD);
 866           else
 867             con->cmd |= (DO_LOGIN | DO_CWD);
 868         }
 869       else /* not on your own */
 870         {
 871           if (rbuf_initialized_p (&con->rbuf))
 872             con->cmd &= ~DO_LOGIN;
 873           else
 874             con->cmd |= DO_LOGIN;
 875           if (con->st & DONE_CWD)
 876             con->cmd &= ~DO_CWD;
 877           else
 878             con->cmd |= DO_CWD;
 879         }
 880       /* Assume no restarting.  */
 881       restval = 0L;
 882       if ((count > 1 || opt.always_rest)
 883           && !(con->cmd & DO_LIST)
 884           && file_exists_p (u->local))
 885         if (stat (u->local, &st) == 0)
 886           restval = st.st_size;
 887       /* Get the current time string.  */
 888       tms = time_str (NULL);
 889       /* Print fetch message, if opt.verbose.  */
 890       if (opt.verbose)
 891         {
 892           char *hurl = str_url (u->proxy ? u->proxy : u, 1);
 893           char tmp[15];
 894           strcpy (tmp, "        ");
 895           if (count > 1)
 896             sprintf (tmp, _("(try:%2d)"), count);
 897           logprintf (LOG_VERBOSE, "--%s--  %s\n  %s => `%s'\n",
 898                      tms, hurl, tmp, locf);
 899 #ifdef WINDOWS
 900           ws_changetitle (hurl, 1);
 901 #endif
 902           free (hurl);
 903         }
 904       /* Send getftp the proper length, if fileinfo was provided.  */
 905       if (f)
 906         len = f->size;
 907       else
 908         len = 0;
 909       err = getftp (u, &len, restval, con);
 910       /* Time?  */
 911       tms = time_str (NULL);
 912       tmrate = rate (len - restval, con->dltime);
 913
 914       if (!rbuf_initialized_p (&con->rbuf))
 915         con->st &= ~DONE_CWD;
 916       else
 917         con->st |= DONE_CWD;
 918
 919       switch (err)
 920         {
 921         case HOSTERR: case CONREFUSED: case FWRITEERR: case FOPENERR:
 922         case FTPNSFOD: case FTPLOGINC: case FTPNOPASV:
 923           /* Fatal errors, give up.  */
 924           return err;
 925           break;
 926         case CONSOCKERR: case CONERROR: case FTPSRVERR: case FTPRERR:
 927         case WRITEFAILED: case FTPUNKNOWNTYPE: case CONPORTERR:
 928         case BINDERR: case LISTENERR: case ACCEPTERR:
 929         case FTPPORTERR: case FTPLOGREFUSED: case FTPINVPASV:
 930           printwhat (count, opt.ntry);
 931           /* non-fatal errors */
 932           continue;
 933           break;
 934         case FTPRETRINT:
 935           /* If the control connection was closed, the retrieval
 936              will be considered OK if f->size == len.  */
 937           if (!f || len != f->size)
 938             {
 939               printwhat (count, opt.ntry);
 940               continue;
 941             }
 942           break;
 943         case RETRFINISHED:
 944           /* Great!  */
 945           break;
 946         default:
 947           /* Not as great.  */
 948           abort ();
 949         }
 950       if (con->st & ON_YOUR_OWN)
 951         {
 952           CLOSE (RBUF_FD (&con->rbuf));
 953           rbuf_uninitialize (&con->rbuf);
 954         }
 955       logprintf (LOG_VERBOSE, _("%s (%s) - `%s' saved [%ld]\n\n"),
 956                  tms, tmrate, locf, len);
 957       logprintf (LOG_NONVERBOSE, "%s URL: %s [%ld] -> \"%s\" [%d]\n",
 958                  tms, u->url, len, locf, count);
 959       /* Do not count listings among the downloaded stuff, since they
 960          will get deleted anyway.  */
 961       if (!(con->cmd & DO_LIST))
 962         {
 963           ++opt.numurls;
 964           opt.downloaded += len;
 965         }
 966       /* Restore the original leave-pendingness.  */
 967       if (orig_lp)
 968         con->cmd |= LEAVE_PENDING;
 969       else
 970         con->cmd &= ~LEAVE_PENDING;
 971       return RETROK;
 972     } while (!opt.ntry || (count < opt.ntry));
 973
 974   if (rbuf_initialized_p (&con->rbuf) && (con->st & ON_YOUR_OWN))
 975     {
 976       CLOSE (RBUF_FD (&con->rbuf));
 977       rbuf_uninitialize (&con->rbuf);
 978     }
 979   return TRYLIMEXC;
 980 }
 981
 982 /* Return the directory listing in a reusable format.  The directory
 983    is specifed in u->dir.  */
 984 static struct fileinfo *
 985 ftp_get_listing (struct urlinfo *u, ccon *con)
 986 {
 987   struct fileinfo *f;
 988   uerr_t err;
 989   char *olocal = u->local;
 990   char *list_filename, *ofile;
 991
 992   con->st &= ~ON_YOUR_OWN;
 993   con->cmd |= (DO_LIST | LEAVE_PENDING);
 994   con->cmd &= ~DO_RETR;
 995   /* Get the listing filename.  */
 996   ofile = u->file;
 997   u->file = LIST_FILENAME;
 998   list_filename = url_filename (u);
 999   u->file = ofile;
1000   u->local = list_filename;
1001   DEBUGP ((_("Using `%s' as listing tmp file.\n"), list_filename));
1002   err = ftp_loop_internal (u, NULL, con);
1003   u->local = olocal;
1004   if (err == RETROK)
1005     f = ftp_parse_ls (list_filename);
1006   else
1007     f = NULL;
1008   if (opt.remove_listing)
1009     {
1010       if (unlink (list_filename))
1011         logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1012       else
1013         logprintf (LOG_VERBOSE, _("Removed `%s'.\n"), list_filename);
1014     }
1015   free (list_filename);
1016   con->cmd &= ~DO_LIST;
1017   return f;
1018 }
1019
1020 static uerr_t ftp_retrieve_dirs PARAMS ((struct urlinfo *, struct fileinfo *,
1021                                          ccon *));
1022 static uerr_t ftp_retrieve_glob PARAMS ((struct urlinfo *, ccon *, int));
1023 static struct fileinfo *delelement PARAMS ((struct fileinfo *,
1024                                             struct fileinfo **));
1025 static void freefileinfo PARAMS ((struct fileinfo *f));
1026
1027 /* Retrieve a list of files given in struct fileinfo linked list.  If
1028    a file is a symbolic link, do not retrieve it, but rather try to
1029    set up a similar link on the local disk, if the symlinks are
1030    supported.
1031
1032    If opt.recursive is set, after all files have been retrieved,
1033    ftp_retrieve_dirs will be called to retrieve the directories.  */
1034 static uerr_t
1035 ftp_retrieve_list (struct urlinfo *u, struct fileinfo *f, ccon *con)
1036 {
1037   static int depth = 0;
1038   uerr_t err;
1039   char *olocal, *ofile;
1040   struct fileinfo *orig;
1041   long local_size;
1042   time_t tml;
1043   int dlthis;
1044
1045   /* Increase the depth.  */
1046   ++depth;
1047   if (opt.reclevel && depth > opt.reclevel)
1048     {
1049       DEBUGP ((_("Recursion depth %d exceeded max. depth %d.\n"),
1050                depth, opt.reclevel));
1051       --depth;
1052       return RECLEVELEXC;
1053     }
1054
1055   assert (f != NULL);
1056   orig = f;
1057
1058   con->st &= ~ON_YOUR_OWN;
1059   if (!(con->st & DONE_CWD))
1060     con->cmd |= DO_CWD;
1061   else
1062     con->cmd &= ~DO_CWD;
1063   con->cmd |= (DO_RETR | LEAVE_PENDING);
1064
1065   if (!rbuf_initialized_p (&con->rbuf))
1066     con->cmd |= DO_LOGIN;
1067   else
1068     con->cmd &= ~DO_LOGIN;
1069
1070   err = RETROK;                 /* in case it's not used */
1071
1072   while (f)
1073     {
1074       if (opt.quota && opt.downloaded > opt.quota)
1075         {
1076           --depth;
1077           return QUOTEXC;
1078         }
1079       olocal = u->local;
1080       ofile = u->file;
1081       u->file = f->name;
1082       u->local = url_filename (u);
1083       err = RETROK;
1084
1085       dlthis = 1;
1086       if (opt.timestamping && f->type == FT_PLAINFILE)
1087         {
1088           struct stat st;
1089           if (!stat (u->local, &st))
1090             {
1091               /* Else, get it from the file.  */
1092               local_size = st.st_size;
1093               tml = st.st_mtime;
1094               if (local_size == f->size && tml >= f->tstamp)
1095                 {
1096                   logprintf (LOG_VERBOSE, _("\
1097 Local file `%s' is more recent, not retrieving.\n\n"), u->local);
1098                   dlthis = 0;
1099                 }
1100               else if (local_size != f->size)
1101                 {
1102                   logprintf (LOG_VERBOSE, _("\
1103 The sizes do not match (local %ld), retrieving.\n"), local_size);
1104                 }
1105             }
1106         }       /* opt.timestamping && f->type == FT_PLAINFILE */
1107       switch (f->type)
1108         {
1109         case FT_SYMLINK:
1110           /* If opt.retr_symlinks is defined, we treat symlinks as
1111              if they were normal files.  There is currently no way
1112              to distinguish whether they might be directories, and
1113              follow them.  */
1114           if (!opt.retr_symlinks)
1115             {
1116 #ifdef HAVE_SYMLINK
1117               if (!f->linkto)
1118                 logputs (LOG_NOTQUIET,
1119                          _("Invalid name of the symlink, skipping.\n"));
1120               else
1121                 {
1122                   struct stat st;
1123                   /* Check whether we already have the correct
1124                      symbolic link.  */
1125                   int rc = lstat (u->local, &st);
1126                   if (rc == 0)
1127                     {
1128                       size_t len = strlen (f->linkto) + 1;
1129                       if (S_ISLNK (st.st_mode))
1130                         {
1131                           char *link_target = (char *)alloca (len);
1132                           size_t n = readlink (u->local, link_target, len);
1133                           if ((n == len - 1)
1134                               && (memcmp (link_target, f->linkto, n) == 0))
1135                             {
1136                               logprintf (LOG_VERBOSE, _("\
1137 Already have correct symlink %s -> %s\n\n"),
1138                                          u->local, f->linkto);
1139                               dlthis = 0;
1140                               break;
1141                             }
1142                         }
1143                     }
1144                   logprintf (LOG_VERBOSE, _("Creating symlink %s -> %s\n"),
1145                              u->local, f->linkto);
1146                   /* Unlink before creating symlink!  */
1147                   unlink (u->local);
1148                   if (symlink (f->linkto, u->local) == -1)
1149                     logprintf (LOG_NOTQUIET, "symlink: %s\n",
1150                                strerror (errno));
1151                   logputs (LOG_VERBOSE, "\n");
1152                 } /* have f->linkto */
1153 #else  /* not HAVE_SYMLINK */
1154               logprintf (LOG_NOTQUIET,
1155                          _("Symlinks not supported, skipping symlink `%s'.\n"),
1156                          u->local);
1157 #endif /* not HAVE_SYMLINK */
1158             }
1159           else                /* opt.retr_symlinks */
1160             {
1161               if (dlthis)
1162                 err = ftp_loop_internal (u, f, con);
1163             } /* opt.retr_symlinks */
1164           break;
1165         case FT_DIRECTORY:
1166           if (!opt.recursive)
1167             logprintf (LOG_NOTQUIET, _("Skipping directory `%s'.\n"),
1168                        f->name);
1169           break;
1170         case FT_PLAINFILE:
1171           /* Call the retrieve loop.  */
1172           if (dlthis)
1173             err = ftp_loop_internal (u, f, con);
1174           break;
1175         case FT_UNKNOWN:
1176           logprintf (LOG_NOTQUIET, _("%s: unknown/unsupported file type.\n"),
1177                      f->name);
1178           break;
1179         }       /* switch */
1180
1181       /* Set the time-stamp information to the local file.  Symlinks
1182          are not to be stamped because it sets the stamp on the
1183          original.  :( */
1184       if (!opt.dfp
1185           && !(f->type == FT_SYMLINK && !opt.retr_symlinks)
1186           && f->tstamp != -1
1187           && dlthis
1188           && file_exists_p (u->local))
1189         {
1190           touch (u->local, f->tstamp);
1191         }
1192       else if (f->tstamp == -1)
1193         logprintf (LOG_NOTQUIET, _("%s: corrupt time-stamp.\n"), u->local);
1194
1195       if (f->perms && dlthis)
1196         chmod (u->local, f->perms);
1197       else
1198         DEBUGP (("Unrecognized permissions for %s.\n", u->local));
1199
1200       free (u->local);
1201       u->local = olocal;
1202       u->file = ofile;
1203       /* Break on fatals.  */
1204       if (err == QUOTEXC || err == HOSTERR || err == FWRITEERR)
1205         break;
1206       con->cmd &= ~ (DO_CWD | DO_LOGIN);
1207       f = f->next;
1208     } /* while */
1209   /* We do not want to call ftp_retrieve_dirs here */
1210   if (opt.recursive && !(opt.reclevel && depth >= opt.reclevel))
1211     err = ftp_retrieve_dirs (u, orig, con);
1212   else if (opt.recursive)
1213     DEBUGP ((_("Will not retrieve dirs since depth is %d (max %d).\n"),
1214              depth, opt.reclevel));
1215   --depth;
1216   return err;
1217 }
1218
1219 /* Retrieve the directories given in a file list.  This function works
1220    by simply going through the linked list and calling
1221    ftp_retrieve_glob on each directory entry.  The function knows
1222    about excluded directories.  */
1223 static uerr_t
1224 ftp_retrieve_dirs (struct urlinfo *u, struct fileinfo *f, ccon *con)
1225 {
1226   char *odir;
1227   char *current_container = NULL;
1228   int current_length = 0;
1229
1230   for (; f; f = f->next)
1231     {
1232       int len;
1233
1234       if (opt.quota && opt.downloaded > opt.quota)
1235         break;
1236       if (f->type != FT_DIRECTORY)
1237         continue;
1238       odir = u->dir;
1239       len = 1 + strlen (u->dir) + 1 + strlen (f->name) + 1;
1240       /* Allocate u->dir off stack, but reallocate only if a larger
1241          string is needed.  */
1242       if (len > current_length)
1243         current_container = (char *)alloca (len);
1244       u->dir = current_container;
1245       /* When retrieving recursively, all directories must be
1246          absolute.  This restriction will (hopefully!) be lifted in
1247          the future.  */
1248       sprintf (u->dir, "/%s%s%s", odir + (*odir == '/'),
1249               (!*odir || (*odir == '/' && !* (odir + 1))) ? "" : "/", f->name);
1250       if (!accdir (u->dir, ALLABS))
1251         {
1252           logprintf (LOG_VERBOSE, _("\
1253 Not descending to `%s' as it is excluded/not-included.\n"), u->dir);
1254           u->dir = odir;
1255           continue;
1256         }
1257       con->st &= ~DONE_CWD;
1258       ftp_retrieve_glob (u, con, GETALL);
1259       /* Set the time-stamp?  */
1260       u->dir = odir;
1261     }
1262   if (opt.quota && opt.downloaded > opt.quota)
1263     return QUOTEXC;
1264   else
1265     return RETROK;
1266 }
1267
1268
1269 /* A near-top-level function to retrieve the files in a directory.
1270    The function calls ftp_get_listing, to get a linked list of files.
1271    Then it weeds out the file names that do not match the pattern.
1272    ftp_retrieve_list is called with this updated list as an argument.
1273
1274    If the argument ACTION is GETONE, just download the file (but first
1275    get the listing, so that the time-stamp is heeded); if it's GLOBALL,
1276    use globbing; if it's GETALL, download the whole directory.  */
1277 static uerr_t
1278 ftp_retrieve_glob (struct urlinfo *u, ccon *con, int action)
1279 {
1280   struct fileinfo *orig, *start;
1281   uerr_t res;
1282
1283   con->cmd |= LEAVE_PENDING;
1284
1285   orig = ftp_get_listing (u, con);
1286   start = orig;
1287   /* First: weed out that do not conform the global rules given in
1288      opt.accepts and opt.rejects.  */
1289   if (opt.accepts || opt.rejects)
1290     {
1291       struct fileinfo *f = orig;
1292
1293       while (f)
1294         {
1295           if (f->type != FT_DIRECTORY && !acceptable (f->name))
1296             {
1297               logprintf (LOG_VERBOSE, _("Rejecting `%s'.\n"), f->name);
1298               f = delelement (f, &start);
1299             }
1300           else
1301             f = f->next;
1302         }
1303     }
1304   /* Now weed out the files that do not match our globbing pattern.
1305      If we are dealing with a globbing pattern, that is.  */
1306   if (*u->file && (action == GLOBALL || action == GETONE))
1307     {
1308       int matchres = 0;
1309       struct fileinfo *f = start;
1310
1311       while (f)
1312         {
1313           matchres = fnmatch (u->file, f->name, 0);
1314           if (matchres == -1)
1315             {
1316               logprintf (LOG_NOTQUIET, "%s: %s\n", u->local,
1317                          strerror (errno));
1318               break;
1319             }
1320           if (matchres == FNM_NOMATCH)
1321             f = delelement (f, &start); /* delete the element from the list */
1322           else
1323             f = f->next;        /* leave the element in the list */
1324         }
1325       if (matchres == -1)
1326         {
1327           freefileinfo (start);
1328           return RETRBADPATTERN;
1329         }
1330     }
1331   res = RETROK;
1332   if (start)
1333     {
1334       /* Just get everything.  */
1335       ftp_retrieve_list (u, start, con);
1336     }
1337   else if (!start)
1338     {
1339       if (action == GLOBALL)
1340         {
1341           /* No luck.  */
1342           /* #### This message SUCKS.  We should see what was the
1343              reason that nothing was retrieved.  */
1344           logprintf (LOG_VERBOSE, _("No matches on pattern `%s'.\n"), u->file);
1345         }
1346       else /* GETONE or GETALL */
1347         {
1348           /* Let's try retrieving it anyway.  */
1349           con->st |= ON_YOUR_OWN;
1350           res = ftp_loop_internal (u, NULL, con);
1351           return res;
1352         }
1353     }
1354   freefileinfo (start);
1355   if (opt.quota && opt.downloaded > opt.quota)
1356     return QUOTEXC;
1357   else
1358     /* #### Should we return `res' here?  */
1359     return RETROK;
1360 }
1361
1362 /* The wrapper that calls an appropriate routine according to contents
1363    of URL.  Inherently, its capabilities are limited on what can be
1364    encoded into a URL.  */
1365 uerr_t
1366 ftp_loop (struct urlinfo *u, int *dt)
1367 {
1368   ccon con;                     /* FTP connection */
1369   uerr_t res;
1370
1371   *dt = 0;
1372
1373   rbuf_uninitialize (&con.rbuf);
1374   con.st = ON_YOUR_OWN;
1375   res = RETROK;                 /* in case it's not used */
1376
1377   /* If the file name is empty, the user probably wants a directory
1378      index.  We'll provide one, properly HTML-ized.  Unless
1379      opt.htmlify is 0, of course.  :-) */
1380   if (!*u->file && !opt.recursive)
1381     {
1382       struct fileinfo *f = ftp_get_listing (u, &con);
1383
1384       if (f)
1385         {
1386           if (opt.htmlify)
1387             {
1388               char *filename = (opt.output_document
1389                                 ? xstrdup (opt.output_document)
1390                                 : (u->local ? xstrdup (u->local)
1391                                    : url_filename (u)));
1392               res = ftp_index (filename, u, f);
1393               if (res == FTPOK && opt.verbose)
1394                 {
1395                   if (!opt.output_document)
1396                     {
1397                       struct stat st;
1398                       long sz;
1399                       if (stat (filename, &st) == 0)
1400                         sz = st.st_size;
1401                       else
1402                         sz = -1;
1403                       logprintf (LOG_NOTQUIET,
1404                                  _("Wrote HTML-ized index to `%s' [%ld].\n"),
1405                                  filename, sz);
1406                     }
1407                   else
1408                     logprintf (LOG_NOTQUIET,
1409                                _("Wrote HTML-ized index to `%s'.\n"),
1410                                filename);
1411                 }
1412               free (filename);
1413             }
1414           freefileinfo (f);
1415         }
1416     }
1417   else
1418     {
1419       int wild = has_wildcards_p (u->file);
1420       if ((opt.ftp_glob && wild) || opt.recursive || opt.timestamping)
1421         {
1422           /* ftp_retrieve_glob is a catch-all function that gets called
1423              if we need globbing, time-stamping or recursion.  Its
1424              third argument is just what we really need.  */
1425           ftp_retrieve_glob (u, &con,
1426                              (opt.ftp_glob && wild) ? GLOBALL : GETONE);
1427         }
1428       else
1429         res = ftp_loop_internal (u, NULL, &con);
1430     }
1431   if (res == FTPOK)
1432     res = RETROK;
1433   if (res == RETROK)
1434     *dt |= RETROKF;
1435   /* If a connection was left, quench it.  */
1436   if (rbuf_initialized_p (&con.rbuf))
1437     CLOSE (RBUF_FD (&con.rbuf));
1438   return res;
1439 }
1440
1441 /* Delete an element from the fileinfo linked list.  Returns the
1442    address of the next element, or NULL if the list is exhausted.  It
1443    can modify the start of the list.  */
1444 static struct fileinfo *
1445 delelement (struct fileinfo *f, struct fileinfo **start)
1446 {
1447   struct fileinfo *prev = f->prev;
1448   struct fileinfo *next = f->next;
1449
1450   free (f->name);
1451   FREE_MAYBE (f->linkto);
1452   free (f);
1453
1454   if (next)
1455     next->prev = prev;
1456   if (prev)
1457     prev->next = next;
1458   else
1459     *start = next;
1460   return next;
1461 }
1462
1463 /* Free the fileinfo linked list of files.  */
1464 static void
1465 freefileinfo (struct fileinfo *f)
1466 {
1467   while (f)
1468     {
1469       struct fileinfo *next = f->next;
1470       free (f->name);
1471       if (f->linkto)
1472         free (f->linkto);
1473       free (f);
1474       f = next;
1475     }
1476 }