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