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, 2012 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 #include "closeout.h"
  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   atexit (close_stdout);
 970
 971   /* Construct the name of the executable, without the directory part.  */
 972 #ifdef __VMS
 973   /* On VMS, lose the "dev:[dir]" prefix and the ".EXE;nnn" suffix. */
 974   exec_name = vms_basename (argv[0]);
 975 #else /* def __VMS */
 976   exec_name = strrchr (argv[0], PATH_SEPARATOR);
 977   if (!exec_name)
 978     exec_name = argv[0];
 979   else
 980     ++exec_name;
 981 #endif /* def __VMS [else] */
 982
 983 #ifdef WINDOWS
 984   /* Drop extension (typically .EXE) from executable filename. */
 985   windows_main ((char **) &exec_name);
 986 #endif
 987
 988   /* Construct the arguments string. */
 989   int argstring_length = 1;
 990   for (i = 1; i < argc; i++)
 991     argstring_length += strlen (argv[i]) + 2 + 1;
 992   char *p = program_argstring = malloc (argstring_length * sizeof (char));
 993   if (p == NULL)
 994     {
 995       fprintf (stderr, _("Memory allocation problem\n"));
 996       exit (2);
 997     }
 998   for (i = 1; i < argc; i++)
 999     {
1000       *p++ = '"';
1001       int arglen = strlen (argv[i]);
1002       memcpy (p, argv[i], arglen);
1003       p += arglen;
1004       *p++ = '"';
1005       *p++ = ' ';
1006     }
1007   *p = '\0';
1008
1009   /* Load the hard-coded defaults.  */
1010   defaults ();
1011
1012   init_switches ();
1013
1014   /* This separate getopt_long is needed to find the user config file
1015      option ("--config") and parse it before the other user options. */
1016   longindex = -1;
1017   int retconf;
1018   bool use_userconfig = false;
1019
1020   while ((retconf = getopt_long (argc, argv,
1021                                 short_options, long_options, &longindex)) != -1)
1022     {
1023       int confval;
1024       bool userrc_ret = true;
1025       struct cmdline_option *config_opt;
1026
1027       /* There is no short option for "--config". */
1028       if (longindex >= 0)
1029         {
1030           confval = long_options[longindex].val;
1031           config_opt = &option_data[confval & ~BOOLEAN_NEG_MARKER];
1032           if (strcmp (config_opt->long_name, "config") == 0)
1033             {
1034               userrc_ret &= run_wgetrc (optarg);
1035               use_userconfig = true;
1036             }
1037           if (!userrc_ret)
1038             {
1039               fprintf (stderr, "Exiting due to error in %s\n", optarg);
1040               exit (2);
1041             }
1042           else
1043             break;
1044         }
1045     }
1046
1047   /* If the user did not specify a config, read the system wgetrc and ~/.wgetrc. */
1048   if (use_userconfig == false)
1049     initialize ();
1050
1051   opterr = 0;
1052   optind = 0;
1053
1054   longindex = -1;
1055   while ((ret = getopt_long (argc, argv,
1056                              short_options, long_options, &longindex)) != -1)
1057     {
1058       int val;
1059       struct cmdline_option *opt;
1060
1061       /* If LONGINDEX is unchanged, it means RET is referring a short
1062          option.  */
1063       if (longindex == -1)
1064         {
1065           if (ret == '?')
1066             {
1067               print_usage (1);
1068               fprintf (stderr, "\n");
1069               fprintf (stderr, _("Try `%s --help' for more options.\n"),
1070                        exec_name);
1071               exit (2);
1072             }
1073           /* Find the short option character in the mapping.  */
1074           longindex = optmap[ret - 32];
1075         }
1076       val = long_options[longindex].val;
1077
1078       /* Use the retrieved value to locate the option in the
1079          option_data array, and to see if we're dealing with the
1080          negated "--no-FOO" variant of the boolean option "--foo".  */
1081       opt = &option_data[val & ~BOOLEAN_NEG_MARKER];
1082       switch (opt->type)
1083         {
1084         case OPT_VALUE:
1085           setoptval (opt->data, optarg, opt->long_name);
1086           break;
1087         case OPT_BOOLEAN:
1088           if (optarg)
1089             /* The user has specified a value -- use it. */
1090             setoptval (opt->data, optarg, opt->long_name);
1091           else
1092             {
1093               /* NEG is true for `--no-FOO' style boolean options. */
1094               bool neg = !!(val & BOOLEAN_NEG_MARKER);
1095               setoptval (opt->data, neg ? "0" : "1", opt->long_name);
1096             }
1097           break;
1098         case OPT_FUNCALL:
1099           {
1100             void (*func) (void) = (void (*) (void)) opt->data;
1101             func ();
1102           }
1103           break;
1104         case OPT__APPEND_OUTPUT:
1105           setoptval ("logfile", optarg, opt->long_name);
1106           append_to_log = true;
1107           break;
1108         case OPT__EXECUTE:
1109           run_command (optarg);
1110           break;
1111         case OPT__NO:
1112           {
1113             /* We support real --no-FOO flags now, but keep these
1114                short options for convenience and backward
1115                compatibility.  */
1116             char *p;
1117             for (p = optarg; p && *p; p++)
1118               switch (*p)
1119                 {
1120                 case 'v':
1121                   setoptval ("verbose", "0", opt->long_name);
1122                   break;
1123                 case 'H':
1124                   setoptval ("addhostdir", "0", opt->long_name);
1125                   break;
1126                 case 'd':
1127                   setoptval ("dirstruct", "0", opt->long_name);
1128                   break;
1129                 case 'c':
1130                   setoptval ("noclobber", "1", opt->long_name);
1131                   break;
1132                 case 'p':
1133                   setoptval ("noparent", "1", opt->long_name);
1134                   break;
1135                 default:
1136                   fprintf (stderr, _("%s: illegal option -- `-n%c'\n"),
1137                            exec_name, *p);
1138                   print_usage (1);
1139                   fprintf (stderr, "\n");
1140                   fprintf (stderr, _("Try `%s --help' for more options.\n"),
1141                            exec_name);
1142                   exit (1);
1143                 }
1144             break;
1145           }
1146         case OPT__PARENT:
1147         case OPT__CLOBBER:
1148           {
1149             /* The wgetrc commands are named noparent and noclobber,
1150                so we must revert the meaning of the cmdline options
1151                before passing the value to setoptval.  */
1152             bool flag = true;
1153             if (optarg)
1154               flag = (*optarg == '1' || c_tolower (*optarg) == 'y'
1155                       || (c_tolower (optarg[0]) == 'o'
1156                           && c_tolower (optarg[1]) == 'n'));
1157             setoptval (opt->type == OPT__PARENT ? "noparent" : "noclobber",
1158                        flag ? "0" : "1", opt->long_name);
1159             break;
1160           }
1161         case OPT__DONT_REMOVE_LISTING:
1162           setoptval ("removelisting", "0", opt->long_name);
1163           break;
1164         }
1165
1166       longindex = -1;
1167     }
1168
1169   nurl = argc - optind;
1170
1171   /* All user options have now been processed, so it's now safe to do
1172      interoption dependency checks. */
1173
1174   if (opt.noclobber && opt.convert_links)
1175     {
1176       fprintf (stderr,
1177                _("Both --no-clobber and --convert-links were specified,"
1178                  "only --convert-links will be used.\n"));
1179       opt.noclobber = false;
1180     }
1181
1182   if (opt.reclevel == 0)
1183       opt.reclevel = INFINITE_RECURSION; /* see recur.h for commentary */
1184
1185   if (opt.spider || opt.delete_after)
1186       opt.no_dirstruct = true;
1187
1188   if (opt.page_requisites && !opt.recursive)
1189     {
1190       /* Don't set opt.recursive here because it would confuse the FTP
1191          code.  Instead, call retrieve_tree below when either
1192          page_requisites or recursive is requested.  */
1193       opt.reclevel = 0;
1194       if (!opt.no_dirstruct)
1195         opt.dirstruct = 1;      /* normally handled by cmd_spec_recursive() */
1196     }
1197
1198   if (opt.verbose == -1)
1199     opt.verbose = !opt.quiet;
1200
1201   /* Sanity checks.  */
1202   if (opt.verbose && opt.quiet)
1203     {
1204       fprintf (stderr, _("Can't be verbose and quiet at the same time.\n"));
1205       print_usage (1);
1206       exit (1);
1207     }
1208   if (opt.timestamping && opt.noclobber)
1209     {
1210       fprintf (stderr, _("\
1211 Can't timestamp and not clobber old files at the same time.\n"));
1212       print_usage (1);
1213       exit (1);
1214     }
1215 #ifdef ENABLE_IPV6
1216   if (opt.ipv4_only && opt.ipv6_only)
1217     {
1218       fprintf (stderr,
1219                _("Cannot specify both --inet4-only and --inet6-only.\n"));
1220       print_usage (1);
1221       exit (1);
1222     }
1223 #endif
1224   if (opt.output_document)
1225     {
1226       if (opt.convert_links
1227           && (nurl > 1 || opt.page_requisites || opt.recursive))
1228         {
1229           fputs (_("\
1230 Cannot specify both -k and -O if multiple URLs are given, or in combination\n\
1231 with -p or -r. See the manual for details.\n\n"), stderr);
1232           print_usage (1);
1233           exit (1);
1234         }
1235       if (opt.page_requisites
1236           || opt.recursive)
1237         {
1238           logprintf (LOG_NOTQUIET, "%s", _("\
1239 WARNING: combining -O with -r or -p will mean that all downloaded content\n\
1240 will be placed in the single file you specified.\n\n"));
1241         }
1242       if (opt.timestamping)
1243         {
1244           logprintf (LOG_NOTQUIET, "%s", _("\
1245 WARNING: timestamping does nothing in combination with -O. See the manual\n\
1246 for details.\n\n"));
1247           opt.timestamping = false;
1248         }
1249       if (opt.noclobber && file_exists_p(opt.output_document))
1250            {
1251               /* Check if output file exists; if it does, exit. */
1252               logprintf (LOG_VERBOSE,
1253                          _("File `%s' already there; not retrieving.\n"),
1254                          opt.output_document);
1255               exit(1);
1256            }
1257     }
1258
1259   if (opt.warc_filename != 0)
1260     {
1261       if (opt.noclobber)
1262         {
1263           fprintf (stderr,
1264                    _("WARC output does not work with --no-clobber, "
1265                      "--no-clobber will be disabled.\n"));
1266           opt.noclobber = false;
1267         }
1268       if (opt.timestamping)
1269         {
1270           fprintf (stderr,
1271                    _("WARC output does not work with timestamping, "
1272                      "timestamping will be disabled.\n"));
1273           opt.timestamping = false;
1274         }
1275       if (opt.spider)
1276         {
1277           fprintf (stderr,
1278                    _("WARC output does not work with --spider.\n"));
1279           exit (1);
1280         }
1281       if (opt.always_rest)
1282         {
1283           fprintf (stderr,
1284                    _("WARC output does not work with --continue, "
1285                      "--continue will be disabled.\n"));
1286           opt.always_rest = false;
1287         }
1288       if (opt.warc_cdx_dedup_filename != 0 && !opt.warc_digests_enabled)
1289         {
1290           fprintf (stderr,
1291                    _("Digests are disabled; WARC deduplication will "
1292                      "not find duplicate records.\n"));
1293         }
1294       if (opt.warc_keep_log)
1295         {
1296           opt.progress_type = "dot";
1297         }
1298     }
1299
1300   if (opt.ask_passwd && opt.passwd)
1301     {
1302       fprintf (stderr,
1303                _("Cannot specify both --ask-password and --password.\n"));
1304       print_usage (1);
1305       exit (1);
1306     }
1307
1308   if (!nurl && !opt.input_filename)
1309     {
1310       /* No URL specified.  */
1311       fprintf (stderr, _("%s: missing URL\n"), exec_name);
1312       print_usage (1);
1313       fprintf (stderr, "\n");
1314       /* #### Something nicer should be printed here -- similar to the
1315          pre-1.5 `--help' page.  */
1316       fprintf (stderr, _("Try `%s --help' for more options.\n"), exec_name);
1317       exit (1);
1318     }
1319
1320 #ifdef ENABLE_IRI
1321   if (opt.enable_iri)
1322     {
1323       if (opt.locale && !check_encoding_name (opt.locale))
1324         opt.locale = NULL;
1325
1326       if (!opt.locale)
1327         opt.locale = find_locale ();
1328
1329       if (opt.encoding_remote && !check_encoding_name (opt.encoding_remote))
1330         opt.encoding_remote = NULL;
1331     }
1332 #else
1333   memset (&dummy_iri, 0, sizeof (dummy_iri));
1334   if (opt.enable_iri || opt.locale || opt.encoding_remote)
1335     {
1336       /* sXXXav : be more specific... */
1337       fprintf (stderr, _("This version does not have support for IRIs\n"));
1338       exit(1);
1339     }
1340 #endif
1341
1342   if (opt.ask_passwd)
1343     {
1344       opt.passwd = prompt_for_password ();
1345
1346       if (opt.passwd == NULL || opt.passwd[0] == '\0')
1347         exit (1);
1348     }
1349
1350 #ifdef USE_WATT32
1351   if (opt.wdebug)
1352      dbug_init();
1353   sock_init();
1354 #else
1355   if (opt.background)
1356     fork_to_background ();
1357 #endif
1358
1359   /* Initialize progress.  Have to do this after the options are
1360      processed so we know where the log file is.  */
1361   if (opt.verbose)
1362     set_progress_implementation (opt.progress_type);
1363
1364   /* Fill in the arguments.  */
1365   url = alloca_array (char *, nurl + 1);
1366   if (url == NULL)
1367     {
1368       fprintf (stderr, _("Memory allocation problem\n"));
1369       exit (2);
1370     }
1371   for (i = 0; i < nurl; i++, optind++)
1372     {
1373       char *rewritten = rewrite_shorthand_url (argv[optind]);
1374       if (rewritten)
1375         url[i] = rewritten;
1376       else
1377         url[i] = xstrdup (argv[optind]);
1378     }
1379   url[i] = NULL;
1380
1381   /* Initialize logging.  */
1382   log_init (opt.lfilename, append_to_log);
1383
1384   /* Open WARC file. */
1385   if (opt.warc_filename != 0)
1386     warc_init ();
1387
1388   DEBUGP (("DEBUG output created by Wget %s on %s.\n\n",
1389            version_string, OS_TYPE));
1390
1391   /* Open the output filename if necessary.  */
1392
1393 /* 2005-04-17 SMS.
1394    Note that having the output_stream ("-O") file opened here for an FTP
1395    URL rather than in getftp() (ftp.c) (and the http equivalent) rather
1396    limits the ability in VMS to open the file differently for ASCII
1397    versus binary FTP there.  (Of course, doing it here allows a open
1398    failure to be detected immediately, without first connecting to the
1399    server.)
1400 */
1401   if (opt.output_document)
1402     {
1403       if (HYPHENP (opt.output_document))
1404         {
1405 #ifdef WINDOWS
1406           _setmode (_fileno (stdout), _O_BINARY);
1407 #endif
1408           output_stream = stdout;
1409         }
1410       else
1411         {
1412           struct_fstat st;
1413
1414 #ifdef __VMS
1415 /* Common fopen() optional arguments:
1416    sequential access only, access callback function.
1417 */
1418 # define FOPEN_OPT_ARGS , "fop=sqo", "acc", acc_cb, &open_id
1419           int open_id = 7;
1420 #else /* def __VMS */
1421 # define FOPEN_OPT_ARGS
1422 #endif /* def __VMS [else] */
1423
1424           output_stream = fopen (opt.output_document,
1425                                  opt.always_rest ? "ab" : "wb"
1426                                  FOPEN_OPT_ARGS);
1427           if (output_stream == NULL)
1428             {
1429               perror (opt.output_document);
1430               exit (1);
1431             }
1432           if (fstat (fileno (output_stream), &st) == 0 && S_ISREG (st.st_mode))
1433             output_stream_regular = true;
1434         }
1435       if (!output_stream_regular && opt.convert_links)
1436         {
1437           fprintf (stderr, _("-k can be used together with -O only if \
1438 outputting to a regular file.\n"));
1439           print_usage (1);
1440           exit(1);
1441         }
1442     }
1443
1444 #ifdef __VMS
1445   /* Set global ODS5 flag according to the specified destination (if
1446      any), otherwise according to the current default device.
1447   */
1448   if (output_stream == NULL)
1449     set_ods5_dest( "SYS$DISK");
1450   else if (output_stream != stdout)
1451     set_ods5_dest( opt.output_document);
1452 #endif /* def __VMS */
1453
1454 #ifdef WINDOWS
1455   ws_startup ();
1456 #endif
1457
1458 #ifdef SIGHUP
1459   /* Setup the signal handler to redirect output when hangup is
1460      received.  */
1461   if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
1462     signal(SIGHUP, redirect_output_signal);
1463 #endif
1464   /* ...and do the same for SIGUSR1.  */
1465 #ifdef SIGUSR1
1466   signal (SIGUSR1, redirect_output_signal);
1467 #endif
1468 #ifdef SIGPIPE
1469   /* Writing to a closed socket normally signals SIGPIPE, and the
1470      process exits.  What we want is to ignore SIGPIPE and just check
1471      for the return value of write().  */
1472   signal (SIGPIPE, SIG_IGN);
1473 #endif
1474 #ifdef SIGWINCH
1475   signal (SIGWINCH, progress_handle_sigwinch);
1476 #endif
1477
1478   /* Retrieve the URLs from argument list.  */
1479   for (t = url; *t; t++)
1480     {
1481       char *filename = NULL, *redirected_URL = NULL;
1482       int dt, url_err;
1483       /* Need to do a new struct iri every time, because
1484        * retrieve_url may modify it in some circumstances,
1485        * currently. */
1486       struct iri *iri = iri_new ();
1487       struct url *url_parsed;
1488
1489       set_uri_encoding (iri, opt.locale, true);
1490       url_parsed = url_parse (*t, &url_err, iri, true);
1491
1492       if (!url_parsed)
1493         {
1494           char *error = url_error (*t, url_err);
1495           logprintf (LOG_NOTQUIET, "%s: %s.\n",*t, error);
1496           xfree (error);
1497           inform_exit_status (URLERROR);
1498         }
1499       else
1500         {
1501           if ((opt.recursive || opt.page_requisites)
1502               && (url_scheme (*t) != SCHEME_FTP || url_uses_proxy (url_parsed)))
1503             {
1504               int old_follow_ftp = opt.follow_ftp;
1505
1506               /* Turn opt.follow_ftp on in case of recursive FTP retrieval */
1507               if (url_scheme (*t) == SCHEME_FTP)
1508                 opt.follow_ftp = 1;
1509
1510               retrieve_tree (url_parsed, NULL);
1511
1512               opt.follow_ftp = old_follow_ftp;
1513             }
1514           else
1515           {
1516             retrieve_url (url_parsed, *t, &filename, &redirected_URL, NULL,
1517                           &dt, opt.recursive, iri, true);
1518           }
1519
1520           if (opt.delete_after && file_exists_p(filename))
1521             {
1522               DEBUGP (("Removing file due to --delete-after in main():\n"));
1523               logprintf (LOG_VERBOSE, _("Removing %s.\n"), filename);
1524               if (unlink (filename))
1525                 logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
1526             }
1527           xfree_null (redirected_URL);
1528           xfree_null (filename);
1529           url_free (url_parsed);
1530         }
1531       iri_free (iri);
1532     }
1533
1534   /* And then from the input file, if any.  */
1535   if (opt.input_filename)
1536     {
1537       int count;
1538       int status;
1539       status = retrieve_from_file (opt.input_filename, opt.force_html, &count);
1540       inform_exit_status (status);
1541       if (!count)
1542         logprintf (LOG_NOTQUIET, _("No URLs found in %s.\n"),
1543                    opt.input_filename);
1544     }
1545
1546   /* Print broken links. */
1547   if (opt.recursive && opt.spider)
1548     print_broken_links ();
1549
1550   /* Print the downloaded sum.  */
1551   if ((opt.recursive || opt.page_requisites
1552        || nurl > 1
1553        || (opt.input_filename && total_downloaded_bytes != 0))
1554       &&
1555       total_downloaded_bytes != 0)
1556     {
1557       double end_time = ptimer_measure (timer);
1558       ptimer_destroy (timer);
1559
1560       char *wall_time = xstrdup (secs_to_human_time (end_time - start_time));
1561       char *download_time = xstrdup (secs_to_human_time (total_download_time));
1562       logprintf (LOG_NOTQUIET,
1563                  _("FINISHED --%s--\nTotal wall clock time: %s\n"
1564                    "Downloaded: %d files, %s in %s (%s)\n"),
1565                  datetime_str (time (NULL)),
1566                  wall_time,
1567                  numurls,
1568                  human_readable (total_downloaded_bytes),
1569                  download_time,
1570                  retr_rate (total_downloaded_bytes, total_download_time));
1571       xfree (wall_time);
1572       xfree (download_time);
1573
1574       /* Print quota warning, if exceeded.  */
1575       if (opt.quota && total_downloaded_bytes > opt.quota)
1576         logprintf (LOG_NOTQUIET,
1577                    _("Download quota of %s EXCEEDED!\n"),
1578                    human_readable (opt.quota));
1579     }
1580
1581   if (opt.cookies_output)
1582     save_cookies ();
1583
1584   if (opt.convert_links && !opt.delete_after)
1585     convert_all_links ();
1586
1587   /* Close WARC file. */
1588   if (opt.warc_filename != 0)
1589     warc_close ();
1590
1591   log_close ();
1592
1593   for (i = 0; i < nurl; i++)
1594     xfree (url[i]);
1595   cleanup ();
1596
1597   exit (get_exit_status ());
1598 }
1599 #endif /* TESTING */
1600 \f
1601 #if defined(SIGHUP) || defined(SIGUSR1)
1602
1603 /* So the signal_name check doesn't blow when only one is available. */
1604 #ifndef SIGHUP
1605 # define SIGHUP -1
1606 #endif
1607 #ifndef SIGUSR1
1608 # define SIGUSR1 -1
1609 #endif
1610
1611 /* Hangup signal handler.  When wget receives SIGHUP or SIGUSR1, it
1612    will proceed operation as usual, trying to write into a log file.
1613    If that is impossible, the output will be turned off.  */
1614
1615 static void
1616 redirect_output_signal (int sig)
1617 {
1618   const char *signal_name = (sig == SIGHUP ? "SIGHUP" :
1619                              (sig == SIGUSR1 ? "SIGUSR1" :
1620                               "WTF?!"));
1621   log_request_redirect_output (signal_name);
1622   progress_schedule_redirect ();
1623   signal (sig, redirect_output_signal);
1624 }
1625 #endif
1626
1627 /*
1628  * vim: et ts=2 sw=2
1629  */