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

   1 /* Command line parsing.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3    2004, 2005, 2006, 2007, 2008 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 #ifdef HAVE_UNISTD_H
  36 # include <unistd.h>
  37 #endif /* HAVE_UNISTD_H */
  38 #include <string.h>
  39 #include <signal.h>
  40 #ifdef ENABLE_NLS
  41 # include <locale.h>
  42 #endif
  43 #include <assert.h>
  44 #include <errno.h>
  45 #include <time.h>
  46
  47 #include "utils.h"
  48 #include "init.h"
  49 #include "retr.h"
  50 #include "recur.h"
  51 #include "host.h"
  52 #include "url.h"
  53 #include "progress.h"           /* for progress_handle_sigwinch */
  54 #include "convert.h"
  55 #include "spider.h"
  56 #include "http.h"               /* for save_cookies */
  57
  58 #include <getopt.h>
  59 #include <getpass.h>
  60 #include <quote.h>
  61
  62 #ifndef PATH_SEPARATOR
  63 # define PATH_SEPARATOR '/'
  64 #endif
  65
  66 struct options opt;
  67
  68 /* defined in version.c */
  69 extern char *version_string;
  70 extern char *compilation_string;
  71 extern char *system_getrc;
  72 extern char *link_string;
  73 /* defined in build_info.c */
  74 extern char *compiled_features[];
  75 extern char *system_wgetrc;
  76 extern char *locale_dir;
  77 /* Used for --version output in print_version */
  78 static const int max_chars_per_line = 72;
  79
  80 #if defined(SIGHUP) || defined(SIGUSR1)
  81 static void redirect_output_signal (int);
  82 #endif
  83
  84 const char *exec_name;
  85 \f
  86 #ifndef TESTING
  87 /* Initialize I18N/L10N.  That amounts to invoking setlocale, and
  88    setting up gettext's message catalog using bindtextdomain and
  89    textdomain.  Does nothing if NLS is disabled or missing.  */
  90
  91 static void
  92 i18n_initialize (void)
  93 {
  94   /* ENABLE_NLS implies existence of functions invoked here.  */
  95 #ifdef ENABLE_NLS
  96   /* Set the current locale.  */
  97   setlocale (LC_ALL, "");
  98   /* Set the text message domain.  */
  99   bindtextdomain ("wget", LOCALEDIR);
 100   textdomain ("wget");
 101 #endif /* ENABLE_NLS */
 102 }
 103 \f
 104 /* Definition of command-line options. */
 105
 106 static void print_help (void);
 107 static void print_version (void);
 108
 109 #ifdef HAVE_SSL
 110 # define IF_SSL(x) x
 111 #else
 112 # define IF_SSL(x) NULL
 113 #endif
 114
 115 #ifdef ENABLE_DEBUG
 116 # define WHEN_DEBUG(x) x
 117 #else
 118 # define WHEN_DEBUG(x) NULL
 119 #endif
 120
 121 struct cmdline_option {
 122   const char *long_name;
 123   char short_name;
 124   enum {
 125     OPT_VALUE,
 126     OPT_BOOLEAN,
 127     OPT_FUNCALL,
 128     /* Non-standard options that have to be handled specially in
 129        main().  */
 130     OPT__APPEND_OUTPUT,
 131     OPT__CLOBBER,
 132     OPT__DONT_REMOVE_LISTING,
 133     OPT__EXECUTE,
 134     OPT__NO,
 135     OPT__PARENT
 136   } type;
 137   const void *data;             /* for standard options */
 138   int argtype;                  /* for non-standard options */
 139 };
 140
 141 static struct cmdline_option option_data[] =
 142   {
 143     { "accept", 'A', OPT_VALUE, "accept", -1 },
 144     { "append-output", 'a', OPT__APPEND_OUTPUT, NULL, required_argument },
 145     { "ask-password", 0, OPT_BOOLEAN, "askpassword", -1 },
 146     { "auth-no-challenge", 0, OPT_BOOLEAN, "authnochallenge", -1 },
 147     { "background", 'b', OPT_BOOLEAN, "background", -1 },
 148     { "backup-converted", 'K', OPT_BOOLEAN, "backupconverted", -1 },
 149     { "backups", 0, OPT_BOOLEAN, "backups", -1 },
 150     { "base", 'B', OPT_VALUE, "base", -1 },
 151     { "bind-address", 0, OPT_VALUE, "bindaddress", -1 },
 152     { IF_SSL ("ca-certificate"), 0, OPT_VALUE, "cacertificate", -1 },
 153     { IF_SSL ("ca-directory"), 0, OPT_VALUE, "cadirectory", -1 },
 154     { "cache", 0, OPT_BOOLEAN, "cache", -1 },
 155     { IF_SSL ("certificate"), 0, OPT_VALUE, "certificate", -1 },
 156     { IF_SSL ("certificate-type"), 0, OPT_VALUE, "certificatetype", -1 },
 157     { IF_SSL ("check-certificate"), 0, OPT_BOOLEAN, "checkcertificate", -1 },
 158     { "clobber", 0, OPT__CLOBBER, NULL, optional_argument },
 159     { "connect-timeout", 0, OPT_VALUE, "connecttimeout", -1 },
 160     { "continue", 'c', OPT_BOOLEAN, "continue", -1 },
 161     { "convert-links", 'k', OPT_BOOLEAN, "convertlinks", -1 },
 162     { "content-disposition", 0, OPT_BOOLEAN, "contentdisposition", -1 },
 163     { "cookies", 0, OPT_BOOLEAN, "cookies", -1 },
 164     { "cut-dirs", 0, OPT_VALUE, "cutdirs", -1 },
 165     { WHEN_DEBUG ("debug"), 'd', OPT_BOOLEAN, "debug", -1 },
 166     { "delete-after", 0, OPT_BOOLEAN, "deleteafter", -1 },
 167     { "directories", 0, OPT_BOOLEAN, "dirstruct", -1 },
 168     { "directory-prefix", 'P', OPT_VALUE, "dirprefix", -1 },
 169     { "dns-cache", 0, OPT_BOOLEAN, "dnscache", -1 },
 170     { "dns-timeout", 0, OPT_VALUE, "dnstimeout", -1 },
 171     { "domains", 'D', OPT_VALUE, "domains", -1 },
 172     { "dont-remove-listing", 0, OPT__DONT_REMOVE_LISTING, NULL, no_argument },
 173     { "dot-style", 0, OPT_VALUE, "dotstyle", -1 },
 174     { "egd-file", 0, OPT_VALUE, "egdfile", -1 },
 175     { "exclude-directories", 'X', OPT_VALUE, "excludedirectories", -1 },
 176     { "exclude-domains", 0, OPT_VALUE, "excludedomains", -1 },
 177     { "execute", 'e', OPT__EXECUTE, NULL, required_argument },
 178     { "follow-ftp", 0, OPT_BOOLEAN, "followftp", -1 },
 179     { "follow-tags", 0, OPT_VALUE, "followtags", -1 },
 180     { "force-directories", 'x', OPT_BOOLEAN, "dirstruct", -1 },
 181     { "force-html", 'F', OPT_BOOLEAN, "forcehtml", -1 },
 182     { "ftp-password", 0, OPT_VALUE, "ftppassword", -1 },
 183     { "ftp-user", 0, OPT_VALUE, "ftpuser", -1 },
 184     { "glob", 0, OPT_BOOLEAN, "glob", -1 },
 185     { "header", 0, OPT_VALUE, "header", -1 },
 186     { "help", 'h', OPT_FUNCALL, (void *)print_help, no_argument },
 187     { "host-directories", 0, OPT_BOOLEAN, "addhostdir", -1 },
 188     { "html-extension", 'E', OPT_BOOLEAN, "htmlextension", -1 },
 189     { "htmlify", 0, OPT_BOOLEAN, "htmlify", -1 },
 190     { "http-keep-alive", 0, OPT_BOOLEAN, "httpkeepalive", -1 },
 191     { "http-passwd", 0, OPT_VALUE, "httppassword", -1 }, /* deprecated */
 192     { "http-password", 0, OPT_VALUE, "httppassword", -1 },
 193     { "http-user", 0, OPT_VALUE, "httpuser", -1 },
 194     { "ignore-case", 0, OPT_BOOLEAN, "ignorecase", -1 },
 195     { "ignore-length", 0, OPT_BOOLEAN, "ignorelength", -1 },
 196     { "ignore-tags", 0, OPT_VALUE, "ignoretags", -1 },
 197     { "include-directories", 'I', OPT_VALUE, "includedirectories", -1 },
 198 #ifdef ENABLE_IPV6
 199     { "inet4-only", '4', OPT_BOOLEAN, "inet4only", -1 },
 200     { "inet6-only", '6', OPT_BOOLEAN, "inet6only", -1 },
 201 #endif
 202     { "input-file", 'i', OPT_VALUE, "input", -1 },
 203     { "iri", 0, OPT_BOOLEAN, "iri", -1 },
 204     { "keep-session-cookies", 0, OPT_BOOLEAN, "keepsessioncookies", -1 },
 205     { "level", 'l', OPT_VALUE, "reclevel", -1 },
 206     { "limit-rate", 0, OPT_VALUE, "limitrate", -1 },
 207     { "load-cookies", 0, OPT_VALUE, "loadcookies", -1 },
 208     { "locale", 0, OPT_VALUE, "locale", -1 },
 209     { "max-redirect", 0, OPT_VALUE, "maxredirect", -1 },
 210     { "mirror", 'm', OPT_BOOLEAN, "mirror", -1 },
 211     { "no", 'n', OPT__NO, NULL, required_argument },
 212     { "no-clobber", 0, OPT_BOOLEAN, "noclobber", -1 },
 213     { "no-parent", 0, OPT_BOOLEAN, "noparent", -1 },
 214     { "output-document", 'O', OPT_VALUE, "outputdocument", -1 },
 215     { "output-file", 'o', OPT_VALUE, "logfile", -1 },
 216     { "page-requisites", 'p', OPT_BOOLEAN, "pagerequisites", -1 },
 217     { "parent", 0, OPT__PARENT, NULL, optional_argument },
 218     { "passive-ftp", 0, OPT_BOOLEAN, "passiveftp", -1 },
 219     { "password", 0, OPT_VALUE, "password", -1 },
 220     { "post-data", 0, OPT_VALUE, "postdata", -1 },
 221     { "post-file", 0, OPT_VALUE, "postfile", -1 },
 222     { "prefer-family", 0, OPT_VALUE, "preferfamily", -1 },
 223     { "preserve-permissions", 0, OPT_BOOLEAN, "preservepermissions", -1 },
 224     { IF_SSL ("private-key"), 0, OPT_VALUE, "privatekey", -1 },
 225     { IF_SSL ("private-key-type"), 0, OPT_VALUE, "privatekeytype", -1 },
 226     { "progress", 0, OPT_VALUE, "progress", -1 },
 227     { "protocol-directories", 0, OPT_BOOLEAN, "protocoldirectories", -1 },
 228     { "proxy", 0, OPT_BOOLEAN, "useproxy", -1 },
 229     { "proxy__compat", 'Y', OPT_VALUE, "useproxy", -1 }, /* back-compatible */
 230     { "proxy-passwd", 0, OPT_VALUE, "proxypassword", -1 }, /* deprecated */
 231     { "proxy-password", 0, OPT_VALUE, "proxypassword", -1 },
 232     { "proxy-user", 0, OPT_VALUE, "proxyuser", -1 },
 233     { "quiet", 'q', OPT_BOOLEAN, "quiet", -1 },
 234     { "quota", 'Q', OPT_VALUE, "quota", -1 },
 235     { "random-file", 0, OPT_VALUE, "randomfile", -1 },
 236     { "random-wait", 0, OPT_BOOLEAN, "randomwait", -1 },
 237     { "read-timeout", 0, OPT_VALUE, "readtimeout", -1 },
 238     { "recursive", 'r', OPT_BOOLEAN, "recursive", -1 },
 239     { "referer", 0, OPT_VALUE, "referer", -1 },
 240     { "reject", 'R', OPT_VALUE, "reject", -1 },
 241     { "relative", 'L', OPT_BOOLEAN, "relativeonly", -1 },
 242     { "remote-encoding", 0, OPT_VALUE, "remoteencoding", -1},
 243     { "remove-listing", 0, OPT_BOOLEAN, "removelisting", -1 },
 244     { "restrict-file-names", 0, OPT_BOOLEAN, "restrictfilenames", -1 },
 245     { "retr-symlinks", 0, OPT_BOOLEAN, "retrsymlinks", -1 },
 246     { "retry-connrefused", 0, OPT_BOOLEAN, "retryconnrefused", -1 },
 247     { "save-cookies", 0, OPT_VALUE, "savecookies", -1 },
 248     { "save-headers", 0, OPT_BOOLEAN, "saveheaders", -1 },
 249     { IF_SSL ("secure-protocol"), 0, OPT_VALUE, "secureprotocol", -1 },
 250     { "server-response", 'S', OPT_BOOLEAN, "serverresponse", -1 },
 251     { "span-hosts", 'H', OPT_BOOLEAN, "spanhosts", -1 },
 252     { "spider", 0, OPT_BOOLEAN, "spider", -1 },
 253     { "strict-comments", 0, OPT_BOOLEAN, "strictcomments", -1 },
 254     { "timeout", 'T', OPT_VALUE, "timeout", -1 },
 255     { "timestamping", 'N', OPT_BOOLEAN, "timestamping", -1 },
 256     { "tries", 't', OPT_VALUE, "tries", -1 },
 257     { "user", 0, OPT_VALUE, "user", -1 },
 258     { "user-agent", 'U', OPT_VALUE, "useragent", -1 },
 259     { "verbose", 'v', OPT_BOOLEAN, "verbose", -1 },
 260     { "verbose", 0, OPT_BOOLEAN, "verbose", -1 },
 261     { "version", 'V', OPT_FUNCALL, (void *) print_version, no_argument },
 262     { "wait", 'w', OPT_VALUE, "wait", -1 },
 263     { "waitretry", 0, OPT_VALUE, "waitretry", -1 },
 264 #ifdef MSDOS
 265     { "wdebug", 0, OPT_BOOLEAN, "wdebug", -1 },
 266 #endif
 267   };
 268
 269 #undef WHEN_DEBUG
 270 #undef IF_SSL
 271
 272 /* Return a string that contains S with "no-" prepended.  The string
 273    is NUL-terminated and allocated off static storage at Wget
 274    startup.  */
 275
 276 static char *
 277 no_prefix (const char *s)
 278 {
 279   static char buffer[1024];
 280   static char *p = buffer;
 281
 282   char *cp = p;
 283   int size = 3 + strlen (s) + 1;  /* "no-STRING\0" */
 284   if (p + size >= buffer + sizeof (buffer))
 285     abort ();
 286
 287   cp[0] = 'n', cp[1] = 'o', cp[2] = '-';
 288   strcpy (cp + 3, s);
 289   p += size;
 290   return cp;
 291 }
 292
 293 /* The arguments that that main passes to getopt_long. */
 294 static struct option long_options[2 * countof (option_data) + 1];
 295 static char short_options[128];
 296
 297 /* Mapping between short option chars and option_data indices. */
 298 static unsigned char optmap[96];
 299
 300 /* Marker for `--no-FOO' values in long_options.  */
 301 #define BOOLEAN_NEG_MARKER 1024
 302
 303 /* Initialize the long_options array used by getopt_long from the data
 304    in option_data.  */
 305
 306 static void
 307 init_switches (void)
 308 {
 309   char *p = short_options;
 310   size_t i, o = 0;
 311   for (i = 0; i < countof (option_data); i++)
 312     {
 313       struct cmdline_option *opt = &option_data[i];
 314       struct option *longopt;
 315
 316       if (!opt->long_name)
 317         /* The option is disabled. */
 318         continue;
 319
 320       longopt = &long_options[o++];
 321       longopt->name = opt->long_name;
 322       longopt->val = i;
 323       if (opt->short_name)
 324         {
 325           *p++ = opt->short_name;
 326           optmap[opt->short_name - 32] = longopt - long_options;
 327         }
 328       switch (opt->type)
 329         {
 330         case OPT_VALUE:
 331           longopt->has_arg = required_argument;
 332           if (opt->short_name)
 333             *p++ = ':';
 334           break;
 335         case OPT_BOOLEAN:
 336           /* Specify an optional argument for long options, so that
 337              --option=off works the same as --no-option, for
 338              compatibility with pre-1.10 Wget.  However, don't specify
 339              optional arguments short-option booleans because they
 340              prevent combining of short options.  */
 341           longopt->has_arg = optional_argument;
 342           /* For Boolean options, add the "--no-FOO" variant, which is
 343              identical to "--foo", except it has opposite meaning and
 344              it doesn't allow an argument.  */
 345           longopt = &long_options[o++];
 346           longopt->name = no_prefix (opt->long_name);
 347           longopt->has_arg = no_argument;
 348           /* Mask the value so we'll be able to recognize that we're
 349              dealing with the false value.  */
 350           longopt->val = i | BOOLEAN_NEG_MARKER;
 351           break;
 352         default:
 353           assert (opt->argtype != -1);
 354           longopt->has_arg = opt->argtype;
 355           if (opt->short_name)
 356             {
 357               if (longopt->has_arg == required_argument)
 358                 *p++ = ':';
 359               /* Don't handle optional_argument */
 360             }
 361         }
 362     }
 363   /* Terminate short_options. */
 364   *p = '\0';
 365   /* No need for xzero(long_options[o]) because its storage is static
 366      and it will be zeroed by default.  */
 367   assert (o <= countof (long_options));
 368 }
 369
 370 /* Print the usage message.  */
 371 static void
 372 print_usage (void)
 373 {
 374   printf (_("Usage: %s [OPTION]... [URL]...\n"), exec_name);
 375 }
 376
 377 /* Print the help message, describing all the available options.  If
 378    you add an option, be sure to update this list.  */
 379 static void
 380 print_help (void)
 381 {
 382   /* We split the help text this way to ease translation of individual
 383      entries.  */
 384   static const char *help[] = {
 385     "\n",
 386     N_("\
 387 Mandatory arguments to long options are mandatory for short options too.\n\n"),
 388     N_("\
 389 Startup:\n"),
 390     N_("\
 391   -V,  --version           display the version of Wget and exit.\n"),
 392     N_("\
 393   -h,  --help              print this help.\n"),
 394     N_("\
 395   -b,  --background        go to background after startup.\n"),
 396     N_("\
 397   -e,  --execute=COMMAND   execute a `.wgetrc'-style command.\n"),
 398     "\n",
 399
 400     N_("\
 401 Logging and input file:\n"),
 402     N_("\
 403   -o,  --output-file=FILE    log messages to FILE.\n"),
 404     N_("\
 405   -a,  --append-output=FILE  append messages to FILE.\n"),
 406 #ifdef ENABLE_DEBUG
 407     N_("\
 408   -d,  --debug               print lots of debugging information.\n"),
 409 #endif
 410 #ifdef MSDOS
 411     N_("\
 412        --wdebug              print Watt-32 debug output.\n"),
 413 #endif
 414     N_("\
 415   -q,  --quiet               quiet (no output).\n"),
 416     N_("\
 417   -v,  --verbose             be verbose (this is the default).\n"),
 418     N_("\
 419   -nv, --no-verbose          turn off verboseness, without being quiet.\n"),
 420     N_("\
 421   -i,  --input-file=FILE     download URLs found in local or external FILE.\n"),
 422     N_("\
 423   -F,  --force-html          treat input file as HTML.\n"),
 424     N_("\
 425   -B,  --base=URL            prepends URL to relative links in -F -i file.\n"),
 426     "\n",
 427
 428     N_("\
 429 Download:\n"),
 430     N_("\
 431   -t,  --tries=NUMBER            set number of retries to NUMBER (0 unlimits).\n"),
 432     N_("\
 433        --retry-connrefused       retry even if connection is refused.\n"),
 434     N_("\
 435   -O,  --output-document=FILE    write documents to FILE.\n"),
 436     N_("\
 437   -nc, --no-clobber              skip downloads that would download to\n\
 438                                  existing files.\n"),
 439     N_("\
 440   -c,  --continue                resume getting a partially-downloaded file.\n"),
 441     N_("\
 442        --progress=TYPE           select progress gauge type.\n"),
 443     N_("\
 444   -N,  --timestamping            don't re-retrieve files unless newer than\n\
 445                                  local.\n"),
 446     N_("\
 447   -S,  --server-response         print server response.\n"),
 448     N_("\
 449        --spider                  don't download anything.\n"),
 450     N_("\
 451   -T,  --timeout=SECONDS         set all timeout values to SECONDS.\n"),
 452     N_("\
 453        --dns-timeout=SECS        set the DNS lookup timeout to SECS.\n"),
 454     N_("\
 455        --connect-timeout=SECS    set the connect timeout to SECS.\n"),
 456     N_("\
 457        --read-timeout=SECS       set the read timeout to SECS.\n"),
 458     N_("\
 459   -w,  --wait=SECONDS            wait SECONDS between retrievals.\n"),
 460     N_("\
 461        --waitretry=SECONDS       wait 1..SECONDS between retries of a retrieval.\n"),
 462     N_("\
 463        --random-wait             wait from 0...2*WAIT secs between retrievals.\n"),
 464     N_("\
 465        --no-proxy                explicitly turn off proxy.\n"),
 466     N_("\
 467   -Q,  --quota=NUMBER            set retrieval quota to NUMBER.\n"),
 468     N_("\
 469        --bind-address=ADDRESS    bind to ADDRESS (hostname or IP) on local host.\n"),
 470     N_("\
 471        --limit-rate=RATE         limit download rate to RATE.\n"),
 472     N_("\
 473        --no-dns-cache            disable caching DNS lookups.\n"),
 474     N_("\
 475        --restrict-file-names=OS  restrict chars in file names to ones OS allows.\n"),
 476     N_("\
 477        --ignore-case             ignore case when matching files/directories.\n"),
 478 #ifdef ENABLE_IPV6
 479     N_("\
 480   -4,  --inet4-only              connect only to IPv4 addresses.\n"),
 481     N_("\
 482   -6,  --inet6-only              connect only to IPv6 addresses.\n"),
 483     N_("\
 484        --prefer-family=FAMILY    connect first to addresses of specified family,\n\
 485                                  one of IPv6, IPv4, or none.\n"),
 486 #endif
 487     N_("\
 488        --user=USER               set both ftp and http user to USER.\n"),
 489     N_("\
 490        --password=PASS           set both ftp and http password to PASS.\n"),
 491     N_("\
 492        --ask-password            prompt for passwords.\n"),
 493     "\n",
 494
 495     N_("\
 496 Directories:\n"),
 497     N_("\
 498   -nd, --no-directories           don't create directories.\n"),
 499     N_("\
 500   -x,  --force-directories        force creation of directories.\n"),
 501     N_("\
 502   -nH, --no-host-directories      don't create host directories.\n"),
 503     N_("\
 504        --protocol-directories     use protocol name in directories.\n"),
 505     N_("\
 506   -P,  --directory-prefix=PREFIX  save files to PREFIX/...\n"),
 507     N_("\
 508        --cut-dirs=NUMBER          ignore NUMBER remote directory components.\n"),
 509     "\n",
 510
 511     N_("\
 512 HTTP options:\n"),
 513     N_("\
 514        --http-user=USER        set http user to USER.\n"),
 515     N_("\
 516        --http-password=PASS    set http password to PASS.\n"),
 517     N_("\
 518        --no-cache              disallow server-cached data.\n"),
 519     N_("\
 520   -E,  --html-extension        save HTML documents with `.html' extension.\n"),
 521     N_("\
 522        --ignore-length         ignore `Content-Length' header field.\n"),
 523     N_("\
 524        --header=STRING         insert STRING among the headers.\n"),
 525     N_("\
 526        --max-redirect          maximum redirections allowed per page.\n"),
 527     N_("\
 528        --proxy-user=USER       set USER as proxy username.\n"),
 529     N_("\
 530        --proxy-password=PASS   set PASS as proxy password.\n"),
 531     N_("\
 532        --referer=URL           include `Referer: URL' header in HTTP request.\n"),
 533     N_("\
 534        --save-headers          save the HTTP headers to file.\n"),
 535     N_("\
 536   -U,  --user-agent=AGENT      identify as AGENT instead of Wget/VERSION.\n"),
 537     N_("\
 538        --no-http-keep-alive    disable HTTP keep-alive (persistent connections).\n"),
 539     N_("\
 540        --no-cookies            don't use cookies.\n"),
 541     N_("\
 542        --load-cookies=FILE     load cookies from FILE before session.\n"),
 543     N_("\
 544        --save-cookies=FILE     save cookies to FILE after session.\n"),
 545     N_("\
 546        --keep-session-cookies  load and save session (non-permanent) cookies.\n"),
 547     N_("\
 548        --post-data=STRING      use the POST method; send STRING as the data.\n"),
 549     N_("\
 550        --post-file=FILE        use the POST method; send contents of FILE.\n"),
 551     N_("\
 552        --content-disposition   honor the Content-Disposition header when\n\
 553                                choosing local file names (EXPERIMENTAL).\n"),
 554     N_("\
 555        --auth-no-challenge     Send Basic HTTP authentication information\n\
 556                                without first waiting for the server's\n\
 557                                challenge.\n"),
 558     "\n",
 559
 560 #ifdef HAVE_SSL
 561     N_("\
 562 HTTPS (SSL/TLS) options:\n"),
 563     N_("\
 564        --secure-protocol=PR     choose secure protocol, one of auto, SSLv2,\n\
 565                                 SSLv3, and TLSv1.\n"),
 566     N_("\
 567        --no-check-certificate   don't validate the server's certificate.\n"),
 568     N_("\
 569        --certificate=FILE       client certificate file.\n"),
 570     N_("\
 571        --certificate-type=TYPE  client certificate type, PEM or DER.\n"),
 572     N_("\
 573        --private-key=FILE       private key file.\n"),
 574     N_("\
 575        --private-key-type=TYPE  private key type, PEM or DER.\n"),
 576     N_("\
 577        --ca-certificate=FILE    file with the bundle of CA's.\n"),
 578     N_("\
 579        --ca-directory=DIR       directory where hash list of CA's is stored.\n"),
 580     N_("\
 581        --random-file=FILE       file with random data for seeding the SSL PRNG.\n"),
 582     N_("\
 583        --egd-file=FILE          file naming the EGD socket with random data.\n"),
 584     "\n",
 585 #endif /* HAVE_SSL */
 586
 587     N_("\
 588 FTP options:\n"),
 589     N_("\
 590        --ftp-user=USER         set ftp user to USER.\n"),
 591     N_("\
 592        --ftp-password=PASS     set ftp password to PASS.\n"),
 593     N_("\
 594        --no-remove-listing     don't remove `.listing' files.\n"),
 595     N_("\
 596        --no-glob               turn off FTP file name globbing.\n"),
 597     N_("\
 598        --no-passive-ftp        disable the \"passive\" transfer mode.\n"),
 599     N_("\
 600        --retr-symlinks         when recursing, get linked-to files (not dir).\n"),
 601     N_("\
 602        --preserve-permissions  preserve remote file permissions.\n"),
 603     "\n",
 604
 605     N_("\
 606 Recursive download:\n"),
 607     N_("\
 608   -r,  --recursive          specify recursive download.\n"),
 609     N_("\
 610   -l,  --level=NUMBER       maximum recursion depth (inf or 0 for infinite).\n"),
 611     N_("\
 612        --delete-after       delete files locally after downloading them.\n"),
 613     N_("\
 614   -k,  --convert-links      make links in downloaded HTML or CSS point to\n\
 615                             local files.\n"),
 616     N_("\
 617   -K,  --backup-converted   before converting file X, back up as X.orig.\n"),
 618     N_("\
 619   -m,  --mirror             shortcut for -N -r -l inf --no-remove-listing.\n"),
 620     N_("\
 621   -p,  --page-requisites    get all images, etc. needed to display HTML page.\n"),
 622     N_("\
 623        --strict-comments    turn on strict (SGML) handling of HTML comments.\n"),
 624     "\n",
 625
 626     N_("\
 627 Recursive accept/reject:\n"),
 628     N_("\
 629   -A,  --accept=LIST               comma-separated list of accepted extensions.\n"),
 630     N_("\
 631   -R,  --reject=LIST               comma-separated list of rejected extensions.\n"),
 632     N_("\
 633   -D,  --domains=LIST              comma-separated list of accepted domains.\n"),
 634     N_("\
 635        --exclude-domains=LIST      comma-separated list of rejected domains.\n"),
 636     N_("\
 637        --follow-ftp                follow FTP links from HTML documents.\n"),
 638     N_("\
 639        --follow-tags=LIST          comma-separated list of followed HTML tags.\n"),
 640     N_("\
 641        --ignore-tags=LIST          comma-separated list of ignored HTML tags.\n"),
 642     N_("\
 643   -H,  --span-hosts                go to foreign hosts when recursive.\n"),
 644     N_("\
 645   -L,  --relative                  follow relative links only.\n"),
 646     N_("\
 647   -I,  --include-directories=LIST  list of allowed directories.\n"),
 648     N_("\
 649   -X,  --exclude-directories=LIST  list of excluded directories.\n"),
 650     N_("\
 651   -np, --no-parent                 don't ascend to the parent directory.\n"),
 652     "\n",
 653
 654     N_("Mail bug reports and suggestions to <bug-wget@gnu.org>.\n")
 655   };
 656
 657   size_t i;
 658
 659   printf (_("GNU Wget %s, a non-interactive network retriever.\n"),
 660           version_string);
 661   print_usage ();
 662
 663   for (i = 0; i < countof (help); i++)
 664     fputs (_(help[i]), stdout);
 665
 666   exit (0);
 667 }
 668
 669 /* Return a human-readable printed representation of INTERVAL,
 670    measured in seconds.  */
 671
 672 static char *
 673 secs_to_human_time (double interval)
 674 {
 675   static char buf[32];
 676   int secs = (int) (interval + 0.5);
 677   int hours, mins, days;
 678
 679   days = secs / 86400, secs %= 86400;
 680   hours = secs / 3600, secs %= 3600;
 681   mins = secs / 60, secs %= 60;
 682
 683   if (days)
 684     sprintf (buf, "%dd %dh %dm %ds", days, hours, mins, secs);
 685   else if (hours)
 686     sprintf (buf, "%dh %dm %ds", hours, mins, secs);
 687   else if (mins)
 688     sprintf (buf, "%dm %ds", mins, secs);
 689   else
 690     sprintf (buf, "%ss", print_decimal (interval));
 691
 692   return buf;
 693 }
 694
 695 static char *
 696 prompt_for_password (void)
 697 {
 698   if (opt.user)
 699     printf (_("Password for user %s: "), quote (opt.user));
 700   else
 701     printf (_("Password: "));
 702   return getpass("");
 703 }
 704
 705 /* Function that prints the line argument while limiting it
 706    to at most line_length. prefix is printed on the first line
 707    and an appropriate number of spaces are added on subsequent
 708    lines.*/
 709 static void
 710 format_and_print_line (char* prefix, char* line,
 711                        int line_length)
 712 {
 713   assert (prefix != NULL);
 714   assert (line != NULL);
 715
 716   if (line_length <= 0)
 717     line_length = max_chars_per_line;
 718
 719   const int leading_spaces = strlen (prefix);
 720   printf ("%s", prefix);
 721   int remaining_chars = line_length - leading_spaces;
 722   /* We break on spaces. */
 723   char* token = strtok (line, " ");
 724   while (token != NULL)
 725     {
 726       /* If however a token is much larger than the maximum
 727          line length, all bets are off and we simply print the
 728          token on the next line. */
 729       if (remaining_chars <= strlen (token))
 730         {
 731           printf ("\n");
 732           int j = 0;
 733           for (j = 0; j < leading_spaces; j++)
 734             {
 735               printf (" ");
 736             }
 737           remaining_chars = line_length - leading_spaces;
 738         }
 739       printf ("%s ", token);
 740       remaining_chars -= strlen (token) + 1;  // account for " "
 741       token = strtok (NULL, " ");
 742     }
 743
 744   printf ("\n");
 745   xfree (prefix);
 746   xfree (line);
 747 }
 748
 749 static void
 750 print_version (void)
 751 {
 752   const char *options_title = "Options    : ";
 753   const char *wgetrc_title  = "Wgetrc     : ";
 754   const char *locale_title  = "Locale     : ";
 755   const char *compile_title = "Compile    : ";
 756   const char *link_title    = "Link       : ";
 757   const char *prefix_spaces = "             ";
 758   const int prefix_space_length = strlen (prefix_spaces);
 759
 760   printf ("GNU Wget %s\n", version_string);
 761   printf (options_title);
 762   /* compiled_features is a char*[]. We limit the characters per
 763      line to max_chars_per_line and prefix each line with a constant
 764      number of spaces for proper alignment. */
 765   int i =0;
 766   for (i = 0; compiled_features[i] != NULL; )
 767     {
 768       int line_length = max_chars_per_line - prefix_space_length;
 769       while ((line_length > 0) && (compiled_features[i] != NULL))
 770         {
 771           printf ("%s ", compiled_features[i]);
 772           line_length -= strlen (compiled_features[i]) + 2;
 773           i++;
 774         }
 775       printf ("\n");
 776       if (compiled_features[i] != NULL)
 777         {
 778           printf (prefix_spaces);
 779         }
 780     }
 781   /* Handle the case when $WGETRC is unset and $HOME/.wgetrc is
 782      absent. */
 783   printf (wgetrc_title);
 784   char *env_wgetrc = wgetrc_env_file_name ();
 785   if (env_wgetrc && *env_wgetrc)
 786     {
 787       printf ("%s (env)\n%s", env_wgetrc, prefix_spaces);
 788       xfree (env_wgetrc);
 789     }
 790   char *user_wgetrc = wgetrc_user_file_name ();
 791   if (user_wgetrc)
 792     {
 793       printf ("%s (user)\n%s", user_wgetrc, prefix_spaces);
 794       xfree (user_wgetrc);
 795     }
 796   printf ("%s (system)\n", system_wgetrc);
 797
 798   format_and_print_line (strdup (locale_title),
 799                          strdup (locale_dir),
 800                          max_chars_per_line);
 801
 802   format_and_print_line (strdup (compile_title),
 803                          strdup (compilation_string),
 804                          max_chars_per_line);
 805
 806   format_and_print_line (strdup (link_title),
 807                          strdup (link_string),
 808                          max_chars_per_line);
 809   printf ("\n");
 810   /* TRANSLATORS: When available, an actual copyright character
 811      (cirle-c) should be used in preference to "(C)". */
 812   fputs (_("\
 813 Copyright (C) 2008 Free Software Foundation, Inc.\n"), stdout);
 814   fputs (_("\
 815 License GPLv3+: GNU GPL version 3 or later\n\
 816 <http://www.gnu.org/licenses/gpl.html>.\n\
 817 This is free software: you are free to change and redistribute it.\n\
 818 There is NO WARRANTY, to the extent permitted by law.\n"), stdout);
 819   /* TRANSLATORS: When available, please use the proper diacritics for
 820      names such as this one. See en_US.po for reference. */
 821   fputs (_("\nOriginally written by Hrvoje Niksic <hniksic@xemacs.org>.\n"),
 822          stdout);
 823   fputs (_("Currently maintained by Micah Cowan <micah@cowan.name>.\n"),
 824          stdout);
 825   exit (0);
 826 }
 827
 828 int
 829 main (int argc, char **argv)
 830 {
 831   char **url, **t;
 832   int i, ret, longindex;
 833   int nurl, status;
 834   bool append_to_log = false;
 835
 836   i18n_initialize ();
 837
 838   /* Construct the name of the executable, without the directory part.  */
 839   exec_name = strrchr (argv[0], PATH_SEPARATOR);
 840   if (!exec_name)
 841     exec_name = argv[0];
 842   else
 843     ++exec_name;
 844
 845 #ifdef WINDOWS
 846   /* Drop extension (typically .EXE) from executable filename. */
 847   windows_main ((char **) &exec_name);
 848 #endif
 849
 850   /* Set option defaults; read the system wgetrc and ~/.wgetrc.  */
 851   initialize ();
 852
 853   init_switches ();
 854   longindex = -1;
 855   while ((ret = getopt_long (argc, argv,
 856                              short_options, long_options, &longindex)) != -1)
 857     {
 858       int val;
 859       struct cmdline_option *opt;
 860
 861       /* If LONGINDEX is unchanged, it means RET is referring a short
 862          option.  */
 863       if (longindex == -1)
 864         {
 865           if (ret == '?')
 866             {
 867               print_usage ();
 868               printf ("\n");
 869               printf (_("Try `%s --help' for more options.\n"), exec_name);
 870               exit (2);
 871             }
 872           /* Find the short option character in the mapping.  */
 873           longindex = optmap[ret - 32];
 874         }
 875       val = long_options[longindex].val;
 876
 877       /* Use the retrieved value to locate the option in the
 878          option_data array, and to see if we're dealing with the
 879          negated "--no-FOO" variant of the boolean option "--foo".  */
 880       opt = &option_data[val & ~BOOLEAN_NEG_MARKER];
 881       switch (opt->type)
 882         {
 883         case OPT_VALUE:
 884           setoptval (opt->data, optarg, opt->long_name);
 885           break;
 886         case OPT_BOOLEAN:
 887           if (optarg)
 888             /* The user has specified a value -- use it. */
 889             setoptval (opt->data, optarg, opt->long_name);
 890           else
 891             {
 892               /* NEG is true for `--no-FOO' style boolean options. */
 893               bool neg = !!(val & BOOLEAN_NEG_MARKER);
 894               setoptval (opt->data, neg ? "0" : "1", opt->long_name);
 895             }
 896           break;
 897         case OPT_FUNCALL:
 898           {
 899             void (*func) (void) = (void (*) (void)) opt->data;
 900             func ();
 901           }
 902           break;
 903         case OPT__APPEND_OUTPUT:
 904           setoptval ("logfile", optarg, opt->long_name);
 905           append_to_log = true;
 906           break;
 907         case OPT__EXECUTE:
 908           run_command (optarg);
 909           break;
 910         case OPT__NO:
 911           {
 912             /* We support real --no-FOO flags now, but keep these
 913                short options for convenience and backward
 914                compatibility.  */
 915             char *p;
 916             for (p = optarg; *p; p++)
 917               switch (*p)
 918                 {
 919                 case 'v':
 920                   setoptval ("verbose", "0", opt->long_name);
 921                   break;
 922                 case 'H':
 923                   setoptval ("addhostdir", "0", opt->long_name);
 924                   break;
 925                 case 'd':
 926                   setoptval ("dirstruct", "0", opt->long_name);
 927                   break;
 928                 case 'c':
 929                   setoptval ("noclobber", "1", opt->long_name);
 930                   break;
 931                 case 'p':
 932                   setoptval ("noparent", "1", opt->long_name);
 933                   break;
 934                 default:
 935                   printf (_("%s: illegal option -- `-n%c'\n"), exec_name, *p);
 936                   print_usage ();
 937                   printf ("\n");
 938                   printf (_("Try `%s --help' for more options.\n"), exec_name);
 939                   exit (1);
 940                 }
 941             break;
 942           }
 943         case OPT__PARENT:
 944         case OPT__CLOBBER:
 945           {
 946             /* The wgetrc commands are named noparent and noclobber,
 947                so we must revert the meaning of the cmdline options
 948                before passing the value to setoptval.  */
 949             bool flag = true;
 950             if (optarg)
 951               flag = (*optarg == '1' || c_tolower (*optarg) == 'y'
 952                       || (c_tolower (optarg[0]) == 'o'
 953                           && c_tolower (optarg[1]) == 'n'));
 954             setoptval (opt->type == OPT__PARENT ? "noparent" : "noclobber",
 955                        flag ? "0" : "1", opt->long_name);
 956             break;
 957           }
 958         case OPT__DONT_REMOVE_LISTING:
 959           setoptval ("removelisting", "0", opt->long_name);
 960           break;
 961         }
 962
 963       longindex = -1;
 964     }
 965
 966   nurl = argc - optind;
 967
 968   /* All user options have now been processed, so it's now safe to do
 969      interoption dependency checks. */
 970
 971   if (opt.reclevel == 0)
 972       opt.reclevel = INFINITE_RECURSION; /* see recur.h for commentary */
 973
 974   if (opt.spider || opt.delete_after)
 975       opt.no_dirstruct = true;
 976
 977   if (opt.page_requisites && !opt.recursive)
 978     {
 979       /* Don't set opt.recursive here because it would confuse the FTP
 980          code.  Instead, call retrieve_tree below when either
 981          page_requisites or recursive is requested.  */
 982       opt.reclevel = 0;
 983       if (!opt.no_dirstruct)
 984         opt.dirstruct = 1;      /* normally handled by cmd_spec_recursive() */
 985     }
 986
 987   if (opt.verbose == -1)
 988     opt.verbose = !opt.quiet;
 989
 990   /* Sanity checks.  */
 991   if (opt.verbose && opt.quiet)
 992     {
 993       printf (_("Can't be verbose and quiet at the same time.\n"));
 994       print_usage ();
 995       exit (1);
 996     }
 997   if (opt.timestamping && opt.noclobber)
 998     {
 999       printf (_("\
1000 Can't timestamp and not clobber old files at the same time.\n"));
1001       print_usage ();
1002       exit (1);
1003     }
1004 #ifdef ENABLE_IPV6
1005   if (opt.ipv4_only && opt.ipv6_only)
1006     {
1007       printf (_("Cannot specify both --inet4-only and --inet6-only.\n"));
1008       print_usage ();
1009       exit (1);
1010     }
1011 #endif
1012   if (opt.output_document)
1013     {
1014       if (opt.convert_links
1015           && (nurl > 1 || opt.page_requisites || opt.recursive))
1016         {
1017           fputs (_("\
1018 Cannot specify both -k and -O if multiple URLs are given, or in combination\n\
1019 with -p or -r. See the manual for details.\n\n"), stdout);
1020           print_usage ();
1021           exit (1);
1022         }
1023       if (opt.page_requisites
1024           || opt.recursive)
1025         {
1026           logprintf (LOG_NOTQUIET, "%s", _("\
1027 WARNING: combining -O with -r or -p will mean that all downloaded content\n\
1028 will be placed in the single file you specified.\n\n"));
1029         }
1030       if (opt.timestamping)
1031         {
1032           logprintf (LOG_NOTQUIET, "%s", _("\
1033 WARNING: timestamping does nothing in combination with -O. See the manual\n\
1034 for details.\n\n"));
1035           opt.timestamping = false;
1036         }
1037       if (opt.noclobber && file_exists_p(opt.output_document))
1038            {
1039               /* Check if output file exists; if it does, exit. */
1040               logprintf (LOG_VERBOSE, _("File `%s' already there; not retrieving.\n"), opt.output_document);
1041               exit(1);
1042            }
1043     }
1044
1045   if (opt.ask_passwd && opt.passwd)
1046     {
1047       printf (_("Cannot specify both --ask-password and --password.\n"));
1048       print_usage ();
1049       exit (1);
1050     }
1051
1052   if (!nurl && !opt.input_filename)
1053     {
1054       /* No URL specified.  */
1055       printf (_("%s: missing URL\n"), exec_name);
1056       print_usage ();
1057       printf ("\n");
1058       /* #### Something nicer should be printed here -- similar to the
1059          pre-1.5 `--help' page.  */
1060       printf (_("Try `%s --help' for more options.\n"), exec_name);
1061       exit (1);
1062     }
1063
1064 #ifdef ENABLE_IRI
1065   if (opt.enable_iri)
1066     {
1067       if (opt.locale && !check_encoding_name (opt.locale))
1068         opt.locale = NULL;
1069
1070       if (!opt.locale)
1071         opt.locale = find_locale ();
1072
1073       if (opt.encoding_remote && !check_encoding_name (opt.encoding_remote))
1074         opt.encoding_remote = NULL;
1075
1076       /*logprintf (LOG_VERBOSE, "Locale = %s\n", quote (opt.locale));*/
1077     }
1078 #else
1079   if (opt.enable_iri || opt.locale || opt.encoding_remote)
1080     {
1081       /* sXXXav : be more specific... */
1082       printf(_("This version does not have support for IRIs\n"));
1083       exit(1);
1084     }
1085 #endif
1086
1087   if (opt.ask_passwd)
1088     {
1089       opt.passwd = prompt_for_password ();
1090
1091       if (opt.passwd == NULL || opt.passwd[0] == '\0')
1092         exit (1);
1093     }
1094
1095 #ifdef MSDOS
1096   if (opt.wdebug)
1097      dbug_init();
1098   sock_init();
1099 #else
1100   if (opt.background)
1101     fork_to_background ();
1102 #endif
1103
1104   /* Initialize progress.  Have to do this after the options are
1105      processed so we know where the log file is.  */
1106   if (opt.verbose)
1107     set_progress_implementation (opt.progress_type);
1108
1109   /* Fill in the arguments.  */
1110   url = alloca_array (char *, nurl + 1);
1111   for (i = 0; i < nurl; i++, optind++)
1112     {
1113       char *rewritten = rewrite_shorthand_url (argv[optind]);
1114       if (rewritten)
1115         url[i] = rewritten;
1116       else
1117         url[i] = xstrdup (argv[optind]);
1118     }
1119   url[i] = NULL;
1120
1121   /* Initialize logging.  */
1122   log_init (opt.lfilename, append_to_log);
1123
1124   DEBUGP (("DEBUG output created by Wget %s on %s.\n\n", version_string,
1125            OS_TYPE));
1126
1127   /* Open the output filename if necessary.  */
1128   if (opt.output_document)
1129     {
1130       if (HYPHENP (opt.output_document))
1131         {
1132 #ifdef WINDOWS
1133           FILE *result;
1134           result = freopen (NULL, "wb", stdout);
1135           if (result == NULL)
1136             {
1137               logputs (LOG_NOTQUIET, _("\
1138 WARNING: Can't reopen standard output in binary mode;\n\
1139          downloaded file may contain inappropriate line endings.\n"));
1140             }
1141 #endif
1142           output_stream = stdout;
1143         }
1144       else
1145         {
1146           struct_fstat st;
1147           output_stream = fopen (opt.output_document,
1148                                  opt.always_rest ? "ab" : "wb");
1149           if (output_stream == NULL)
1150             {
1151               perror (opt.output_document);
1152               exit (1);
1153             }
1154           if (fstat (fileno (output_stream), &st) == 0 && S_ISREG (st.st_mode))
1155             output_stream_regular = true;
1156         }
1157     }
1158
1159 #ifdef WINDOWS
1160   ws_startup ();
1161 #endif
1162
1163 #ifdef SIGHUP
1164   /* Setup the signal handler to redirect output when hangup is
1165      received.  */
1166   if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
1167     signal(SIGHUP, redirect_output_signal);
1168 #endif
1169   /* ...and do the same for SIGUSR1.  */
1170 #ifdef SIGUSR1
1171   signal (SIGUSR1, redirect_output_signal);
1172 #endif
1173 #ifdef SIGPIPE
1174   /* Writing to a closed socket normally signals SIGPIPE, and the
1175      process exits.  What we want is to ignore SIGPIPE and just check
1176      for the return value of write().  */
1177   signal (SIGPIPE, SIG_IGN);
1178 #endif
1179 #ifdef SIGWINCH
1180   signal (SIGWINCH, progress_handle_sigwinch);
1181 #endif
1182
1183   status = RETROK;              /* initialize it, just-in-case */
1184   /* Retrieve the URLs from argument list.  */
1185   for (t = url; *t; t++)
1186     {
1187       char *filename = NULL, *redirected_URL = NULL;
1188       int dt;
1189
1190       if ((opt.recursive || opt.page_requisites)
1191           && (url_scheme (*t) != SCHEME_FTP || url_uses_proxy (*t)))
1192         {
1193           int old_follow_ftp = opt.follow_ftp;
1194
1195           /* Turn opt.follow_ftp on in case of recursive FTP retrieval */
1196           if (url_scheme (*t) == SCHEME_FTP)
1197             opt.follow_ftp = 1;
1198
1199           status = retrieve_tree (*t, NULL);
1200
1201           opt.follow_ftp = old_follow_ftp;
1202         }
1203       else
1204         {
1205           struct iri *i = iri_new ();
1206           set_uri_encoding (i, opt.locale, true);
1207           status = retrieve_url (*t, &filename, &redirected_URL, NULL, &dt,
1208                                  opt.recursive, i);
1209           iri_free (i);
1210         }
1211
1212       if (opt.delete_after && file_exists_p(filename))
1213         {
1214           DEBUGP (("Removing file due to --delete-after in main():\n"));
1215           logprintf (LOG_VERBOSE, _("Removing %s.\n"), filename);
1216           if (unlink (filename))
1217             logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1218         }
1219
1220       xfree_null (redirected_URL);
1221       xfree_null (filename);
1222     }
1223
1224   /* And then from the input file, if any.  */
1225   if (opt.input_filename)
1226     {
1227       int count;
1228       status = retrieve_from_file (opt.input_filename, opt.force_html, &count);
1229       if (!count)
1230         logprintf (LOG_NOTQUIET, _("No URLs found in %s.\n"),
1231                    opt.input_filename);
1232     }
1233
1234   /* Print broken links. */
1235   if (opt.recursive && opt.spider)
1236     {
1237       print_broken_links();
1238     }
1239
1240   /* Print the downloaded sum.  */
1241   if ((opt.recursive || opt.page_requisites
1242        || nurl > 1
1243        || (opt.input_filename && total_downloaded_bytes != 0))
1244       &&
1245       total_downloaded_bytes != 0)
1246     {
1247       logprintf (LOG_NOTQUIET,
1248                  _("FINISHED --%s--\nDownloaded: %d files, %s in %s (%s)\n"),
1249                  datetime_str (time (NULL)),
1250                  opt.numurls,
1251                  human_readable (total_downloaded_bytes),
1252                  secs_to_human_time (total_download_time),
1253                  retr_rate (total_downloaded_bytes, total_download_time));
1254       /* Print quota warning, if exceeded.  */
1255       if (opt.quota && total_downloaded_bytes > opt.quota)
1256         logprintf (LOG_NOTQUIET,
1257                    _("Download quota of %s EXCEEDED!\n"),
1258                    human_readable (opt.quota));
1259     }
1260
1261   if (opt.cookies_output)
1262     save_cookies ();
1263
1264   if (opt.convert_links && !opt.delete_after)
1265     convert_all_links ();
1266
1267   log_close ();
1268   for (i = 0; i < nurl; i++)
1269     xfree (url[i]);
1270   cleanup ();
1271
1272 #ifdef DEBUG_MALLOC
1273   print_malloc_debug_stats ();
1274 #endif
1275   if (status == RETROK)
1276     return 0;
1277   else
1278     return 1;
1279 }
1280 #endif /* TESTING */
1281 \f
1282 #if defined(SIGHUP) || defined(SIGUSR1)
1283
1284 /* So the signal_name check doesn't blow when only one is available. */
1285 #ifndef SIGHUP
1286 # define SIGHUP -1
1287 #endif
1288 #ifndef SIGUSR1
1289 # define SIGUSR1 -1
1290 #endif
1291
1292 /* Hangup signal handler.  When wget receives SIGHUP or SIGUSR1, it
1293    will proceed operation as usual, trying to write into a log file.
1294    If that is impossible, the output will be turned off.  */
1295
1296 static void
1297 redirect_output_signal (int sig)
1298 {
1299   const char *signal_name = (sig == SIGHUP ? "SIGHUP" :
1300                              (sig == SIGUSR1 ? "SIGUSR1" :
1301                               "WTF?!"));
1302   log_request_redirect_output (signal_name);
1303   progress_schedule_redirect ();
1304   signal (sig, redirect_output_signal);
1305 }
1306 #endif
1307
1308 /*
1309  * vim: et ts=2 sw=2
1310  */