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