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

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