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

   1 /* Command line parsing.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   3    2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
   4    Inc.
   5
   6 This file is part of GNU Wget.
   7
   8 GNU Wget is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 GNU Wget is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with Wget.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 Additional permission under GNU GPL version 3 section 7
  22
  23 If you modify this program, or any covered work, by linking or
  24 combining it with the OpenSSL project's OpenSSL library (or a
  25 modified version of that library), containing parts covered by the
  26 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
  27 grants you additional permission to convey the resulting work.
  28 Corresponding Source for a non-source form of such a combination
  29 shall include the source code for the parts of OpenSSL used as well
  30 as that of the covered work.  */
  31
  32 #include "wget.h"
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <unistd.h>
  37 #include <string.h>
  38 #include <signal.h>
  39 #ifdef ENABLE_NLS
  40 # include <locale.h>
  41 #endif
  42 #include <assert.h>
  43 #include <errno.h>
  44 #include <time.h>
  45
  46 #include "exits.h"
  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 #include "ptimer.h"
  58 #include "warc.h"
  59
  60 #include <getopt.h>
  61 #include <getpass.h>
  62 #include <quote.h>
  63
  64 #ifdef WINDOWS
  65 # include <io.h>
  66 # include <fcntl.h>
  67 #endif
  68
  69 #ifdef __VMS
  70 # include "vms.h"
  71 #endif /* __VMS */
  72
  73 #ifndef PATH_SEPARATOR
  74 # define PATH_SEPARATOR '/'
  75 #endif
  76
  77 #ifndef ENABLE_IRI
  78 struct iri dummy_iri;
  79 #endif
  80
  81 struct options opt;
  82
  83 /* defined in version.c */
  84 extern char *version_string;
  85 extern char *compilation_string;
  86 extern char *system_getrc;
  87 extern char *link_string;
  88 /* defined in build_info.c */
  89 extern const char *compiled_features[];
  90 /* Used for --version output in print_version */
  91 #define MAX_CHARS_PER_LINE      72
  92 #define TABULATION              4
  93
  94 #if defined(SIGHUP) || defined(SIGUSR1)
  95 static void redirect_output_signal (int);
  96 #endif
  97
  98 const char *exec_name;
  99
 100 /* Number of successfully downloaded URLs */
 101 int numurls = 0;
 102 \f
 103 #ifndef TESTING
 104 /* Initialize I18N/L10N.  That amounts to invoking setlocale, and
 105    setting up gettext's message catalog using bindtextdomain and
 106    textdomain.  Does nothing if NLS is disabled or missing.  */
 107
 108 static void
 109 i18n_initialize (void)
 110 {
 111   /* ENABLE_NLS implies existence of functions invoked here.  */
 112 #ifdef ENABLE_NLS
 113   /* Set the current locale.  */
 114   setlocale (LC_ALL, "");
 115   /* Set the text message domain.  */
 116   bindtextdomain ("wget", LOCALEDIR);
 117   textdomain ("wget");
 118 #endif /* ENABLE_NLS */
 119 }
 120 \f
 121 /* Definition of command-line options. */
 122
 123 static void print_help (void);
 124 static void print_version (void);
 125
 126 #ifdef HAVE_SSL
 127 # define IF_SSL(x) x
 128 #else
 129 # define IF_SSL(x) NULL
 130 #endif
 131
 132 #ifdef ENABLE_DEBUG
 133 # define WHEN_DEBUG(x) x
 134 #else
 135 # define WHEN_DEBUG(x) NULL
 136 #endif
 137
 138 struct cmdline_option {
 139   const char *long_name;
 140   char short_name;
 141   enum {
 142     OPT_VALUE,
 143     OPT_BOOLEAN,
 144     OPT_FUNCALL,
 145     /* Non-standard options that have to be handled specially in
 146        main().  */
 147     OPT__APPEND_OUTPUT,
 148     OPT__CLOBBER,
 149     OPT__DONT_REMOVE_LISTING,
 150     OPT__EXECUTE,
 151     OPT__NO,
 152     OPT__PARENT
 153   } type;
 154   const void *data;             /* for standard options */
 155   int argtype;                  /* for non-standard options */
 156 };
 157
 158 static struct cmdline_option option_data[] =
 159   {
 160     { "accept", 'A', OPT_VALUE, "accept", -1 },
 161     { "adjust-extension", 'E', OPT_BOOLEAN, "adjustextension", -1 },
 162     { "append-output", 'a', OPT__APPEND_OUTPUT, NULL, required_argument },
 163     { "ask-password", 0, OPT_BOOLEAN, "askpassword", -1 },
 164     { "auth-no-challenge", 0, OPT_BOOLEAN, "authnochallenge", -1 },
 165     { "background", 'b', OPT_BOOLEAN, "background", -1 },
 166     { "backup-converted", 'K', OPT_BOOLEAN, "backupconverted", -1 },
 167     { "backups", 0, OPT_BOOLEAN, "backups", -1 },
 168     { "base", 'B', OPT_VALUE, "base", -1 },
 169     { "bind-address", 0, OPT_VALUE, "bindaddress", -1 },
 170     { IF_SSL ("ca-certificate"), 0, OPT_VALUE, "cacertificate", -1 },
 171     { IF_SSL ("ca-directory"), 0, OPT_VALUE, "cadirectory", -1 },
 172     { "cache", 0, OPT_BOOLEAN, "cache", -1 },
 173     { IF_SSL ("certificate"), 0, OPT_VALUE, "certificate", -1 },
 174     { IF_SSL ("certificate-type"), 0, OPT_VALUE, "certificatetype", -1 },
 175     { IF_SSL ("check-certificate"), 0, OPT_BOOLEAN, "checkcertificate", -1 },
 176     { "clobber", 0, OPT__CLOBBER, NULL, optional_argument },
 177     { "config", 0, OPT_VALUE, "chooseconfig", -1 },
 178     { "connect-timeout", 0, OPT_VALUE, "connecttimeout", -1 },
 179     { "continue", 'c', OPT_BOOLEAN, "continue", -1 },
 180     { "convert-links", 'k', OPT_BOOLEAN, "convertlinks", -1 },
 181     { "content-disposition", 0, OPT_BOOLEAN, "contentdisposition", -1 },
 182     { "content-on-error", 0, OPT_BOOLEAN, "contentonerror", -1 },
 183     { "cookies", 0, OPT_BOOLEAN, "cookies", -1 },
 184     { "cut-dirs", 0, OPT_VALUE, "cutdirs", -1 },
 185     { WHEN_DEBUG ("debug"), 'd', OPT_BOOLEAN, "debug", -1 },
 186     { "default-page", 0, OPT_VALUE, "defaultpage", -1 },
 187     { "delete-after", 0, OPT_BOOLEAN, "deleteafter", -1 },
 188     { "directories", 0, OPT_BOOLEAN, "dirstruct", -1 },
 189     { "directory-prefix", 'P', OPT_VALUE, "dirprefix", -1 },
 190     { "dns-cache", 0, OPT_BOOLEAN, "dnscache", -1 },
 191     { "dns-timeout", 0, OPT_VALUE, "dnstimeout", -1 },
 192     { "domains", 'D', OPT_VALUE, "domains", -1 },
 193     { "dont-remove-listing", 0, OPT__DONT_REMOVE_LISTING, NULL, no_argument },
 194     { "dot-style", 0, OPT_VALUE, "dotstyle", -1 }, /* deprecated */
 195     { "egd-file", 0, OPT_VALUE, "egdfile", -1 },
 196     { "exclude-directories", 'X', OPT_VALUE, "excludedirectories", -1 },
 197     { "exclude-domains", 0, OPT_VALUE, "excludedomains", -1 },
 198     { "execute", 'e', OPT__EXECUTE, NULL, required_argument },
 199     { "follow-ftp", 0, OPT_BOOLEAN, "followftp", -1 },
 200     { "follow-tags", 0, OPT_VALUE, "followtags", -1 },
 201     { "force-directories", 'x', OPT_BOOLEAN, "dirstruct", -1 },
 202     { "force-html", 'F', OPT_BOOLEAN, "forcehtml", -1 },
 203     { "ftp-password", 0, OPT_VALUE, "ftppassword", -1 },
 204 #ifdef __VMS
 205     { "ftp-stmlf", 0, OPT_BOOLEAN, "ftpstmlf", -1 },
 206 #endif /* def __VMS */
 207     { "ftp-user", 0, OPT_VALUE, "ftpuser", -1 },
 208     { "glob", 0, OPT_BOOLEAN, "glob", -1 },
 209     { "header", 0, OPT_VALUE, "header", -1 },
 210     { "help", 'h', OPT_FUNCALL, (void *)print_help, no_argument },
 211     { "host-directories", 0, OPT_BOOLEAN, "addhostdir", -1 },
 212     { "html-extension", 'E', OPT_BOOLEAN, "adjustextension", -1 }, /* deprecated */
 213     { "htmlify", 0, OPT_BOOLEAN, "htmlify", -1 },
 214     { "http-keep-alive", 0, OPT_BOOLEAN, "httpkeepalive", -1 },
 215     { "http-passwd", 0, OPT_VALUE, "httppassword", -1 }, /* deprecated */
 216     { "http-password", 0, OPT_VALUE, "httppassword", -1 },
 217     { "http-user", 0, OPT_VALUE, "httpuser", -1 },
 218     { "ignore-case", 0, OPT_BOOLEAN, "ignorecase", -1 },
 219     { "ignore-length", 0, OPT_BOOLEAN, "ignorelength", -1 },
 220     { "ignore-tags", 0, OPT_VALUE, "ignoretags", -1 },
 221     { "include-directories", 'I', OPT_VALUE, "includedirectories", -1 },
 222 #ifdef ENABLE_IPV6
 223     { "inet4-only", '4', OPT_BOOLEAN, "inet4only", -1 },
 224     { "inet6-only", '6', OPT_BOOLEAN, "inet6only", -1 },
 225 #endif
 226     { "input-file", 'i', OPT_VALUE, "input", -1 },
 227     { "iri", 0, OPT_BOOLEAN, "iri", -1 },
 228     { "keep-session-cookies", 0, OPT_BOOLEAN, "keepsessioncookies", -1 },
 229     { "level", 'l', OPT_VALUE, "reclevel", -1 },
 230     { "limit-rate", 0, OPT_VALUE, "limitrate", -1 },
 231     { "load-cookies", 0, OPT_VALUE, "loadcookies", -1 },
 232     { "local-encoding", 0, OPT_VALUE, "localencoding", -1 },
 233     { "max-redirect", 0, OPT_VALUE, "maxredirect", -1 },
 234     { "mirror", 'm', OPT_BOOLEAN, "mirror", -1 },
 235     { "no", 'n', OPT__NO, NULL, required_argument },
 236     { "no-clobber", 0, OPT_BOOLEAN, "noclobber", -1 },
 237     { "no-parent", 0, OPT_BOOLEAN, "noparent", -1 },
 238     { "output-document", 'O', OPT_VALUE, "outputdocument", -1 },
 239     { "output-file", 'o', OPT_VALUE, "logfile", -1 },
 240     { "page-requisites", 'p', OPT_BOOLEAN, "pagerequisites", -1 },
 241     { "parent", 0, OPT__PARENT, NULL, optional_argument },
 242     { "passive-ftp", 0, OPT_BOOLEAN, "passiveftp", -1 },
 243     { "password", 0, OPT_VALUE, "password", -1 },
 244     { "post-data", 0, OPT_VALUE, "postdata", -1 },
 245     { "post-file", 0, OPT_VALUE, "postfile", -1 },
 246     { "prefer-family", 0, OPT_VALUE, "preferfamily", -1 },
 247     { "preserve-permissions", 0, OPT_BOOLEAN, "preservepermissions", -1 },
 248     { IF_SSL ("private-key"), 0, OPT_VALUE, "privatekey", -1 },
 249     { IF_SSL ("private-key-type"), 0, OPT_VALUE, "privatekeytype", -1 },
 250     { "progress", 0, OPT_VALUE, "progress", -1 },
 251     { "protocol-directories", 0, OPT_BOOLEAN, "protocoldirectories", -1 },
 252     { "proxy", 0, OPT_BOOLEAN, "useproxy", -1 },
 253     { "proxy__compat", 'Y', OPT_VALUE, "useproxy", -1 }, /* back-compatible */
 254     { "proxy-passwd", 0, OPT_VALUE, "proxypassword", -1 }, /* deprecated */
 255     { "proxy-password", 0, OPT_VALUE, "proxypassword", -1 },
 256     { "proxy-user", 0, OPT_VALUE, "proxyuser", -1 },
 257     { "quiet", 'q', OPT_BOOLEAN, "quiet", -1 },
 258     { "quota", 'Q', OPT_VALUE, "quota", -1 },
 259     { "random-file", 0, OPT_VALUE, "randomfile", -1 },
 260     { "random-wait", 0, OPT_BOOLEAN, "randomwait", -1 },
 261     { "read-timeout", 0, OPT_VALUE, "readtimeout", -1 },
 262     { "recursive", 'r', OPT_BOOLEAN, "recursive", -1 },
 263     { "referer", 0, OPT_VALUE, "referer", -1 },
 264     { "reject", 'R', OPT_VALUE, "reject", -1 },
 265     { "relative", 'L', OPT_BOOLEAN, "relativeonly", -1 },
 266     { "remote-encoding", 0, OPT_VALUE, "remoteencoding", -1 },
 267     { "remove-listing", 0, OPT_BOOLEAN, "removelisting", -1 },
 268     { "restrict-file-names", 0, OPT_BOOLEAN, "restrictfilenames", -1 },
 269     { "retr-symlinks", 0, OPT_BOOLEAN, "retrsymlinks", -1 },
 270     { "retry-connrefused", 0, OPT_BOOLEAN, "retryconnrefused", -1 },
 271     { "save-cookies", 0, OPT_VALUE, "savecookies", -1 },
 272     { "save-headers", 0, OPT_BOOLEAN, "saveheaders", -1 },
 273     { IF_SSL ("secure-protocol"), 0, OPT_VALUE, "secureprotocol", -1 },
 274     { "server-response", 'S', OPT_BOOLEAN, "serverresponse", -1 },
 275     { "span-hosts", 'H', OPT_BOOLEAN, "spanhosts", -1 },
 276     { "spider", 0, OPT_BOOLEAN, "spider", -1 },
 277     { "strict-comments", 0, OPT_BOOLEAN, "strictcomments", -1 },
 278     { "timeout", 'T', OPT_VALUE, "timeout", -1 },
 279     { "timestamping", 'N', OPT_BOOLEAN, "timestamping", -1 },
 280     { "tries", 't', OPT_VALUE, "tries", -1 },
 281     { "unlink", 0, OPT_BOOLEAN, "unlink", -1 },
 282     { "trust-server-names", 0, OPT_BOOLEAN, "trustservernames", -1 },
 283     { "use-server-timestamps", 0, OPT_BOOLEAN, "useservertimestamps", -1 },
 284     { "user", 0, OPT_VALUE, "user", -1 },
 285     { "user-agent", 'U', OPT_VALUE, "useragent", -1 },
 286     { "verbose", 'v', OPT_BOOLEAN, "verbose", -1 },
 287     { "verbose", 0, OPT_BOOLEAN, "verbose", -1 },
 288     { "version", 'V', OPT_FUNCALL, (void *) print_version, no_argument },
 289     { "wait", 'w', OPT_VALUE, "wait", -1 },
 290     { "waitretry", 0, OPT_VALUE, "waitretry", -1 },
 291     { "warc-cdx", 0, OPT_BOOLEAN, "warccdx", -1 },
 292 #ifdef HAVE_LIBZ
 293     { "warc-compression", 0, OPT_BOOLEAN, "warccompression", -1 },
 294 #endif
 295     { "warc-dedup", 0, OPT_VALUE, "warccdxdedup", -1 },
 296     { "warc-digests", 0, OPT_BOOLEAN, "warcdigests", -1 },
 297     { "warc-file", 0, OPT_VALUE, "warcfile", -1 },
 298     { "warc-header", 0, OPT_VALUE, "warcheader", -1 },
 299     { "warc-keep-log", 0, OPT_BOOLEAN, "warckeeplog", -1 },
 300     { "warc-max-size", 0, OPT_VALUE, "warcmaxsize", -1 },
 301     { "warc-tempdir", 0, OPT_VALUE, "warctempdir", -1 },
 302 #ifdef USE_WATT32
 303     { "wdebug", 0, OPT_BOOLEAN, "wdebug", -1 },
 304 #endif
 305   };
 306
 307 #undef WHEN_DEBUG
 308 #undef IF_SSL
 309
 310 /* Return a string that contains S with "no-" prepended.  The string
 311    is NUL-terminated and allocated off static storage at Wget
 312    startup.  */
 313
 314 static char *
 315 no_prefix (const char *s)
 316 {
 317   static char buffer[1024];
 318   static char *p = buffer;
 319
 320   char *cp = p;
 321   int size = 3 + strlen (s) + 1;  /* "no-STRING\0" */
 322   if (p + size >= buffer + sizeof (buffer))
 323     abort ();
 324
 325   cp[0] = 'n', cp[1] = 'o', cp[2] = '-';
 326   strcpy (cp + 3, s);
 327   p += size;
 328   return cp;
 329 }
 330
 331 /* The arguments that that main passes to getopt_long. */
 332 static struct option long_options[2 * countof (option_data) + 1];
 333 static char short_options[128];
 334
 335 /* Mapping between short option chars and option_data indices. */
 336 static unsigned char optmap[96];
 337
 338 /* Marker for `--no-FOO' values in long_options.  */
 339 #define BOOLEAN_NEG_MARKER 1024
 340
 341 /* Initialize the long_options array used by getopt_long from the data
 342    in option_data.  */
 343
 344 static void
 345 init_switches (void)
 346 {
 347   char *p = short_options;
 348   size_t i, o = 0;
 349   for (i = 0; i < countof (option_data); i++)
 350     {
 351       struct cmdline_option *opt = &option_data[i];
 352       struct option *longopt;
 353
 354       if (!opt->long_name)
 355         /* The option is disabled. */
 356         continue;
 357
 358       longopt = &long_options[o++];
 359       longopt->name = opt->long_name;
 360       longopt->val = i;
 361       if (opt->short_name)
 362         {
 363           *p++ = opt->short_name;
 364           optmap[opt->short_name - 32] = longopt - long_options;
 365         }
 366       switch (opt->type)
 367         {
 368         case OPT_VALUE:
 369           longopt->has_arg = required_argument;
 370           if (opt->short_name)
 371             *p++ = ':';
 372           break;
 373         case OPT_BOOLEAN:
 374           /* Specify an optional argument for long options, so that
 375              --option=off works the same as --no-option, for
 376              compatibility with pre-1.10 Wget.  However, don't specify
 377              optional arguments short-option booleans because they
 378              prevent combining of short options.  */
 379           longopt->has_arg = optional_argument;
 380           /* For Boolean options, add the "--no-FOO" variant, which is
 381              identical to "--foo", except it has opposite meaning and
 382              it doesn't allow an argument.  */
 383           longopt = &long_options[o++];
 384           longopt->name = no_prefix (opt->long_name);
 385           longopt->has_arg = no_argument;
 386           /* Mask the value so we'll be able to recognize that we're
 387              dealing with the false value.  */
 388           longopt->val = i | BOOLEAN_NEG_MARKER;
 389           break;
 390         default:
 391           assert (opt->argtype != -1);
 392           longopt->has_arg = opt->argtype;
 393           if (opt->short_name)
 394             {
 395               if (longopt->has_arg == required_argument)
 396                 *p++ = ':';
 397               /* Don't handle optional_argument */
 398             }
 399         }
 400     }
 401   /* Terminate short_options. */
 402   *p = '\0';
 403   /* No need for xzero(long_options[o]) because its storage is static
 404      and it will be zeroed by default.  */
 405   assert (o <= countof (long_options));
 406 }
 407
 408 /* Print the usage message.  */
 409 static int
 410 print_usage (int error)
 411 {
 412   return fprintf (error ? stderr : stdout,
 413                   _("Usage: %s [OPTION]... [URL]...\n"), exec_name);
 414 }
 415
 416 /* Print the help message, describing all the available options.  If
 417    you add an option, be sure to update this list.  */
 418 static void
 419 print_help (void)
 420 {
 421   /* We split the help text this way to ease translation of individual
 422      entries.  */
 423   static const char *help[] = {
 424     "\n",
 425     N_("\
 426 Mandatory arguments to long options are mandatory for short options too.\n\n"),
 427     N_("\
 428 Startup:\n"),
 429     N_("\
 430   -V,  --version           display the version of Wget and exit.\n"),
 431     N_("\
 432   -h,  --help              print this help.\n"),
 433     N_("\
 434   -b,  --background        go to background after startup.\n"),
 435     N_("\
 436   -e,  --execute=COMMAND   execute a `.wgetrc'-style command.\n"),
 437     "\n",
 438
 439     N_("\
 440 Logging and input file:\n"),
 441     N_("\
 442   -o,  --output-file=FILE    log messages to FILE.\n"),
 443     N_("\
 444   -a,  --append-output=FILE  append messages to FILE.\n"),
 445 #ifdef ENABLE_DEBUG
 446     N_("\
 447   -d,  --debug               print lots of debugging information.\n"),
 448 #endif
 449 #ifdef USE_WATT32
 450     N_("\
 451        --wdebug              print Watt-32 debug output.\n"),
 452 #endif
 453     N_("\
 454   -q,  --quiet               quiet (no output).\n"),
 455     N_("\
 456   -v,  --verbose             be verbose (this is the default).\n"),
 457     N_("\
 458   -nv, --no-verbose          turn off verboseness, without being quiet.\n"),
 459     N_("\
 460   -i,  --input-file=FILE     download URLs found in local or external FILE.\n"),
 461     N_("\
 462   -F,  --force-html          treat input file as HTML.\n"),
 463     N_("\
 464   -B,  --base=URL            resolves HTML input-file links (-i -F)\n\
 465                              relative to URL.\n"),
 466     N_("\
 467        --config=FILE         Specify config file to use.\n"),
 468     "\n",
 469
 470     N_("\
 471 Download:\n"),
 472     N_("\
 473   -t,  --tries=NUMBER            set number of retries to NUMBER (0 unlimits).\n"),
 474     N_("\
 475        --retry-connrefused       retry even if connection is refused.\n"),
 476     N_("\
 477   -O,  --output-document=FILE    write documents to FILE.\n"),
 478     N_("\
 479   -nc, --no-clobber              skip downloads that would download to\n\
 480                                  existing files (overwriting them).\n"),
 481     N_("\
 482   -c,  --continue                resume getting a partially-downloaded file.\n"),
 483     N_("\
 484        --progress=TYPE           select progress gauge type.\n"),
 485     N_("\
 486   -N,  --timestamping            don't re-retrieve files unless newer than\n\
 487                                  local.\n"),
 488     N_("\
 489   --no-use-server-timestamps     don't set the local file's timestamp by\n\
 490                                  the one on the server.\n"),
 491     N_("\
 492   -S,  --server-response         print server response.\n"),
 493     N_("\
 494        --spider                  don't download anything.\n"),
 495     N_("\
 496   -T,  --timeout=SECONDS         set all timeout values to SECONDS.\n"),
 497     N_("\
 498        --dns-timeout=SECS        set the DNS lookup timeout to SECS.\n"),
 499     N_("\
 500        --connect-timeout=SECS    set the connect timeout to SECS.\n"),
 501     N_("\
 502        --read-timeout=SECS       set the read timeout to SECS.\n"),
 503     N_("\
 504   -w,  --wait=SECONDS            wait SECONDS between retrievals.\n"),
 505     N_("\
 506        --waitretry=SECONDS       wait 1..SECONDS between retries of a retrieval.\n"),
 507     N_("\
 508        --random-wait             wait from 0.5*WAIT...1.5*WAIT secs between retrievals.\n"),
 509     N_("\
 510        --no-proxy                explicitly turn off proxy.\n"),
 511     N_("\
 512   -Q,  --quota=NUMBER            set retrieval quota to NUMBER.\n"),
 513     N_("\
 514        --bind-address=ADDRESS    bind to ADDRESS (hostname or IP) on local host.\n"),
 515     N_("\
 516        --limit-rate=RATE         limit download rate to RATE.\n"),
 517     N_("\
 518        --no-dns-cache            disable caching DNS lookups.\n"),
 519     N_("\
 520        --restrict-file-names=OS  restrict chars in file names to ones OS allows.\n"),
 521     N_("\
 522        --ignore-case             ignore case when matching files/directories.\n"),
 523 #ifdef ENABLE_IPV6
 524     N_("\
 525   -4,  --inet4-only              connect only to IPv4 addresses.\n"),
 526     N_("\
 527   -6,  --inet6-only              connect only to IPv6 addresses.\n"),
 528     N_("\
 529        --prefer-family=FAMILY    connect first to addresses of specified family,\n\
 530                                  one of IPv6, IPv4, or none.\n"),
 531 #endif
 532     N_("\
 533        --user=USER               set both ftp and http user to USER.\n"),
 534     N_("\
 535        --password=PASS           set both ftp and http password to PASS.\n"),
 536     N_("\
 537        --ask-password            prompt for passwords.\n"),
 538     N_("\
 539        --no-iri                  turn off IRI support.\n"),
 540     N_("\
 541        --local-encoding=ENC      use ENC as the local encoding for IRIs.\n"),
 542     N_("\
 543        --remote-encoding=ENC     use ENC as the default remote encoding.\n"),
 544     N_("\
 545        --unlink                  remove file before clobber.\n"),
 546     "\n",
 547
 548     N_("\
 549 Directories:\n"),
 550     N_("\
 551   -nd, --no-directories           don't create directories.\n"),
 552     N_("\
 553   -x,  --force-directories        force creation of directories.\n"),
 554     N_("\
 555   -nH, --no-host-directories      don't create host directories.\n"),
 556     N_("\
 557        --protocol-directories     use protocol name in directories.\n"),
 558     N_("\
 559   -P,  --directory-prefix=PREFIX  save files to PREFIX/...\n"),
 560     N_("\
 561        --cut-dirs=NUMBER          ignore NUMBER remote directory components.\n"),
 562     "\n",
 563
 564     N_("\
 565 HTTP options:\n"),
 566     N_("\
 567        --http-user=USER        set http user to USER.\n"),
 568     N_("\
 569        --http-password=PASS    set http password to PASS.\n"),
 570     N_("\
 571        --no-cache              disallow server-cached data.\n"),
 572     N_ ("\
 573        --default-page=NAME     Change the default page name (normally\n\
 574                                this is `index.html'.).\n"),
 575     N_("\
 576   -E,  --adjust-extension      save HTML/CSS documents with proper extensions.\n"),
 577     N_("\
 578        --ignore-length         ignore `Content-Length' header field.\n"),
 579     N_("\
 580        --header=STRING         insert STRING among the headers.\n"),
 581     N_("\
 582        --max-redirect          maximum redirections allowed per page.\n"),
 583     N_("\
 584        --proxy-user=USER       set USER as proxy username.\n"),
 585     N_("\
 586        --proxy-password=PASS   set PASS as proxy password.\n"),
 587     N_("\
 588        --referer=URL           include `Referer: URL' header in HTTP request.\n"),
 589     N_("\
 590        --save-headers          save the HTTP headers to file.\n"),
 591     N_("\
 592   -U,  --user-agent=AGENT      identify as AGENT instead of Wget/VERSION.\n"),
 593     N_("\
 594        --no-http-keep-alive    disable HTTP keep-alive (persistent connections).\n"),
 595     N_("\
 596        --no-cookies            don't use cookies.\n"),
 597     N_("\
 598        --load-cookies=FILE     load cookies from FILE before session.\n"),
 599     N_("\
 600        --save-cookies=FILE     save cookies to FILE after session.\n"),
 601     N_("\
 602        --keep-session-cookies  load and save session (non-permanent) cookies.\n"),
 603     N_("\
 604        --post-data=STRING      use the POST method; send STRING as the data.\n"),
 605     N_("\
 606        --post-file=FILE        use the POST method; send contents of FILE.\n"),
 607     N_("\
 608        --content-disposition   honor the Content-Disposition header when\n\
 609                                choosing local file names (EXPERIMENTAL).\n"),
 610     N_("\
 611        --content-on-error      output the received content on server errors.\n"),
 612     N_("\
 613        --auth-no-challenge     send Basic HTTP authentication information\n\
 614                                without first waiting for the server's\n\
 615                                challenge.\n"),
 616     "\n",
 617
 618 #ifdef HAVE_SSL
 619     N_("\
 620 HTTPS (SSL/TLS) options:\n"),
 621     N_("\
 622        --secure-protocol=PR     choose secure protocol, one of auto, SSLv2,\n\
 623                                 SSLv3, and TLSv1.\n"),
 624     N_("\
 625        --no-check-certificate   don't validate the server's certificate.\n"),
 626     N_("\
 627        --certificate=FILE       client certificate file.\n"),
 628     N_("\
 629        --certificate-type=TYPE  client certificate type, PEM or DER.\n"),
 630     N_("\
 631        --private-key=FILE       private key file.\n"),
 632     N_("\
 633        --private-key-type=TYPE  private key type, PEM or DER.\n"),
 634     N_("\
 635        --ca-certificate=FILE    file with the bundle of CA's.\n"),
 636     N_("\
 637        --ca-directory=DIR       directory where hash list of CA's is stored.\n"),
 638     N_("\
 639        --random-file=FILE       file with random data for seeding the SSL PRNG.\n"),
 640     N_("\
 641        --egd-file=FILE          file naming the EGD socket with random data.\n"),
 642     "\n",
 643 #endif /* HAVE_SSL */
 644
 645     N_("\
 646 FTP options:\n"),
 647 #ifdef __VMS
 648     N_("\
 649        --ftp-stmlf             Use Stream_LF format for all binary FTP files.\n"),
 650 #endif /* def __VMS */
 651     N_("\
 652        --ftp-user=USER         set ftp user to USER.\n"),
 653     N_("\
 654        --ftp-password=PASS     set ftp password to PASS.\n"),
 655     N_("\
 656        --no-remove-listing     don't remove `.listing' files.\n"),
 657     N_("\
 658        --no-glob               turn off FTP file name globbing.\n"),
 659     N_("\
 660        --no-passive-ftp        disable the \"passive\" transfer mode.\n"),
 661     N_("\
 662        --preserve-permissions  preserve remote file permissions.\n"),
 663     N_("\
 664        --retr-symlinks         when recursing, get linked-to files (not dir).\n"),
 665     "\n",
 666
 667     N_("\
 668 WARC options:\n"),
 669     N_("\
 670        --warc-file=FILENAME      save request/response data to a .warc.gz file.\n"),
 671     N_("\
 672        --warc-header=STRING      insert STRING into the warcinfo record.\n"),
 673     N_("\
 674        --warc-max-size=NUMBER    set maximum size of WARC files to NUMBER.\n"),
 675     N_("\
 676        --warc-cdx                write CDX index files.\n"),
 677     N_("\
 678        --warc-dedup=FILENAME     do not store records listed in this CDX file.\n"),
 679 #ifdef HAVE_LIBZ
 680     N_("\
 681        --no-warc-compression     do not compress WARC files with GZIP.\n"),
 682 #endif
 683     N_("\
 684        --no-warc-digests         do not calculate SHA1 digests.\n"),
 685     N_("\
 686        --no-warc-keep-log        do not store the log file in a WARC record.\n"),
 687     N_("\
 688        --warc-tempdir=DIRECTORY  location for temporary files created by the\n\
 689                                  WARC writer.\n"),
 690     "\n",
 691
 692     N_("\
 693 Recursive download:\n"),
 694     N_("\
 695   -r,  --recursive          specify recursive download.\n"),
 696     N_("\
 697   -l,  --level=NUMBER       maximum recursion depth (inf or 0 for infinite).\n"),
 698     N_("\
 699        --delete-after       delete files locally after downloading them.\n"),
 700     N_("\
 701   -k,  --convert-links      make links in downloaded HTML or CSS point to\n\
 702                             local files.\n"),
 703 #ifdef __VMS
 704     N_("\
 705   -K,  --backup-converted   before converting file X, back up as X_orig.\n"),
 706 #else /* def __VMS */
 707     N_("\
 708   -K,  --backup-converted   before converting file X, back up as X.orig.\n"),
 709 #endif /* def __VMS [else] */
 710     N_("\
 711   -m,  --mirror             shortcut for -N -r -l inf --no-remove-listing.\n"),
 712     N_("\
 713   -p,  --page-requisites    get all images, etc. needed to display HTML page.\n"),
 714     N_("\
 715        --strict-comments    turn on strict (SGML) handling of HTML comments.\n"),
 716     "\n",
 717
 718     N_("\
 719 Recursive accept/reject:\n"),
 720     N_("\
 721   -A,  --accept=LIST               comma-separated list of accepted extensions.\n"),
 722     N_("\
 723   -R,  --reject=LIST               comma-separated list of rejected extensions.\n"),
 724     N_("\
 725   -D,  --domains=LIST              comma-separated list of accepted domains.\n"),
 726     N_("\
 727        --exclude-domains=LIST      comma-separated list of rejected domains.\n"),
 728     N_("\
 729        --follow-ftp                follow FTP links from HTML documents.\n"),
 730     N_("\
 731        --follow-tags=LIST          comma-separated list of followed HTML tags.\n"),
 732     N_("\
 733        --ignore-tags=LIST          comma-separated list of ignored HTML tags.\n"),
 734     N_("\
 735   -H,  --span-hosts                go to foreign hosts when recursive.\n"),
 736     N_("\
 737   -L,  --relative                  follow relative links only.\n"),
 738     N_("\
 739   -I,  --include-directories=LIST  list of allowed directories.\n"),
 740     N_("\
 741   --trust-server-names             use the name specified by the redirection\n\
 742                                    url last component.\n"),
 743     N_("\
 744   -X,  --exclude-directories=LIST  list of excluded directories.\n"),
 745     N_("\
 746   -np, --no-parent                 don't ascend to the parent directory.\n"),
 747     "\n",
 748
 749     N_("Mail bug reports and suggestions to <bug-wget@gnu.org>.\n")
 750   };
 751
 752   size_t i;
 753
 754   if (printf (_("GNU Wget %s, a non-interactive network retriever.\n"),
 755               version_string) < 0)
 756     exit (3);
 757   if (print_usage (0) < 0)
 758     exit (3);
 759
 760   for (i = 0; i < countof (help); i++)
 761     if (fputs (_(help[i]), stdout) < 0)
 762       exit (3);
 763
 764   exit (0);
 765 }
 766
 767 /* Return a human-readable printed representation of INTERVAL,
 768    measured in seconds.  */
 769
 770 static char *
 771 secs_to_human_time (double interval)
 772 {
 773   static char buf[32];
 774   int secs = (int) (interval + 0.5);
 775   int hours, mins, days;
 776
 777   days = secs / 86400, secs %= 86400;
 778   hours = secs / 3600, secs %= 3600;
 779   mins = secs / 60, secs %= 60;
 780
 781   if (days)
 782     sprintf (buf, "%dd %dh %dm %ds", days, hours, mins, secs);
 783   else if (hours)
 784     sprintf (buf, "%dh %dm %ds", hours, mins, secs);
 785   else if (mins)
 786     sprintf (buf, "%dm %ds", mins, secs);
 787   else
 788     sprintf (buf, "%ss", print_decimal (interval));
 789
 790   return buf;
 791 }
 792
 793 static char *
 794 prompt_for_password (void)
 795 {
 796   if (opt.user)
 797     fprintf (stderr, _("Password for user %s: "), quote (opt.user));
 798   else
 799     fprintf (stderr, _("Password: "));
 800   return getpass("");
 801 }
 802
 803 /* Function that prints the line argument while limiting it
 804    to at most line_length. prefix is printed on the first line
 805    and an appropriate number of spaces are added on subsequent
 806    lines.*/
 807 static int
 808 format_and_print_line (const char *prefix, const char *line,
 809                        int line_length)
 810 {
 811   int remaining_chars;
 812   char *line_dup, *token;
 813
 814   assert (prefix != NULL);
 815   assert (line != NULL);
 816
 817   line_dup = xstrdup (line);
 818
 819   if (line_length <= 0)
 820     line_length = MAX_CHARS_PER_LINE - TABULATION;
 821
 822   if (printf ("%s", prefix) < 0)
 823     return -1;
 824   remaining_chars = line_length;
 825   /* We break on spaces. */
 826   token = strtok (line_dup, " ");
 827   while (token != NULL)
 828     {
 829       /* If however a token is much larger than the maximum
 830          line length, all bets are off and we simply print the
 831          token on the next line. */
 832       if (remaining_chars <= strlen (token))
 833         {
 834           if (printf ("\n%*c", TABULATION, ' ') < 0)
 835             return -1;
 836           remaining_chars = line_length - TABULATION;
 837         }
 838       if (printf ("%s ", token) < 0)
 839         return -1;
 840       remaining_chars -= strlen (token) + 1;  /* account for " " */
 841       token = strtok (NULL, " ");
 842     }
 843
 844   if (printf ("\n") < 0)
 845     return -1;
 846
 847   xfree (line_dup);
 848   return 0;
 849 }
 850
 851 static void
 852 print_version (void)
 853 {
 854   const char *wgetrc_title  = _("Wgetrc: ");
 855   const char *locale_title  = _("Locale: ");
 856   const char *compile_title = _("Compile: ");
 857   const char *link_title    = _("Link: ");
 858   char *env_wgetrc, *user_wgetrc;
 859   int i;
 860
 861   if (printf (_("GNU Wget %s built on %s.\n\n"), version_string, OS_TYPE) < 0)
 862     exit (3);
 863
 864   for (i = 0; compiled_features[i] != NULL; )
 865     {
 866       int line_length = MAX_CHARS_PER_LINE;
 867       while ((line_length > 0) && (compiled_features[i] != NULL))
 868         {
 869           if (printf ("%s ", compiled_features[i]) < 0)
 870             exit (3);
 871           line_length -= strlen (compiled_features[i]) + 2;
 872           i++;
 873         }
 874       if (printf ("\n") < 0)
 875         exit (3);
 876     }
 877   if (printf ("\n") < 0)
 878     exit (3);
 879
 880   /* Handle the case when $WGETRC is unset and $HOME/.wgetrc is
 881      absent. */
 882   if (printf ("%s\n", wgetrc_title) < 0)
 883     exit (3);
 884
 885   env_wgetrc = wgetrc_env_file_name ();
 886   if (env_wgetrc && *env_wgetrc)
 887     {
 888       if (printf (_("    %s (env)\n"), env_wgetrc) < 0)
 889         exit (3);
 890       xfree (env_wgetrc);
 891     }
 892   user_wgetrc = wgetrc_user_file_name ();
 893   if (user_wgetrc)
 894     {
 895       if (printf (_("    %s (user)\n"), user_wgetrc) < 0)
 896         exit (3);
 897       xfree (user_wgetrc);
 898     }
 899 #ifdef SYSTEM_WGETRC
 900   if (printf (_("    %s (system)\n"), SYSTEM_WGETRC) < 0)
 901     exit (3);
 902 #endif
 903
 904 #ifdef ENABLE_NLS
 905   if (format_and_print_line (locale_title,
 906                         LOCALEDIR,
 907                              MAX_CHARS_PER_LINE) < 0)
 908     exit (3);
 909 #endif /* def ENABLE_NLS */
 910
 911   if (compilation_string != NULL)
 912     if (format_and_print_line (compile_title,
 913                                compilation_string,
 914                                MAX_CHARS_PER_LINE) < 0)
 915       exit (3);
 916
 917   if (link_string != NULL)
 918     if (format_and_print_line (link_title,
 919                                link_string,
 920                                MAX_CHARS_PER_LINE) < 0)
 921       exit (3);
 922
 923   if (printf ("\n") < 0)
 924     exit (3);
 925
 926   /* TRANSLATORS: When available, an actual copyright character
 927      (circle-c) should be used in preference to "(C)". */
 928   if (fputs (_("\
 929 Copyright (C) 2011 Free Software Foundation, Inc.\n"), stdout) < 0)
 930     exit (3);
 931   if (fputs (_("\
 932 License GPLv3+: GNU GPL version 3 or later\n\
 933 <http://www.gnu.org/licenses/gpl.html>.\n\
 934 This is free software: you are free to change and redistribute it.\n\
 935 There is NO WARRANTY, to the extent permitted by law.\n"), stdout) < 0)
 936     exit (3);
 937   /* TRANSLATORS: When available, please use the proper diacritics for
 938      names such as this one. See en_US.po for reference. */
 939   if (fputs (_("\nOriginally written by Hrvoje Niksic <hniksic@xemacs.org>.\n"),
 940              stdout) < 0)
 941     exit (3);
 942   if (fputs (_("Please send bug reports and questions to <bug-wget@gnu.org>.\n"),
 943              stdout) < 0)
 944     exit (3);
 945
 946   exit (0);
 947 }
 948
 949 char *program_name; /* Needed by lib/error.c. */
 950 char *program_argstring; /* Needed by wget_warc.c. */
 951
 952 int
 953 main (int argc, char **argv)
 954 {
 955   char **url, **t;
 956   int i, ret, longindex;
 957   int nurl;
 958   bool append_to_log = false;
 959
 960   total_downloaded_bytes = 0;
 961
 962   program_name = argv[0];
 963
 964   struct ptimer *timer = ptimer_new ();
 965   double start_time = ptimer_measure (timer);
 966
 967   i18n_initialize ();
 968
 969   /* Construct the name of the executable, without the directory part.  */
 970 #ifdef __VMS
 971   /* On VMS, lose the "dev:[dir]" prefix and the ".EXE;nnn" suffix. */
 972   exec_name = vms_basename (argv[0]);
 973 #else /* def __VMS */
 974   exec_name = strrchr (argv[0], PATH_SEPARATOR);
 975   if (!exec_name)
 976     exec_name = argv[0];
 977   else
 978     ++exec_name;
 979 #endif /* def __VMS [else] */
 980
 981 #ifdef WINDOWS
 982   /* Drop extension (typically .EXE) from executable filename. */
 983   windows_main ((char **) &exec_name);
 984 #endif
 985
 986   /* Construct the arguments string. */
 987   int argstring_length = 1;
 988   for (i = 1; i < argc; i++)
 989     argstring_length += strlen (argv[i]) + 2 + 1;
 990   char *p = program_argstring = malloc (argstring_length * sizeof (char));
 991   for (i = 1; i < argc; i++)
 992   {
 993     *p++ = '"';
 994     int arglen = strlen (argv[i]);
 995     memcpy (p, argv[i], arglen);
 996     p += arglen;
 997     *p++ = '"';
 998     *p++ = ' ';
 999   }
1000   *p = '\0';
1001
1002   /* Load the hard-coded defaults.  */
1003   defaults ();
1004
1005   init_switches ();
1006
1007   /* This separate getopt_long is needed to find the user config file
1008      option ("--config") and parse it before the other user options. */
1009   longindex = -1;
1010   int retconf;
1011   bool use_userconfig = false;
1012
1013   while ((retconf = getopt_long (argc, argv,
1014                                 short_options, long_options, &longindex)) != -1)
1015     {
1016       int confval;
1017       bool userrc_ret = true;
1018       struct cmdline_option *config_opt;
1019
1020       /* There is no short option for "--config". */
1021       if (longindex >= 0)
1022         {
1023           confval = long_options[longindex].val;
1024           config_opt = &option_data[confval & ~BOOLEAN_NEG_MARKER];
1025           if (strcmp (config_opt->long_name, "config") == 0)
1026             {
1027               userrc_ret &= run_wgetrc (optarg);
1028               use_userconfig = true;
1029             }
1030           if (!userrc_ret)
1031             {
1032               printf ("Exiting due to error in %s\n", optarg);
1033               exit (2);
1034             }
1035           else
1036             break;
1037         }
1038     }
1039
1040   /* If the user did not specify a config, read the system wgetrc and ~/.wgetrc. */
1041   if (use_userconfig == false)
1042     initialize ();
1043
1044   opterr = 0;
1045   optind = 0;
1046
1047   longindex = -1;
1048   while ((ret = getopt_long (argc, argv,
1049                              short_options, long_options, &longindex)) != -1)
1050     {
1051       int val;
1052       struct cmdline_option *opt;
1053
1054       /* If LONGINDEX is unchanged, it means RET is referring a short
1055          option.  */
1056       if (longindex == -1)
1057         {
1058           if (ret == '?')
1059             {
1060               print_usage (0);
1061               printf ("\n");
1062               printf (_("Try `%s --help' for more options.\n"), exec_name);
1063               exit (2);
1064             }
1065           /* Find the short option character in the mapping.  */
1066           longindex = optmap[ret - 32];
1067         }
1068       val = long_options[longindex].val;
1069
1070       /* Use the retrieved value to locate the option in the
1071          option_data array, and to see if we're dealing with the
1072          negated "--no-FOO" variant of the boolean option "--foo".  */
1073       opt = &option_data[val & ~BOOLEAN_NEG_MARKER];
1074       switch (opt->type)
1075         {
1076         case OPT_VALUE:
1077           setoptval (opt->data, optarg, opt->long_name);
1078           break;
1079         case OPT_BOOLEAN:
1080           if (optarg)
1081             /* The user has specified a value -- use it. */
1082             setoptval (opt->data, optarg, opt->long_name);
1083           else
1084             {
1085               /* NEG is true for `--no-FOO' style boolean options. */
1086               bool neg = !!(val & BOOLEAN_NEG_MARKER);
1087               setoptval (opt->data, neg ? "0" : "1", opt->long_name);
1088             }
1089           break;
1090         case OPT_FUNCALL:
1091           {
1092             void (*func) (void) = (void (*) (void)) opt->data;
1093             func ();
1094           }
1095           break;
1096         case OPT__APPEND_OUTPUT:
1097           setoptval ("logfile", optarg, opt->long_name);
1098           append_to_log = true;
1099           break;
1100         case OPT__EXECUTE:
1101           run_command (optarg);
1102           break;
1103         case OPT__NO:
1104           {
1105             /* We support real --no-FOO flags now, but keep these
1106                short options for convenience and backward
1107                compatibility.  */
1108             char *p;
1109             for (p = optarg; p && *p; p++)
1110               switch (*p)
1111                 {
1112                 case 'v':
1113                   setoptval ("verbose", "0", opt->long_name);
1114                   break;
1115                 case 'H':
1116                   setoptval ("addhostdir", "0", opt->long_name);
1117                   break;
1118                 case 'd':
1119                   setoptval ("dirstruct", "0", opt->long_name);
1120                   break;
1121                 case 'c':
1122                   setoptval ("noclobber", "1", opt->long_name);
1123                   break;
1124                 case 'p':
1125                   setoptval ("noparent", "1", opt->long_name);
1126                   break;
1127                 default:
1128                   fprintf (stderr, _("%s: illegal option -- `-n%c'\n"),
1129                            exec_name, *p);
1130                   print_usage (1);
1131                   fprintf (stderr, "\n");
1132                   fprintf (stderr, _("Try `%s --help' for more options.\n"),
1133                            exec_name);
1134                   exit (1);
1135                 }
1136             break;
1137           }
1138         case OPT__PARENT:
1139         case OPT__CLOBBER:
1140           {
1141             /* The wgetrc commands are named noparent and noclobber,
1142                so we must revert the meaning of the cmdline options
1143                before passing the value to setoptval.  */
1144             bool flag = true;
1145             if (optarg)
1146               flag = (*optarg == '1' || c_tolower (*optarg) == 'y'
1147                       || (c_tolower (optarg[0]) == 'o'
1148                           && c_tolower (optarg[1]) == 'n'));
1149             setoptval (opt->type == OPT__PARENT ? "noparent" : "noclobber",
1150                        flag ? "0" : "1", opt->long_name);
1151             break;
1152           }
1153         case OPT__DONT_REMOVE_LISTING:
1154           setoptval ("removelisting", "0", opt->long_name);
1155           break;
1156         }
1157
1158       longindex = -1;
1159     }
1160
1161   nurl = argc - optind;
1162
1163   /* All user options have now been processed, so it's now safe to do
1164      interoption dependency checks. */
1165
1166   if (opt.noclobber && opt.convert_links)
1167     {
1168       fprintf (stderr,
1169                _("Both --no-clobber and --convert-links were specified,"
1170                  "only --convert-links will be used.\n"));
1171       opt.noclobber = false;
1172     }
1173
1174   if (opt.reclevel == 0)
1175       opt.reclevel = INFINITE_RECURSION; /* see recur.h for commentary */
1176
1177   if (opt.spider || opt.delete_after)
1178       opt.no_dirstruct = true;
1179
1180   if (opt.page_requisites && !opt.recursive)
1181     {
1182       /* Don't set opt.recursive here because it would confuse the FTP
1183          code.  Instead, call retrieve_tree below when either
1184          page_requisites or recursive is requested.  */
1185       opt.reclevel = 0;
1186       if (!opt.no_dirstruct)
1187         opt.dirstruct = 1;      /* normally handled by cmd_spec_recursive() */
1188     }
1189
1190   if (opt.verbose == -1)
1191     opt.verbose = !opt.quiet;
1192
1193   /* Sanity checks.  */
1194   if (opt.verbose && opt.quiet)
1195     {
1196       fprintf (stderr, _("Can't be verbose and quiet at the same time.\n"));
1197       print_usage (1);
1198       exit (1);
1199     }
1200   if (opt.timestamping && opt.noclobber)
1201     {
1202       fprintf (stderr, _("\
1203 Can't timestamp and not clobber old files at the same time.\n"));
1204       print_usage (1);
1205       exit (1);
1206     }
1207 #ifdef ENABLE_IPV6
1208   if (opt.ipv4_only && opt.ipv6_only)
1209     {
1210       fprintf (stderr,
1211                _("Cannot specify both --inet4-only and --inet6-only.\n"));
1212       print_usage (1);
1213       exit (1);
1214     }
1215 #endif
1216   if (opt.output_document)
1217     {
1218       if (opt.convert_links
1219           && (nurl > 1 || opt.page_requisites || opt.recursive))
1220         {
1221           fputs (_("\
1222 Cannot specify both -k and -O if multiple URLs are given, or in combination\n\
1223 with -p or -r. See the manual for details.\n\n"), stderr);
1224           print_usage (1);
1225           exit (1);
1226         }
1227       if (opt.page_requisites
1228           || opt.recursive)
1229         {
1230           logprintf (LOG_NOTQUIET, "%s", _("\
1231 WARNING: combining -O with -r or -p will mean that all downloaded content\n\
1232 will be placed in the single file you specified.\n\n"));
1233         }
1234       if (opt.timestamping)
1235         {
1236           logprintf (LOG_NOTQUIET, "%s", _("\
1237 WARNING: timestamping does nothing in combination with -O. See the manual\n\
1238 for details.\n\n"));
1239           opt.timestamping = false;
1240         }
1241       if (opt.noclobber && file_exists_p(opt.output_document))
1242            {
1243               /* Check if output file exists; if it does, exit. */
1244               logprintf (LOG_VERBOSE,
1245                          _("File `%s' already there; not retrieving.\n"),
1246                          opt.output_document);
1247               exit(1);
1248            }
1249     }
1250
1251   if (opt.warc_filename != 0)
1252     {
1253       if (opt.noclobber)
1254         {
1255           fprintf (stderr,
1256                    _("WARC output does not work with --no-clobber, "
1257                      "--no-clobber will be disabled.\n"));
1258           opt.noclobber = false;
1259         }
1260       if (opt.timestamping)
1261         {
1262           fprintf (stderr,
1263                    _("WARC output does not work with timestamping, "
1264                      "timestamping will be disabled.\n"));
1265           opt.timestamping = false;
1266         }
1267       if (opt.spider)
1268         {
1269           fprintf (stderr,
1270                    _("WARC output does not work with --spider.\n"));
1271           exit (1);
1272         }
1273       if (opt.always_rest)
1274         {
1275           fprintf (stderr,
1276                    _("WARC output does not work with --continue, "
1277                      "--continue will be disabled.\n"));
1278           opt.always_rest = false;
1279         }
1280       if (opt.warc_cdx_dedup_filename != 0 && !opt.warc_digests_enabled)
1281         {
1282           fprintf (stderr,
1283                    _("Digests are disabled; WARC deduplication will "
1284                      "not find duplicate records.\n"));
1285         }
1286       if (opt.warc_keep_log)
1287         {
1288           opt.progress_type = "dot";
1289         }
1290     }
1291
1292   if (opt.ask_passwd && opt.passwd)
1293     {
1294       fprintf (stderr,
1295                _("Cannot specify both --ask-password and --password.\n"));
1296       print_usage (1);
1297       exit (1);
1298     }
1299
1300   if (!nurl && !opt.input_filename)
1301     {
1302       /* No URL specified.  */
1303       fprintf (stderr, _("%s: missing URL\n"), exec_name);
1304       print_usage (1);
1305       printf ("\n");
1306       /* #### Something nicer should be printed here -- similar to the
1307          pre-1.5 `--help' page.  */
1308       fprintf (stderr, _("Try `%s --help' for more options.\n"), exec_name);
1309       exit (1);
1310     }
1311
1312 #ifdef ENABLE_IRI
1313   if (opt.enable_iri)
1314     {
1315       if (opt.locale && !check_encoding_name (opt.locale))
1316         opt.locale = NULL;
1317
1318       if (!opt.locale)
1319         opt.locale = find_locale ();
1320
1321       if (opt.encoding_remote && !check_encoding_name (opt.encoding_remote))
1322         opt.encoding_remote = NULL;
1323     }
1324 #else
1325   memset (&dummy_iri, 0, sizeof (dummy_iri));
1326   if (opt.enable_iri || opt.locale || opt.encoding_remote)
1327     {
1328       /* sXXXav : be more specific... */
1329       fprintf (stderr, _("This version does not have support for IRIs\n"));
1330       exit(1);
1331     }
1332 #endif
1333
1334   if (opt.ask_passwd)
1335     {
1336       opt.passwd = prompt_for_password ();
1337
1338       if (opt.passwd == NULL || opt.passwd[0] == '\0')
1339         exit (1);
1340     }
1341
1342 #ifdef USE_WATT32
1343   if (opt.wdebug)
1344      dbug_init();
1345   sock_init();
1346 #else
1347   if (opt.background)
1348     fork_to_background ();
1349 #endif
1350
1351   /* Initialize progress.  Have to do this after the options are
1352      processed so we know where the log file is.  */
1353   if (opt.verbose)
1354     set_progress_implementation (opt.progress_type);
1355
1356   /* Fill in the arguments.  */
1357   url = alloca_array (char *, nurl + 1);
1358   for (i = 0; i < nurl; i++, optind++)
1359     {
1360       char *rewritten = rewrite_shorthand_url (argv[optind]);
1361       if (rewritten)
1362         url[i] = rewritten;
1363       else
1364         url[i] = xstrdup (argv[optind]);
1365     }
1366   url[i] = NULL;
1367
1368   /* Initialize logging.  */
1369   log_init (opt.lfilename, append_to_log);
1370
1371   /* Open WARC file. */
1372   if (opt.warc_filename != 0)
1373     warc_init ();
1374
1375   DEBUGP (("DEBUG output created by Wget %s on %s.\n\n",
1376            version_string, OS_TYPE));
1377
1378   /* Open the output filename if necessary.  */
1379
1380 /* 2005-04-17 SMS.
1381    Note that having the output_stream ("-O") file opened here for an FTP
1382    URL rather than in getftp() (ftp.c) (and the http equivalent) rather
1383    limits the ability in VMS to open the file differently for ASCII
1384    versus binary FTP there.  (Of course, doing it here allows a open
1385    failure to be detected immediately, without first connecting to the
1386    server.)
1387 */
1388   if (opt.output_document)
1389     {
1390       if (HYPHENP (opt.output_document))
1391         {
1392 #ifdef WINDOWS
1393           _setmode (_fileno (stdout), _O_BINARY);
1394 #endif
1395           output_stream = stdout;
1396         }
1397       else
1398         {
1399           struct_fstat st;
1400
1401 #ifdef __VMS
1402 /* Common fopen() optional arguments:
1403    sequential access only, access callback function.
1404 */
1405 # define FOPEN_OPT_ARGS , "fop=sqo", "acc", acc_cb, &open_id
1406           int open_id = 7;
1407 #else /* def __VMS */
1408 # define FOPEN_OPT_ARGS
1409 #endif /* def __VMS [else] */
1410
1411           output_stream = fopen (opt.output_document,
1412                                  opt.always_rest ? "ab" : "wb"
1413                                  FOPEN_OPT_ARGS);
1414           if (output_stream == NULL)
1415             {
1416               perror (opt.output_document);
1417               exit (1);
1418             }
1419           if (fstat (fileno (output_stream), &st) == 0 && S_ISREG (st.st_mode))
1420             output_stream_regular = true;
1421         }
1422       if (!output_stream_regular && opt.convert_links)
1423         {
1424           fprintf (stderr, _("-k can be used together with -O only if \
1425 outputting to a regular file.\n"));
1426           print_usage (1);
1427           exit(1);
1428         }
1429     }
1430
1431 #ifdef __VMS
1432   /* Set global ODS5 flag according to the specified destination (if
1433      any), otherwise according to the current default device.
1434   */
1435   if (output_stream == NULL)
1436     set_ods5_dest( "SYS$DISK");
1437   else if (output_stream != stdout)
1438     set_ods5_dest( opt.output_document);
1439 #endif /* def __VMS */
1440
1441 #ifdef WINDOWS
1442   ws_startup ();
1443 #endif
1444
1445 #ifdef SIGHUP
1446   /* Setup the signal handler to redirect output when hangup is
1447      received.  */
1448   if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
1449     signal(SIGHUP, redirect_output_signal);
1450 #endif
1451   /* ...and do the same for SIGUSR1.  */
1452 #ifdef SIGUSR1
1453   signal (SIGUSR1, redirect_output_signal);
1454 #endif
1455 #ifdef SIGPIPE
1456   /* Writing to a closed socket normally signals SIGPIPE, and the
1457      process exits.  What we want is to ignore SIGPIPE and just check
1458      for the return value of write().  */
1459   signal (SIGPIPE, SIG_IGN);
1460 #endif
1461 #ifdef SIGWINCH
1462   signal (SIGWINCH, progress_handle_sigwinch);
1463 #endif
1464
1465   /* Retrieve the URLs from argument list.  */
1466   for (t = url; *t; t++)
1467     {
1468       char *filename = NULL, *redirected_URL = NULL;
1469       int dt, url_err;
1470       /* Need to do a new struct iri every time, because
1471        * retrieve_url may modify it in some circumstances,
1472        * currently. */
1473       struct iri *iri = iri_new ();
1474       struct url *url_parsed;
1475
1476       set_uri_encoding (iri, opt.locale, true);
1477       url_parsed = url_parse (*t, &url_err, iri, true);
1478
1479       if (!url_parsed)
1480         {
1481           char *error = url_error (*t, url_err);
1482           logprintf (LOG_NOTQUIET, "%s: %s.\n",*t, error);
1483           xfree (error);
1484           inform_exit_status (URLERROR);
1485         }
1486       else
1487         {
1488           if ((opt.recursive || opt.page_requisites)
1489               && (url_scheme (*t) != SCHEME_FTP || url_uses_proxy (url_parsed)))
1490             {
1491               int old_follow_ftp = opt.follow_ftp;
1492
1493               /* Turn opt.follow_ftp on in case of recursive FTP retrieval */
1494               if (url_scheme (*t) == SCHEME_FTP)
1495                 opt.follow_ftp = 1;
1496
1497               retrieve_tree (url_parsed, NULL);
1498
1499               opt.follow_ftp = old_follow_ftp;
1500             }
1501           else
1502           {
1503             retrieve_url (url_parsed, *t, &filename, &redirected_URL, NULL,
1504                           &dt, opt.recursive, iri, true);
1505           }
1506
1507           if (opt.delete_after && file_exists_p(filename))
1508             {
1509               DEBUGP (("Removing file due to --delete-after in main():\n"));
1510               logprintf (LOG_VERBOSE, _("Removing %s.\n"), filename);
1511               if (unlink (filename))
1512                 logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1513             }
1514           xfree_null (redirected_URL);
1515           xfree_null (filename);
1516           url_free (url_parsed);
1517         }
1518       iri_free (iri);
1519     }
1520
1521   /* And then from the input file, if any.  */
1522   if (opt.input_filename)
1523     {
1524       int count;
1525       int status;
1526       status = retrieve_from_file (opt.input_filename, opt.force_html, &count);
1527       inform_exit_status (status);
1528       if (!count)
1529         logprintf (LOG_NOTQUIET, _("No URLs found in %s.\n"),
1530                    opt.input_filename);
1531     }
1532
1533   /* Print broken links. */
1534   if (opt.recursive && opt.spider)
1535     print_broken_links ();
1536
1537   /* Print the downloaded sum.  */
1538   if ((opt.recursive || opt.page_requisites
1539        || nurl > 1
1540        || (opt.input_filename && total_downloaded_bytes != 0))
1541       &&
1542       total_downloaded_bytes != 0)
1543     {
1544       double end_time = ptimer_measure (timer);
1545       ptimer_destroy (timer);
1546
1547       char *wall_time = xstrdup (secs_to_human_time (end_time - start_time));
1548       char *download_time = xstrdup (secs_to_human_time (total_download_time));
1549       logprintf (LOG_NOTQUIET,
1550                  _("FINISHED --%s--\nTotal wall clock time: %s\n"
1551                    "Downloaded: %d files, %s in %s (%s)\n"),
1552                  datetime_str (time (NULL)),
1553                  wall_time,
1554                  numurls,
1555                  human_readable (total_downloaded_bytes),
1556                  download_time,
1557                  retr_rate (total_downloaded_bytes, total_download_time));
1558       xfree (wall_time);
1559       xfree (download_time);
1560
1561       /* Print quota warning, if exceeded.  */
1562       if (opt.quota && total_downloaded_bytes > opt.quota)
1563         logprintf (LOG_NOTQUIET,
1564                    _("Download quota of %s EXCEEDED!\n"),
1565                    human_readable (opt.quota));
1566     }
1567
1568   if (opt.cookies_output)
1569     save_cookies ();
1570
1571   if (opt.convert_links && !opt.delete_after)
1572     convert_all_links ();
1573
1574   /* Close WARC file. */
1575   if (opt.warc_filename != 0)
1576     warc_close ();
1577
1578   log_close ();
1579
1580   for (i = 0; i < nurl; i++)
1581     xfree (url[i]);
1582   cleanup ();
1583
1584   exit (get_exit_status ());
1585 }
1586 #endif /* TESTING */
1587 \f
1588 #if defined(SIGHUP) || defined(SIGUSR1)
1589
1590 /* So the signal_name check doesn't blow when only one is available. */
1591 #ifndef SIGHUP
1592 # define SIGHUP -1
1593 #endif
1594 #ifndef SIGUSR1
1595 # define SIGUSR1 -1
1596 #endif
1597
1598 /* Hangup signal handler.  When wget receives SIGHUP or SIGUSR1, it
1599    will proceed operation as usual, trying to write into a log file.
1600    If that is impossible, the output will be turned off.  */
1601
1602 static void
1603 redirect_output_signal (int sig)
1604 {
1605   const char *signal_name = (sig == SIGHUP ? "SIGHUP" :
1606                              (sig == SIGUSR1 ? "SIGUSR1" :
1607                               "WTF?!"));
1608   log_request_redirect_output (signal_name);
1609   progress_schedule_redirect ();
1610   signal (sig, redirect_output_signal);
1611 }
1612 #endif
1613
1614 /*
1615  * vim: et ts=2 sw=2
1616  */