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   -E,  --html-extension        save HTML documents with `.html' extension.\n"),
 519     N_("\
 520        --ignore-length         ignore `Content-Length' header field.\n"),
 521     N_("\
 522        --header=STRING         insert STRING among the headers.\n"),
 523     N_("\
 524        --max-redirect          maximum redirections allowed per page.\n"),
 525     N_("\
 526        --proxy-user=USER       set USER as proxy username.\n"),
 527     N_("\
 528        --proxy-password=PASS   set PASS as proxy password.\n"),
 529     N_("\
 530        --referer=URL           include `Referer: URL' header in HTTP request.\n"),
 531     N_("\
 532        --save-headers          save the HTTP headers to file.\n"),
 533     N_("\
 534   -U,  --user-agent=AGENT      identify as AGENT instead of Wget/VERSION.\n"),
 535     N_("\
 536        --no-http-keep-alive    disable HTTP keep-alive (persistent connections).\n"),
 537     N_("\
 538        --no-cookies            don't use cookies.\n"),
 539     N_("\
 540        --load-cookies=FILE     load cookies from FILE before session.\n"),
 541     N_("\
 542        --save-cookies=FILE     save cookies to FILE after session.\n"),
 543     N_("\
 544        --keep-session-cookies  load and save session (non-permanent) cookies.\n"),
 545     N_("\
 546        --post-data=STRING      use the POST method; send STRING as the data.\n"),
 547     N_("\
 548        --post-file=FILE        use the POST method; send contents of FILE.\n"),
 549     N_("\
 550        --content-disposition   honor the Content-Disposition header when\n\
 551                                choosing local file names (EXPERIMENTAL).\n"),
 552     N_("\
 553        --auth-no-challenge     Send Basic HTTP authentication information\n\
 554                                without first waiting for the server's\n\
 555                                challenge.\n"),
 556     "\n",
 557
 558 #ifdef HAVE_SSL
 559     N_("\
 560 HTTPS (SSL/TLS) options:\n"),
 561     N_("\
 562        --secure-protocol=PR     choose secure protocol, one of auto, SSLv2,\n\
 563                                 SSLv3, and TLSv1.\n"),
 564     N_("\
 565        --no-check-certificate   don't validate the server's certificate.\n"),
 566     N_("\
 567        --certificate=FILE       client certificate file.\n"),
 568     N_("\
 569        --certificate-type=TYPE  client certificate type, PEM or DER.\n"),
 570     N_("\
 571        --private-key=FILE       private key file.\n"),
 572     N_("\
 573        --private-key-type=TYPE  private key type, PEM or DER.\n"),
 574     N_("\
 575        --ca-certificate=FILE    file with the bundle of CA's.\n"),
 576     N_("\
 577        --ca-directory=DIR       directory where hash list of CA's is stored.\n"),
 578     N_("\
 579        --random-file=FILE       file with random data for seeding the SSL PRNG.\n"),
 580     N_("\
 581        --egd-file=FILE          file naming the EGD socket with random data.\n"),
 582     "\n",
 583 #endif /* HAVE_SSL */
 584
 585     N_("\
 586 FTP options:\n"),
 587     N_("\
 588        --ftp-user=USER         set ftp user to USER.\n"),
 589     N_("\
 590        --ftp-password=PASS     set ftp password to PASS.\n"),
 591     N_("\
 592        --no-remove-listing     don't remove `.listing' files.\n"),
 593     N_("\
 594        --no-glob               turn off FTP file name globbing.\n"),
 595     N_("\
 596        --no-passive-ftp        disable the \"passive\" transfer mode.\n"),
 597     N_("\
 598        --retr-symlinks         when recursing, get linked-to files (not dir).\n"),
 599     N_("\
 600        --preserve-permissions  preserve remote file permissions.\n"),
 601     "\n",
 602
 603     N_("\
 604 Recursive download:\n"),
 605     N_("\
 606   -r,  --recursive          specify recursive download.\n"),
 607     N_("\
 608   -l,  --level=NUMBER       maximum recursion depth (inf or 0 for infinite).\n"),
 609     N_("\
 610        --delete-after       delete files locally after downloading them.\n"),
 611     N_("\
 612   -k,  --convert-links      make links in downloaded HTML or CSS point to\n\
 613                             local files.\n"),
 614     N_("\
 615   -K,  --backup-converted   before converting file X, back up as X.orig.\n"),
 616     N_("\
 617   -m,  --mirror             shortcut for -N -r -l inf --no-remove-listing.\n"),
 618     N_("\
 619   -p,  --page-requisites    get all images, etc. needed to display HTML page.\n"),
 620     N_("\
 621        --strict-comments    turn on strict (SGML) handling of HTML comments.\n"),
 622     "\n",
 623
 624     N_("\
 625 Recursive accept/reject:\n"),
 626     N_("\
 627   -A,  --accept=LIST               comma-separated list of accepted extensions.\n"),
 628     N_("\
 629   -R,  --reject=LIST               comma-separated list of rejected extensions.\n"),
 630     N_("\
 631   -D,  --domains=LIST              comma-separated list of accepted domains.\n"),
 632     N_("\
 633        --exclude-domains=LIST      comma-separated list of rejected domains.\n"),
 634     N_("\
 635        --follow-ftp                follow FTP links from HTML documents.\n"),
 636     N_("\
 637        --follow-tags=LIST          comma-separated list of followed HTML tags.\n"),
 638     N_("\
 639        --ignore-tags=LIST          comma-separated list of ignored HTML tags.\n"),
 640     N_("\
 641   -H,  --span-hosts                go to foreign hosts when recursive.\n"),
 642     N_("\
 643   -L,  --relative                  follow relative links only.\n"),
 644     N_("\
 645   -I,  --include-directories=LIST  list of allowed directories.\n"),
 646     N_("\
 647   -X,  --exclude-directories=LIST  list of excluded directories.\n"),
 648     N_("\
 649   -np, --no-parent                 don't ascend to the parent directory.\n"),
 650     "\n",
 651
 652     N_("Mail bug reports and suggestions to <bug-wget@gnu.org>.\n")
 653   };
 654
 655   size_t i;
 656
 657   printf (_("GNU Wget %s, a non-interactive network retriever.\n"),
 658           version_string);
 659   print_usage ();
 660
 661   for (i = 0; i < countof (help); i++)
 662     fputs (_(help[i]), stdout);
 663
 664   exit (0);
 665 }
 666
 667 /* Return a human-readable printed representation of INTERVAL,
 668    measured in seconds.  */
 669
 670 static char *
 671 secs_to_human_time (double interval)
 672 {
 673   static char buf[32];
 674   int secs = (int) (interval + 0.5);
 675   int hours, mins, days;
 676
 677   days = secs / 86400, secs %= 86400;
 678   hours = secs / 3600, secs %= 3600;
 679   mins = secs / 60, secs %= 60;
 680
 681   if (days)
 682     sprintf (buf, "%dd %dh %dm %ds", days, hours, mins, secs);
 683   else if (hours)
 684     sprintf (buf, "%dh %dm %ds", hours, mins, secs);
 685   else if (mins)
 686     sprintf (buf, "%dm %ds", mins, secs);
 687   else
 688     sprintf (buf, "%ss", print_decimal (interval));
 689
 690   return buf;
 691 }
 692
 693 static char *
 694 prompt_for_password (void)
 695 {
 696   if (opt.user)
 697     printf (_("Password for user %s: "), quote (opt.user));
 698   else
 699     printf (_("Password: "));
 700   return getpass("");
 701 }
 702
 703 /* Function that prints the line argument while limiting it
 704    to at most line_length. prefix is printed on the first line
 705    and an appropriate number of spaces are added on subsequent
 706    lines.*/
 707 static void
 708 format_and_print_line (char* prefix, char* line,
 709                        int line_length)
 710 {
 711   assert (prefix != NULL);
 712   assert (line != NULL);
 713
 714   if (line_length <= 0)
 715     line_length = max_chars_per_line;
 716
 717   const int leading_spaces = strlen (prefix);
 718   printf ("%s", prefix);
 719   int remaining_chars = line_length - leading_spaces;
 720   /* We break on spaces. */
 721   char* token = strtok (line, " ");
 722   while (token != NULL)
 723     {
 724       /* If however a token is much larger than the maximum
 725          line length, all bets are off and we simply print the
 726          token on the next line. */
 727       if (remaining_chars <= strlen (token))
 728         {
 729           printf ("\n");
 730           int j = 0;
 731           for (j = 0; j < leading_spaces; j++)
 732             {
 733               printf (" ");
 734             }
 735           remaining_chars = line_length - leading_spaces;
 736         }
 737       printf ("%s ", token);
 738       remaining_chars -= strlen (token) + 1;  // account for " "
 739       token = strtok (NULL, " ");
 740     }
 741
 742   printf ("\n");
 743   xfree (prefix);
 744   xfree (line);
 745 }
 746
 747 static void
 748 print_version (void)
 749 {
 750   const char *options_title = "Options    : ";
 751   const char *wgetrc_title  = "Wgetrc     : ";
 752   const char *locale_title  = "Locale     : ";
 753   const char *compile_title = "Compile    : ";
 754   const char *link_title    = "Link       : ";
 755   const char *prefix_spaces = "             ";
 756   const int prefix_space_length = strlen (prefix_spaces);
 757
 758   printf ("GNU Wget %s\n", version_string);
 759   printf (options_title);
 760   /* compiled_features is a char*[]. We limit the characters per
 761      line to max_chars_per_line and prefix each line with a constant
 762      number of spaces for proper alignment. */
 763   int i =0;
 764   for (i = 0; compiled_features[i] != NULL; )
 765     {
 766       int line_length = max_chars_per_line - prefix_space_length;
 767       while ((line_length > 0) && (compiled_features[i] != NULL))
 768         {
 769           printf ("%s ", compiled_features[i]);
 770           line_length -= strlen (compiled_features[i]) + 2;
 771           i++;
 772         }
 773       printf ("\n");
 774       if (compiled_features[i] != NULL)
 775         {
 776           printf (prefix_spaces);
 777         }
 778     }
 779   /* Handle the case when $WGETRC is unset and $HOME/.wgetrc is
 780      absent. */
 781   printf (wgetrc_title);
 782   char *env_wgetrc = wgetrc_env_file_name ();
 783   if (env_wgetrc && *env_wgetrc)
 784     {
 785       printf ("%s (env)\n%s", env_wgetrc, prefix_spaces);
 786       xfree (env_wgetrc);
 787     }
 788   char *user_wgetrc = wgetrc_user_file_name ();
 789   if (user_wgetrc)
 790     {
 791       printf ("%s (user)\n%s", user_wgetrc, prefix_spaces);
 792       xfree (user_wgetrc);
 793     }
 794   printf ("%s (system)\n", system_wgetrc);
 795
 796   format_and_print_line (strdup (locale_title),
 797                          strdup (locale_dir),
 798                          max_chars_per_line);
 799
 800   format_and_print_line (strdup (compile_title),
 801                          strdup (compilation_string),
 802                          max_chars_per_line);
 803
 804   format_and_print_line (strdup (link_title),
 805                          strdup (link_string),
 806                          max_chars_per_line);
 807   printf ("\n");
 808   /* TRANSLATORS: When available, an actual copyright character
 809      (cirle-c) should be used in preference to "(C)". */
 810   fputs (_("\
 811 Copyright (C) 2008 Free Software Foundation, Inc.\n"), stdout);
 812   fputs (_("\
 813 License GPLv3+: GNU GPL version 3 or later\n\
 814 <http://www.gnu.org/licenses/gpl.html>.\n\
 815 This is free software: you are free to change and redistribute it.\n\
 816 There is NO WARRANTY, to the extent permitted by law.\n"), stdout);
 817   /* TRANSLATORS: When available, please use the proper diacritics for
 818      names such as this one. See en_US.po for reference. */
 819   fputs (_("\nOriginally written by Hrvoje Niksic <hniksic@xemacs.org>.\n"),
 820          stdout);
 821   fputs (_("Currently maintained by Micah Cowan <micah@cowan.name>.\n"),
 822          stdout);
 823   exit (0);
 824 }
 825
 826 int
 827 main (int argc, char **argv)
 828 {
 829   char **url, **t;
 830   int i, ret, longindex;
 831   int nurl, status;
 832   bool append_to_log = false;
 833
 834   i18n_initialize ();
 835
 836   /* Construct the name of the executable, without the directory part.  */
 837   exec_name = strrchr (argv[0], PATH_SEPARATOR);
 838   if (!exec_name)
 839     exec_name = argv[0];
 840   else
 841     ++exec_name;
 842
 843 #ifdef WINDOWS
 844   /* Drop extension (typically .EXE) from executable filename. */
 845   windows_main ((char **) &exec_name);
 846 #endif
 847
 848   /* Set option defaults; read the system wgetrc and ~/.wgetrc.  */
 849   initialize ();
 850
 851   init_switches ();
 852   longindex = -1;
 853   while ((ret = getopt_long (argc, argv,
 854                              short_options, long_options, &longindex)) != -1)
 855     {
 856       int val;
 857       struct cmdline_option *opt;
 858
 859       /* If LONGINDEX is unchanged, it means RET is referring a short
 860          option.  */
 861       if (longindex == -1)
 862         {
 863           if (ret == '?')
 864             {
 865               print_usage ();
 866               printf ("\n");
 867               printf (_("Try `%s --help' for more options.\n"), exec_name);
 868               exit (2);
 869             }
 870           /* Find the short option character in the mapping.  */
 871           longindex = optmap[ret - 32];
 872         }
 873       val = long_options[longindex].val;
 874
 875       /* Use the retrieved value to locate the option in the
 876          option_data array, and to see if we're dealing with the
 877          negated "--no-FOO" variant of the boolean option "--foo".  */
 878       opt = &option_data[val & ~BOOLEAN_NEG_MARKER];
 879       switch (opt->type)
 880         {
 881         case OPT_VALUE:
 882           setoptval (opt->data, optarg, opt->long_name);
 883           break;
 884         case OPT_BOOLEAN:
 885           if (optarg)
 886             /* The user has specified a value -- use it. */
 887             setoptval (opt->data, optarg, opt->long_name);
 888           else
 889             {
 890               /* NEG is true for `--no-FOO' style boolean options. */
 891               bool neg = !!(val & BOOLEAN_NEG_MARKER);
 892               setoptval (opt->data, neg ? "0" : "1", opt->long_name);
 893             }
 894           break;
 895         case OPT_FUNCALL:
 896           {
 897             void (*func) (void) = (void (*) (void)) opt->data;
 898             func ();
 899           }
 900           break;
 901         case OPT__APPEND_OUTPUT:
 902           setoptval ("logfile", optarg, opt->long_name);
 903           append_to_log = true;
 904           break;
 905         case OPT__EXECUTE:
 906           run_command (optarg);
 907           break;
 908         case OPT__NO:
 909           {
 910             /* We support real --no-FOO flags now, but keep these
 911                short options for convenience and backward
 912                compatibility.  */
 913             char *p;
 914             for (p = optarg; *p; p++)
 915               switch (*p)
 916                 {
 917                 case 'v':
 918                   setoptval ("verbose", "0", opt->long_name);
 919                   break;
 920                 case 'H':
 921                   setoptval ("addhostdir", "0", opt->long_name);
 922                   break;
 923                 case 'd':
 924                   setoptval ("dirstruct", "0", opt->long_name);
 925                   break;
 926                 case 'c':
 927                   setoptval ("noclobber", "1", opt->long_name);
 928                   break;
 929                 case 'p':
 930                   setoptval ("noparent", "1", opt->long_name);
 931                   break;
 932                 default:
 933                   printf (_("%s: illegal option -- `-n%c'\n"), exec_name, *p);
 934                   print_usage ();
 935                   printf ("\n");
 936                   printf (_("Try `%s --help' for more options.\n"), exec_name);
 937                   exit (1);
 938                 }
 939             break;
 940           }
 941         case OPT__PARENT:
 942         case OPT__CLOBBER:
 943           {
 944             /* The wgetrc commands are named noparent and noclobber,
 945                so we must revert the meaning of the cmdline options
 946                before passing the value to setoptval.  */
 947             bool flag = true;
 948             if (optarg)
 949               flag = (*optarg == '1' || c_tolower (*optarg) == 'y'
 950                       || (c_tolower (optarg[0]) == 'o'
 951                           && c_tolower (optarg[1]) == 'n'));
 952             setoptval (opt->type == OPT__PARENT ? "noparent" : "noclobber",
 953                        flag ? "0" : "1", opt->long_name);
 954             break;
 955           }
 956         case OPT__DONT_REMOVE_LISTING:
 957           setoptval ("removelisting", "0", opt->long_name);
 958           break;
 959         }
 960
 961       longindex = -1;
 962     }
 963
 964   nurl = argc - optind;
 965
 966   /* All user options have now been processed, so it's now safe to do
 967      interoption dependency checks. */
 968
 969   if (opt.reclevel == 0)
 970       opt.reclevel = INFINITE_RECURSION; /* see recur.h for commentary */
 971
 972   if (opt.spider || opt.delete_after)
 973       opt.no_dirstruct = true;
 974
 975   if (opt.page_requisites && !opt.recursive)
 976     {
 977       /* Don't set opt.recursive here because it would confuse the FTP
 978          code.  Instead, call retrieve_tree below when either
 979          page_requisites or recursive is requested.  */
 980       opt.reclevel = 0;
 981       if (!opt.no_dirstruct)
 982         opt.dirstruct = 1;      /* normally handled by cmd_spec_recursive() */
 983     }
 984
 985   if (opt.verbose == -1)
 986     opt.verbose = !opt.quiet;
 987
 988   /* Sanity checks.  */
 989   if (opt.verbose && opt.quiet)
 990     {
 991       printf (_("Can't be verbose and quiet at the same time.\n"));
 992       print_usage ();
 993       exit (1);
 994     }
 995   if (opt.timestamping && opt.noclobber)
 996     {
 997       printf (_("\
 998 Can't timestamp and not clobber old files at the same time.\n"));
 999       print_usage ();
1000       exit (1);
1001     }
1002 #ifdef ENABLE_IPV6
1003   if (opt.ipv4_only && opt.ipv6_only)
1004     {
1005       printf (_("Cannot specify both --inet4-only and --inet6-only.\n"));
1006       print_usage ();
1007       exit (1);
1008     }
1009 #endif
1010   if (opt.output_document)
1011     {
1012       if (opt.convert_links
1013           && (nurl > 1 || opt.page_requisites || opt.recursive))
1014         {
1015           fputs (_("\
1016 Cannot specify both -k and -O if multiple URLs are given, or in combination\n\
1017 with -p or -r. See the manual for details.\n\n"), stdout);
1018           print_usage ();
1019           exit (1);
1020         }
1021       if (opt.page_requisites
1022           || opt.recursive)
1023         {
1024           logprintf (LOG_NOTQUIET, "%s", _("\
1025 WARNING: combining -O with -r or -p will mean that all downloaded content\n\
1026 will be placed in the single file you specified.\n\n"));
1027         }
1028       if (opt.timestamping)
1029         {
1030           logprintf (LOG_NOTQUIET, "%s", _("\
1031 WARNING: timestamping does nothing in combination with -O. See the manual\n\
1032 for details.\n\n"));
1033           opt.timestamping = false;
1034         }
1035       if (opt.noclobber && file_exists_p(opt.output_document))
1036            {
1037               /* Check if output file exists; if it does, exit. */
1038               logprintf (LOG_VERBOSE, _("File `%s' already there; not retrieving.\n"), opt.output_document);
1039               exit(1);
1040            }
1041     }
1042
1043   if (opt.ask_passwd && opt.passwd)
1044     {
1045       printf (_("Cannot specify both --ask-password and --password.\n"));
1046       print_usage ();
1047       exit (1);
1048     }
1049
1050   if (!nurl && !opt.input_filename)
1051     {
1052       /* No URL specified.  */
1053       printf (_("%s: missing URL\n"), exec_name);
1054       print_usage ();
1055       printf ("\n");
1056       /* #### Something nicer should be printed here -- similar to the
1057          pre-1.5 `--help' page.  */
1058       printf (_("Try `%s --help' for more options.\n"), exec_name);
1059       exit (1);
1060     }
1061
1062   if (opt.ask_passwd)
1063     {
1064       opt.passwd = prompt_for_password ();
1065
1066       if (opt.passwd == NULL || opt.passwd[0] == '\0')
1067         exit (1);
1068     }
1069
1070 #ifdef MSDOS
1071   if (opt.wdebug)
1072      dbug_init();
1073   sock_init();
1074 #else
1075   if (opt.background)
1076     fork_to_background ();
1077 #endif
1078
1079   /* Initialize progress.  Have to do this after the options are
1080      processed so we know where the log file is.  */
1081   if (opt.verbose)
1082     set_progress_implementation (opt.progress_type);
1083
1084   /* Fill in the arguments.  */
1085   url = alloca_array (char *, nurl + 1);
1086   for (i = 0; i < nurl; i++, optind++)
1087     {
1088       char *rewritten = rewrite_shorthand_url (argv[optind]);
1089       if (rewritten)
1090         url[i] = rewritten;
1091       else
1092         url[i] = xstrdup (argv[optind]);
1093     }
1094   url[i] = NULL;
1095
1096   /* Initialize logging.  */
1097   log_init (opt.lfilename, append_to_log);
1098
1099   DEBUGP (("DEBUG output created by Wget %s on %s.\n\n", version_string,
1100            OS_TYPE));
1101
1102   /* Open the output filename if necessary.  */
1103   if (opt.output_document)
1104     {
1105       if (HYPHENP (opt.output_document))
1106         {
1107 #ifdef WINDOWS
1108           FILE *result;
1109           result = freopen (NULL, "wb", stdout);
1110           if (result == NULL)
1111             {
1112               logputs (LOG_NOTQUIET, _("\
1113 WARNING: Can't reopen standard output in binary mode;\n\
1114          downloaded file may contain inappropriate line endings.\n"));
1115             }
1116 #endif
1117           output_stream = stdout;
1118         }
1119       else
1120         {
1121           struct_fstat st;
1122           output_stream = fopen (opt.output_document,
1123                                  opt.always_rest ? "ab" : "wb");
1124           if (output_stream == NULL)
1125             {
1126               perror (opt.output_document);
1127               exit (1);
1128             }
1129           if (fstat (fileno (output_stream), &st) == 0 && S_ISREG (st.st_mode))
1130             output_stream_regular = true;
1131         }
1132     }
1133
1134 #ifdef WINDOWS
1135   ws_startup ();
1136 #endif
1137
1138 #ifdef SIGHUP
1139   /* Setup the signal handler to redirect output when hangup is
1140      received.  */
1141   if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
1142     signal(SIGHUP, redirect_output_signal);
1143 #endif
1144   /* ...and do the same for SIGUSR1.  */
1145 #ifdef SIGUSR1
1146   signal (SIGUSR1, redirect_output_signal);
1147 #endif
1148 #ifdef SIGPIPE
1149   /* Writing to a closed socket normally signals SIGPIPE, and the
1150      process exits.  What we want is to ignore SIGPIPE and just check
1151      for the return value of write().  */
1152   signal (SIGPIPE, SIG_IGN);
1153 #endif
1154 #ifdef SIGWINCH
1155   signal (SIGWINCH, progress_handle_sigwinch);
1156 #endif
1157
1158   status = RETROK;              /* initialize it, just-in-case */
1159   /* Retrieve the URLs from argument list.  */
1160   for (t = url; *t; t++)
1161     {
1162       char *filename = NULL, *redirected_URL = NULL;
1163       int dt;
1164
1165       if ((opt.recursive || opt.page_requisites)
1166           && (url_scheme (*t) != SCHEME_FTP || url_uses_proxy (*t)))
1167         {
1168           int old_follow_ftp = opt.follow_ftp;
1169
1170           /* Turn opt.follow_ftp on in case of recursive FTP retrieval */
1171           if (url_scheme (*t) == SCHEME_FTP)
1172             opt.follow_ftp = 1;
1173
1174           status = retrieve_tree (*t);
1175
1176           opt.follow_ftp = old_follow_ftp;
1177         }
1178       else
1179         status = retrieve_url (*t, &filename, &redirected_URL, NULL, &dt, opt.recursive);
1180
1181       if (opt.delete_after && file_exists_p(filename))
1182         {
1183           DEBUGP (("Removing file due to --delete-after in main():\n"));
1184           logprintf (LOG_VERBOSE, _("Removing %s.\n"), filename);
1185           if (unlink (filename))
1186             logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1187         }
1188
1189       xfree_null (redirected_URL);
1190       xfree_null (filename);
1191     }
1192
1193   /* And then from the input file, if any.  */
1194   if (opt.input_filename)
1195     {
1196       int count;
1197       status = retrieve_from_file (opt.input_filename, opt.force_html, &count);
1198       if (!count)
1199         logprintf (LOG_NOTQUIET, _("No URLs found in %s.\n"),
1200                    opt.input_filename);
1201     }
1202
1203   /* Print broken links. */
1204   if (opt.recursive && opt.spider)
1205     {
1206       print_broken_links();
1207     }
1208
1209   /* Print the downloaded sum.  */
1210   if ((opt.recursive || opt.page_requisites
1211        || nurl > 1
1212        || (opt.input_filename && total_downloaded_bytes != 0))
1213       &&
1214       total_downloaded_bytes != 0)
1215     {
1216       logprintf (LOG_NOTQUIET,
1217                  _("FINISHED --%s--\nDownloaded: %d files, %s in %s (%s)\n"),
1218                  datetime_str (time (NULL)),
1219                  opt.numurls,
1220                  human_readable (total_downloaded_bytes),
1221                  secs_to_human_time (total_download_time),
1222                  retr_rate (total_downloaded_bytes, total_download_time));
1223       /* Print quota warning, if exceeded.  */
1224       if (opt.quota && total_downloaded_bytes > opt.quota)
1225         logprintf (LOG_NOTQUIET,
1226                    _("Download quota of %s EXCEEDED!\n"),
1227                    human_readable (opt.quota));
1228     }
1229
1230   if (opt.cookies_output)
1231     save_cookies ();
1232
1233   if (opt.convert_links && !opt.delete_after)
1234     convert_all_links ();
1235
1236   log_close ();
1237   for (i = 0; i < nurl; i++)
1238     xfree (url[i]);
1239   cleanup ();
1240
1241 #ifdef DEBUG_MALLOC
1242   print_malloc_debug_stats ();
1243 #endif
1244   if (status == RETROK)
1245     return 0;
1246   else
1247     return 1;
1248 }
1249 #endif /* TESTING */
1250 \f
1251 #if defined(SIGHUP) || defined(SIGUSR1)
1252
1253 /* So the signal_name check doesn't blow when only one is available. */
1254 #ifndef SIGHUP
1255 # define SIGHUP -1
1256 #endif
1257 #ifndef SIGUSR1
1258 # define SIGUSR1 -1
1259 #endif
1260
1261 /* Hangup signal handler.  When wget receives SIGHUP or SIGUSR1, it
1262    will proceed operation as usual, trying to write into a log file.
1263    If that is impossible, the output will be turned off.  */
1264
1265 static void
1266 redirect_output_signal (int sig)
1267 {
1268   const char *signal_name = (sig == SIGHUP ? "SIGHUP" :
1269                              (sig == SIGUSR1 ? "SIGUSR1" :
1270                               "WTF?!"));
1271   log_request_redirect_output (signal_name);
1272   progress_schedule_redirect ();
1273   signal (sig, redirect_output_signal);
1274 }
1275 #endif
1276
1277 /*
1278  * vim: et ts=2 sw=2
1279  */