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