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