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