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

   1 /* Command line parsing.
   2    Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Wget.
   5
   6 GNU Wget is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 GNU Wget is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Wget; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20 In addition, as a special exception, the Free Software Foundation
  21 gives permission to link the code of its release of Wget with the
  22 OpenSSL project's "OpenSSL" library (or with modified versions of it
  23 that use the same license as the "OpenSSL" library), and distribute
  24 the linked executables.  You must obey the GNU General Public License
  25 in all respects for all of the code used other than "OpenSSL".  If you
  26 modify this file, you may extend this exception to your version of the
  27 file, but you are not obligated to do so.  If you do not wish to do
  28 so, delete this exception statement from your version.  */
  29
  30 #include <config.h>
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #ifdef HAVE_UNISTD_H
  35 # include <unistd.h>
  36 #endif /* HAVE_UNISTD_H */
  37 #include <string.h>
  38 #include <signal.h>
  39 #if defined(HAVE_NLS) && defined(HAVE_LOCALE_H)
  40 # include <locale.h>
  41 #endif
  42 #include <assert.h>
  43 #include <errno.h>
  44
  45 #include "wget.h"
  46 #include "utils.h"
  47 #include "init.h"
  48 #include "retr.h"
  49 #include "recur.h"
  50 #include "host.h"
  51 #include "url.h"
  52 #include "progress.h"           /* for progress_handle_sigwinch */
  53 #include "convert.h"
  54
  55 /* On GNU system this will include system-wide getopt.h. */
  56 #include "getopt.h"
  57
  58 #ifndef PATH_SEPARATOR
  59 # define PATH_SEPARATOR '/'
  60 #endif
  61
  62 struct options opt;
  63
  64 extern char *version_string;
  65
  66 extern struct cookie_jar *wget_cookie_jar;
  67
  68 static void redirect_output_signal (int);
  69
  70 const char *exec_name;
  71 \f
  72 /* Initialize I18N/L10N.  That amounts to invoking setlocale, and
  73    setting up gettext's message catalog using bindtextdomain and
  74    textdomain.  Does nothing if NLS is disabled or missing.  */
  75
  76 static void
  77 i18n_initialize (void)
  78 {
  79   /* HAVE_NLS implies existence of functions invoked here.  */
  80 #ifdef HAVE_NLS
  81   /* Set the current locale.  */
  82   /* Where possible, sets only LC_MESSAGES and LC_CTYPE.  Other
  83      categories, such as numeric, time, or collation, break code that
  84      parses data received from the network and relies on C-locale
  85      behavior of libc functions.  For example, Solaris strptime fails
  86      to recognize English month names in non-English locales, which
  87      breaks http_atotm.  Some implementations of fnmatch perform
  88      unwanted case folding in non-C locales.  ctype macros, while they
  89      were used, provided another example against LC_ALL.  */
  90 #if defined(LC_MESSAGES) && defined(LC_CTYPE)
  91   setlocale (LC_MESSAGES, "");
  92   setlocale (LC_CTYPE, "");     /* safe because we use safe-ctype */
  93 #else
  94   setlocale (LC_ALL, "");
  95 #endif
  96   /* Set the text message domain.  */
  97   bindtextdomain ("wget", LOCALEDIR);
  98   textdomain ("wget");
  99 #endif /* HAVE_NLS */
 100 }
 101 \f
 102 /* Definition of command-line options. */
 103
 104 static void print_help (void);
 105 static void print_version (void);
 106
 107 #ifdef HAVE_SSL
 108 # define IF_SSL(x) x
 109 #else
 110 # define IF_SSL(x) NULL
 111 #endif
 112
 113 #ifdef ENABLE_DEBUG
 114 # define WHEN_DEBUG(x) x
 115 #else
 116 # define WHEN_DEBUG(x) NULL
 117 #endif
 118
 119 struct cmdline_option {
 120   const char *long_name;
 121   char short_name;
 122   enum {
 123     OPT_VALUE,
 124     OPT_BOOLEAN,
 125     OPT_FUNCALL,
 126     /* Non-standard options that have to be handled specially in
 127        main().  */
 128     OPT__APPEND_OUTPUT,
 129     OPT__CLOBBER,
 130     OPT__DONT_REMOVE_LISTING,
 131     OPT__EXECUTE,
 132     OPT__NO,
 133     OPT__PARENT
 134   } type;
 135   const void *data;             /* for standard options */
 136   int argtype;                  /* for non-standard options */
 137 };
 138
 139 struct cmdline_option option_data[] =
 140   {
 141     { "accept", 'A', OPT_VALUE, "accept", -1 },
 142     { "append-output", 'a', OPT__APPEND_OUTPUT, NULL, required_argument },
 143     { "background", 'b', OPT_BOOLEAN, "background", -1 },
 144     { "backup-converted", 'K', OPT_BOOLEAN, "backupconverted", -1 },
 145     { "backups", 0, OPT_BOOLEAN, "backups", -1 },
 146     { "base", 'B', OPT_VALUE, "base", -1 },
 147     { "bind-address", 0, OPT_VALUE, "bindaddress", -1 },
 148     { IF_SSL ("ca-certificate"), 0, OPT_VALUE, "cacertificate", -1 },
 149     { IF_SSL ("ca-directory"), 0, OPT_VALUE, "cadirectory", -1 },
 150     { "cache", 0, OPT_BOOLEAN, "cache", -1 },
 151     { IF_SSL ("certificate"), 0, OPT_VALUE, "certificate", -1 },
 152     { IF_SSL ("certificate-type"), 0, OPT_VALUE, "certificatetype", -1 },
 153     { IF_SSL ("check-certificate"), 0, OPT_BOOLEAN, "checkcertificate", -1 },
 154     { "clobber", 0, OPT__CLOBBER, NULL, optional_argument },
 155     { "connect-timeout", 0, OPT_VALUE, "connecttimeout", -1 },
 156     { "continue", 'c', OPT_BOOLEAN, "continue", -1 },
 157     { "convert-links", 'k', OPT_BOOLEAN, "convertlinks", -1 },
 158     { "cookies", 0, OPT_BOOLEAN, "cookies", -1 },
 159     { "cut-dirs", 0, OPT_VALUE, "cutdirs", -1 },
 160     { WHEN_DEBUG ("debug"), 'd', OPT_BOOLEAN, "debug", -1 },
 161     { "delete-after", 0, OPT_BOOLEAN, "deleteafter", -1 },
 162     { "directories", 0, OPT_BOOLEAN, "dirstruct", -1 },
 163     { "directory-prefix", 'P', OPT_VALUE, "dirprefix", -1 },
 164     { "dns-cache", 0, OPT_BOOLEAN, "dnscache", -1 },
 165     { "dns-timeout", 0, OPT_VALUE, "dnstimeout", -1 },
 166     { "domains", 'D', OPT_VALUE, "domains", -1 },
 167     { "dont-remove-listing", 0, OPT__DONT_REMOVE_LISTING, NULL, no_argument },
 168     { "dot-style", 0, OPT_VALUE, "dotstyle", -1 },
 169     { "egd-file", 0, OPT_VALUE, "egdfile", -1 },
 170     { "exclude-directories", 'X', OPT_VALUE, "excludedirectories", -1 },
 171     { "exclude-domains", 0, OPT_VALUE, "excludedomains", -1 },
 172     { "execute", 'e', OPT__EXECUTE, NULL, required_argument },
 173     { "follow-ftp", 0, OPT_BOOLEAN, "followftp", -1 },
 174     { "follow-tags", 0, OPT_VALUE, "followtags", -1 },
 175     { "force-directories", 'x', OPT_BOOLEAN, "dirstruct", -1 },
 176     { "force-html", 'F', OPT_BOOLEAN, "forcehtml", -1 },
 177     { "ftp-password", 0, OPT_VALUE, "ftppassword", -1 },
 178     { "ftp-user", 0, OPT_VALUE, "ftpuser", -1 },
 179     { "glob", 0, OPT_BOOLEAN, "glob", -1 },
 180     { "header", 0, OPT_VALUE, "header", -1 },
 181     { "help", 'h', OPT_FUNCALL, (void *)print_help, no_argument },
 182     { "host-directories", 0, OPT_BOOLEAN, "addhostdir", -1 },
 183     { "html-extension", 'E', OPT_BOOLEAN, "htmlextension", -1 },
 184     { "htmlify", 0, OPT_BOOLEAN, "htmlify", -1 },
 185     { "http-keep-alive", 0, OPT_BOOLEAN, "httpkeepalive", -1 },
 186     { "http-passwd", 0, OPT_VALUE, "httppassword", -1 }, /* deprecated */
 187     { "http-password", 0, OPT_VALUE, "httppassword", -1 },
 188     { "http-user", 0, OPT_VALUE, "httpuser", -1 },
 189     { "ignore-length", 0, OPT_BOOLEAN, "ignorelength", -1 },
 190     { "ignore-tags", 0, OPT_VALUE, "ignoretags", -1 },
 191     { "include-directories", 'I', OPT_VALUE, "includedirectories", -1 },
 192 #ifdef ENABLE_IPV6
 193     { "inet4-only", '4', OPT_BOOLEAN, "inet4only", -1 },
 194     { "inet6-only", '6', OPT_BOOLEAN, "inet6only", -1 },
 195 #endif
 196     { "input-file", 'i', OPT_VALUE, "input", -1 },
 197     { "keep-session-cookies", 0, OPT_BOOLEAN, "keepsessioncookies", -1 },
 198     { "level", 'l', OPT_VALUE, "reclevel", -1 },
 199     { "limit-rate", 0, OPT_VALUE, "limitrate", -1 },
 200     { "load-cookies", 0, OPT_VALUE, "loadcookies", -1 },
 201     { "mirror", 'm', OPT_BOOLEAN, "mirror", -1 },
 202     { "no", 'n', OPT__NO, NULL, required_argument },
 203     { "no-clobber", 0, OPT_BOOLEAN, "noclobber", -1 },
 204     { "no-parent", 0, OPT_BOOLEAN, "noparent", -1 },
 205     { "output-document", 'O', OPT_VALUE, "outputdocument", -1 },
 206     { "output-file", 'o', OPT_VALUE, "logfile", -1 },
 207     { "page-requisites", 'p', OPT_BOOLEAN, "pagerequisites", -1 },
 208     { "parent", 0, OPT__PARENT, NULL, optional_argument },
 209     { "passive-ftp", 0, OPT_BOOLEAN, "passiveftp", -1 },
 210     { "password", 0, OPT_VALUE, "password", -1 },
 211     { "post-data", 0, OPT_VALUE, "postdata", -1 },
 212     { "post-file", 0, OPT_VALUE, "postfile", -1 },
 213     { "prefer-family", 0, OPT_VALUE, "preferfamily", -1 },
 214     { "preserve-permissions", 0, OPT_BOOLEAN, "preservepermissions", -1 },
 215     { IF_SSL ("private-key"), 0, OPT_VALUE, "privatekey", -1 },
 216     { IF_SSL ("private-key-type"), 0, OPT_VALUE, "privatekeytype", -1 },
 217     { "progress", 0, OPT_VALUE, "progress", -1 },
 218     { "protocol-directories", 0, OPT_BOOLEAN, "protocoldirectories", -1 },
 219     { "proxy", 0, OPT_BOOLEAN, "useproxy", -1 },
 220     { "proxy__compat", 'Y', OPT_VALUE, "useproxy", -1 }, /* back-compatible */
 221     { "proxy-passwd", 0, OPT_VALUE, "proxypassword", -1 }, /* deprecated */
 222     { "proxy-password", 0, OPT_VALUE, "proxypassword", -1 },
 223     { "proxy-user", 0, OPT_VALUE, "proxyuser", -1 },
 224     { "quiet", 'q', OPT_BOOLEAN, "quiet", -1 },
 225     { "quota", 'Q', OPT_VALUE, "quota", -1 },
 226     { "random-file", 0, OPT_VALUE, "randomfile", -1 },
 227     { "random-wait", 0, OPT_BOOLEAN, "randomwait", -1 },
 228     { "read-timeout", 0, OPT_VALUE, "readtimeout", -1 },
 229     { "recursive", 'r', OPT_BOOLEAN, "recursive", -1 },
 230     { "referer", 0, OPT_VALUE, "referer", -1 },
 231     { "reject", 'R', OPT_VALUE, "reject", -1 },
 232     { "relative", 'L', OPT_BOOLEAN, "relativeonly", -1 },
 233     { "remove-listing", 0, OPT_BOOLEAN, "removelisting", -1 },
 234     { "restrict-file-names", 0, OPT_BOOLEAN, "restrictfilenames", -1 },
 235     { "retr-symlinks", 0, OPT_BOOLEAN, "retrsymlinks", -1 },
 236     { "retry-connrefused", 0, OPT_BOOLEAN, "retryconnrefused", -1 },
 237     { "save-cookies", 0, OPT_VALUE, "savecookies", -1 },
 238     { "save-headers", 0, OPT_BOOLEAN, "saveheaders", -1 },
 239     { IF_SSL ("secure-protocol"), 0, OPT_VALUE, "secureprotocol", -1 },
 240     { "server-response", 'S', OPT_BOOLEAN, "serverresponse", -1 },
 241     { "span-hosts", 'H', OPT_BOOLEAN, "spanhosts", -1 },
 242     { "spider", 0, OPT_BOOLEAN, "spider", -1 },
 243     { "strict-comments", 0, OPT_BOOLEAN, "strictcomments", -1 },
 244     { "timeout", 'T', OPT_VALUE, "timeout", -1 },
 245     { "timestamping", 'N', OPT_BOOLEAN, "timestamping", -1 },
 246     { "tries", 't', OPT_VALUE, "tries", -1 },
 247     { "user", 0, OPT_VALUE, "user", -1 },
 248     { "user-agent", 'U', OPT_VALUE, "useragent", -1 },
 249     { "verbose", 'v', OPT_BOOLEAN, "verbose", -1 },
 250     { "verbose", 0, OPT_BOOLEAN, "verbose", -1 },
 251     { "version", 'V', OPT_FUNCALL, (void *) print_version, no_argument },
 252     { "wait", 'w', OPT_VALUE, "wait", -1 },
 253     { "waitretry", 0, OPT_VALUE, "waitretry", -1 },
 254   };
 255
 256 #undef WHEN_DEBUG
 257 #undef IF_SSL
 258
 259 /* Return a string that contains S with "no-" prepended.  The string
 260    is NUL-terminated and allocated off static storage at Wget
 261    startup.  */
 262
 263 static char *
 264 no_prefix (const char *s)
 265 {
 266   static char buffer[1024];
 267   static char *p = buffer;
 268
 269   char *cp = p;
 270   int size = 3 + strlen (s) + 1;  /* "no-STRING\0" */
 271   if (p + size >= buffer + sizeof (buffer))
 272     abort ();
 273
 274   cp[0] = 'n', cp[1] = 'o', cp[2] = '-';
 275   strcpy (cp + 3, s);
 276   p += size;
 277   return cp;
 278 }
 279
 280 /* The arguments that that main passes to getopt_long. */
 281 static struct option long_options[2 * countof (option_data) + 1];
 282 static char short_options[128];
 283
 284 /* Mapping between short option chars and option_data indices. */
 285 static unsigned char optmap[96];
 286
 287 /* Marker for `--no-FOO' values in long_options.  */
 288 #define BOOLEAN_NEG_MARKER 1024
 289
 290 /* Initialize the long_options array used by getopt_long from the data
 291    in option_data.  */
 292
 293 static void
 294 init_switches (void)
 295 {
 296   char *p = short_options;
 297   int i, o = 0;
 298   for (i = 0; i < countof (option_data); i++)
 299     {
 300       struct cmdline_option *opt = &option_data[i];
 301       struct option *longopt;
 302
 303       if (!opt->long_name)
 304         /* The option is disabled. */
 305         continue;
 306
 307       longopt = &long_options[o++];
 308       longopt->name = opt->long_name;
 309       longopt->val = i;
 310       if (opt->short_name)
 311         {
 312           *p++ = opt->short_name;
 313           optmap[opt->short_name - 32] = longopt - long_options;
 314         }
 315       switch (opt->type)
 316         {
 317         case OPT_VALUE:
 318           longopt->has_arg = required_argument;
 319           if (opt->short_name)
 320             *p++ = ':';
 321           break;
 322         case OPT_BOOLEAN:
 323           /* Specify an optional argument for long options, so that
 324              --option=off works the same as --no-option, for
 325              compatibility with pre-1.10 Wget.  However, don't specify
 326              optional arguments short-option booleans because they
 327              prevent combining of short options.  */
 328           longopt->has_arg = optional_argument;
 329           /* For Boolean options, add the "--no-FOO" variant, which is
 330              identical to "--foo", except it has opposite meaning and
 331              it doesn't allow an argument.  */
 332           longopt = &long_options[o++];
 333           longopt->name = no_prefix (opt->long_name);
 334           longopt->has_arg = no_argument;
 335           /* Mask the value so we'll be able to recognize that we're
 336              dealing with the false value.  */
 337           longopt->val = i | BOOLEAN_NEG_MARKER;
 338           break;
 339         default:
 340           assert (opt->argtype != -1);
 341           longopt->has_arg = opt->argtype;
 342           if (opt->short_name)
 343             {
 344               if (longopt->has_arg == required_argument)
 345                 *p++ = ':';
 346               /* Don't handle optional_argument */
 347             }
 348         }
 349     }
 350   /* Terminate short_options. */
 351   *p = '\0';
 352   /* No need for xzero(long_options[o]) because its storage is static
 353      and it will be zeroed by default.  */
 354   assert (o <= countof (long_options));
 355 }
 356
 357 /* Print the usage message.  */
 358 static void
 359 print_usage (void)
 360 {
 361   printf (_("Usage: %s [OPTION]... [URL]...\n"), exec_name);
 362 }
 363
 364 /* Print the help message, describing all the available options.  If
 365    you add an option, be sure to update this list.  */
 366 static void
 367 print_help (void)
 368 {
 369   /* We split the help text this way to ease translation of individual
 370      entries.  */
 371   static const char *help[] = {
 372     "\n",
 373     N_("\
 374 Mandatory arguments to long options are mandatory for short options too.\n\n"),
 375     N_("\
 376 Startup:\n"),
 377     N_("\
 378   -V,  --version           display the version of Wget and exit.\n"),
 379     N_("\
 380   -h,  --help              print this help.\n"),
 381     N_("\
 382   -b,  --background        go to background after startup.\n"),
 383     N_("\
 384   -e,  --execute=COMMAND   execute a `.wgetrc'-style command.\n"),
 385     "\n",
 386
 387     N_("\
 388 Logging and input file:\n"),
 389     N_("\
 390   -o,  --output-file=FILE    log messages to FILE.\n"),
 391     N_("\
 392   -a,  --append-output=FILE  append messages to FILE.\n"),
 393 #ifdef ENABLE_DEBUG
 394     N_("\
 395   -d,  --debug               print lots of debugging information.\n"),
 396 #endif
 397     N_("\
 398   -q,  --quiet               quiet (no output).\n"),
 399     N_("\
 400   -v,  --verbose             be verbose (this is the default).\n"),
 401     N_("\
 402   -nv, --no-verbose          turn off verboseness, without being quiet.\n"),
 403     N_("\
 404   -i,  --input-file=FILE     download URLs found in FILE.\n"),
 405     N_("\
 406   -F,  --force-html          treat input file as HTML.\n"),
 407     N_("\
 408   -B,  --base=URL            prepends URL to relative links in -F -i file.\n"),
 409     "\n",
 410
 411     N_("\
 412 Download:\n"),
 413     N_("\
 414   -t,  --tries=NUMBER            set number of retries to NUMBER (0 unlimits).\n"),
 415     N_("\
 416        --retry-connrefused       retry even if connection is refused.\n"),
 417     N_("\
 418   -O,  --output-document=FILE    write documents to FILE.\n"),
 419     N_("\
 420   -nc, --no-clobber              skip downloads that would download to\n\
 421                                  existing files.\n"),
 422     N_("\
 423   -c,  --continue                resume getting a partially-downloaded file.\n"),
 424     N_("\
 425        --progress=TYPE           select progress gauge type.\n"),
 426     N_("\
 427   -N,  --timestamping            don't re-retrieve files unless newer than\n\
 428                                  local.\n"),
 429     N_("\
 430   -S,  --server-response         print server response.\n"),
 431     N_("\
 432        --spider                  don't download anything.\n"),
 433     N_("\
 434   -T,  --timeout=SECONDS         set all timeout values to SECONDS.\n"),
 435     N_("\
 436        --dns-timeout=SECS        set the DNS lookup timeout to SECS.\n"),
 437     N_("\
 438        --connect-timeout=SECS    set the connect timeout to SECS.\n"),
 439     N_("\
 440        --read-timeout=SECS       set the read timeout to SECS.\n"),
 441     N_("\
 442   -w,  --wait=SECONDS            wait SECONDS between retrievals.\n"),
 443     N_("\
 444        --waitretry=SECONDS       wait 1..SECONDS between retries of a retrieval.\n"),
 445     N_("\
 446        --random-wait             wait from 0...2*WAIT secs between retrievals.\n"),
 447     N_("\
 448   -Y,  --proxy                   explicitly turn on proxy.\n"),
 449     N_("\
 450        --no-proxy                explicitly turn off proxy.\n"),
 451     N_("\
 452   -Q,  --quota=NUMBER            set retrieval quota to NUMBER.\n"),
 453     N_("\
 454        --bind-address=ADDRESS    bind to ADDRESS (hostname or IP) on local host.\n"),
 455     N_("\
 456        --limit-rate=RATE         limit download rate to RATE.\n"),
 457     N_("\
 458        --no-dns-cache            disable caching DNS lookups.\n"),
 459     N_("\
 460        --restrict-file-names=OS  restrict chars in file names to ones OS allows.\n"),
 461 #ifdef ENABLE_IPV6
 462     N_("\
 463   -4,  --inet4-only              connect only to IPv4 addresses.\n"),
 464     N_("\
 465   -6,  --inet6-only              connect only to IPv6 addresses.\n"),
 466     N_("\
 467        --prefer-family=FAMILY    connect first to addresses of specified family,\n\
 468                                  one of IPv6, IPv4, or none.\n"),
 469 #endif
 470     N_("\
 471        --user=USER               set both ftp and http user to USER.\n"),
 472     N_("\
 473        --password=PASS           set both ftp and http password to PASS.\n"),
 474     "\n",
 475
 476     N_("\
 477 Directories:\n"),
 478     N_("\
 479   -nd, --no-directories           don't create directories.\n"),
 480     N_("\
 481   -x,  --force-directories        force creation of directories.\n"),
 482     N_("\
 483   -nH, --no-host-directories      don't create host directories.\n"),
 484     N_("\
 485        --protocol-directories     use protocol name in directories.\n"),
 486     N_("\
 487   -P,  --directory-prefix=PREFIX  save files to PREFIX/...\n"),
 488     N_("\
 489        --cut-dirs=NUMBER          ignore NUMBER remote directory components.\n"),
 490     "\n",
 491
 492     N_("\
 493 HTTP options:\n"),
 494     N_("\
 495        --http-user=USER        set http user to USER.\n"),
 496     N_("\
 497        --http-password=PASS    set http password to PASS.\n"),
 498     N_("\
 499        --no-cache              disallow server-cached data.\n"),
 500     N_("\
 501   -E,  --html-extension        save HTML documents with `.html' extension.\n"),
 502     N_("\
 503        --ignore-length         ignore `Content-Length' header field.\n"),
 504     N_("\
 505        --header=STRING         insert STRING among the headers.\n"),
 506     N_("\
 507        --proxy-user=USER       set USER as proxy username.\n"),
 508     N_("\
 509        --proxy-password=PASS   set PASS as proxy password.\n"),
 510     N_("\
 511        --referer=URL           include `Referer: URL' header in HTTP request.\n"),
 512     N_("\
 513        --save-headers          save the HTTP headers to file.\n"),
 514     N_("\
 515   -U,  --user-agent=AGENT      identify as AGENT instead of Wget/VERSION.\n"),
 516     N_("\
 517        --no-http-keep-alive    disable HTTP keep-alive (persistent connections).\n"),
 518     N_("\
 519        --no-cookies            don't use cookies.\n"),
 520     N_("\
 521        --load-cookies=FILE     load cookies from FILE before session.\n"),
 522     N_("\
 523        --save-cookies=FILE     save cookies to FILE after session.\n"),
 524     N_("\
 525        --keep-session-cookies  load and save session (non-permanent) cookies.\n"),
 526     N_("\
 527        --post-data=STRING      use the POST method; send STRING as the data.\n"),
 528     N_("\
 529        --post-file=FILE        use the POST method; send contents of FILE.\n"),
 530     "\n",
 531
 532 #ifdef HAVE_SSL
 533     N_("\
 534 HTTPS (SSL/TLS) options:\n"),
 535     N_("\
 536        --secure-protocol=PR     choose secure protocol, one of auto, SSLv2,\n\
 537                                 SSLv3, and TLSv1.\n"),
 538     N_("\
 539        --no-check-certificate   don't validate the server's certificate.\n"),
 540     N_("\
 541        --certificate=FILE       client certificate file.\n"),
 542     N_("\
 543        --certificate-type=TYPE  client certificate type, PEM or DER.\n"),
 544     N_("\
 545        --private-key=FILE       private key file.\n"),
 546     N_("\
 547        --private-key-type=TYPE  private key type, PEM or DER.\n"),
 548     N_("\
 549        --ca-certificate=FILE    file with the bundle of CA's.\n"),
 550     N_("\
 551        --ca-directory=DIR       directory where hash list of CA's is stored.\n"),
 552     N_("\
 553        --random-file=FILE       file with random data for seeding the SSL PRNG.\n"),
 554     N_("\
 555        --egd-file=FILE          file naming the EGD socket with random data.\n"),
 556     "\n",
 557 #endif /* HAVE_SSL */
 558
 559     N_("\
 560 FTP options:\n"),
 561     N_("\
 562        --ftp-user=USER         set ftp user to USER.\n"),
 563     N_("\
 564        --ftp-password=PASS     set ftp password to PASS.\n"),
 565     N_("\
 566        --no-remove-listing     don't remove `.listing' files.\n"),
 567     N_("\
 568        --no-glob               turn off FTP file name globbing.\n"),
 569     N_("\
 570        --no-passive-ftp        disable the \"passive\" transfer mode.\n"),
 571     N_("\
 572        --retr-symlinks         when recursing, get linked-to files (not dir).\n"),
 573     N_("\
 574        --preserve-permissions  preserve remote file permissions.\n"),
 575     "\n",
 576
 577     N_("\
 578 Recursive download:\n"),
 579     N_("\
 580   -r,  --recursive          specify recursive download.\n"),
 581     N_("\
 582   -l,  --level=NUMBER       maximum recursion depth (inf or 0 for infinite).\n"),
 583     N_("\
 584        --delete-after       delete files locally after downloading them.\n"),
 585     N_("\
 586   -k,  --convert-links      make links in downloaded HTML point to local files.\n"),
 587     N_("\
 588   -K,  --backup-converted   before converting file X, back up as X.orig.\n"),
 589     N_("\
 590   -m,  --mirror             shortcut option equivalent to -r -N -l inf -nr.\n"),
 591     N_("\
 592   -p,  --page-requisites    get all images, etc. needed to display HTML page.\n"),
 593     N_("\
 594        --strict-comments    turn on strict (SGML) handling of HTML comments.\n"),
 595     "\n",
 596
 597     N_("\
 598 Recursive accept/reject:\n"),
 599     N_("\
 600   -A,  --accept=LIST               comma-separated list of accepted extensions.\n"),
 601     N_("\
 602   -R,  --reject=LIST               comma-separated list of rejected extensions.\n"),
 603     N_("\
 604   -D,  --domains=LIST              comma-separated list of accepted domains.\n"),
 605     N_("\
 606        --exclude-domains=LIST      comma-separated list of rejected domains.\n"),
 607     N_("\
 608        --follow-ftp                follow FTP links from HTML documents.\n"),
 609     N_("\
 610        --follow-tags=LIST          comma-separated list of followed HTML tags.\n"),
 611     N_("\
 612        --ignore-tags=LIST          comma-separated list of ignored HTML tags.\n"),
 613     N_("\
 614   -H,  --span-hosts                go to foreign hosts when recursive.\n"),
 615     N_("\
 616   -L,  --relative                  follow relative links only.\n"),
 617     N_("\
 618   -I,  --include-directories=LIST  list of allowed directories.\n"),
 619     N_("\
 620   -X,  --exclude-directories=LIST  list of excluded directories.\n"),
 621     N_("\
 622   -np, --no-parent                 don't ascend to the parent directory.\n"),
 623     "\n",
 624
 625     N_("Mail bug reports and suggestions to <bug-wget@gnu.org>.\n")
 626   };
 627
 628   int i;
 629
 630   printf (_("GNU Wget %s, a non-interactive network retriever.\n"),
 631           version_string);
 632   print_usage ();
 633
 634   for (i = 0; i < countof (help); i++)
 635     fputs (_(help[i]), stdout);
 636
 637   exit (0);
 638 }
 639
 640 /* Return a human-readable printed representation of INTERVAL,
 641    measured in seconds.  */
 642
 643 static char *
 644 secs_to_human_time (double interval)
 645 {
 646   static char buf[32];
 647   int secs = (int) (interval + 0.5);
 648   int hours, mins, days;
 649
 650   days = secs / 86400, secs %= 86400;
 651   hours = secs / 3600, secs %= 3600;
 652   mins = secs / 60, secs %= 60;
 653
 654   if (days)
 655     sprintf (buf, "%dd %dh %dm %ds", days, hours, mins, secs);
 656   else if (hours)
 657     sprintf (buf, "%dh %dm %ds", hours, mins, secs);
 658   else if (mins)
 659     sprintf (buf, "%dm %ds", mins, secs);
 660   else if (interval >= 10)
 661     sprintf (buf, "%ds", secs);
 662   else
 663     /* For very quick downloads show more exact timing information. */
 664     sprintf (buf, "%.*fs",
 665              interval < 0.001 ? 0 : /* 0s instead of 0.000s */
 666              interval < 0.01 ? 3 :  /* 0.00x */
 667              interval < 0.1 ? 2 :   /* 0.0x */
 668              1,                     /* 0.x, 1.x, ..., 9.x */
 669              interval);
 670
 671   return buf;
 672 }
 673
 674 static void
 675 print_version (void)
 676 {
 677   printf ("GNU Wget %s\n\n", version_string);
 678   fputs (_("\
 679 Copyright (C) 2005 Free Software Foundation, Inc.\n"), stdout);
 680   fputs (_("\
 681 This program is distributed in the hope that it will be useful,\n\
 682 but WITHOUT ANY WARRANTY; without even the implied warranty of\n\
 683 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n\
 684 GNU General Public License for more details.\n"), stdout);
 685   fputs (_("\nOriginally written by Hrvoje Niksic <hniksic@xemacs.org>.\n"),
 686          stdout);
 687   exit (0);
 688 }
 689 \f
 690 int
 691 main (int argc, char *const *argv)
 692 {
 693   char **url, **t;
 694   int i, ret, longindex;
 695   int nurl, status;
 696   bool append_to_log = false;
 697
 698   i18n_initialize ();
 699
 700   /* Construct the name of the executable, without the directory part.  */
 701   exec_name = strrchr (argv[0], PATH_SEPARATOR);
 702   if (!exec_name)
 703     exec_name = argv[0];
 704   else
 705     ++exec_name;
 706
 707 #ifdef WINDOWS
 708   /* Drop extension (typically .EXE) from executable filename. */
 709   windows_main (&argc, (char **) argv, (char **) &exec_name);
 710 #endif
 711
 712   /* Set option defaults; read the system wgetrc and ~/.wgetrc.  */
 713   initialize ();
 714
 715   init_switches ();
 716   longindex = -1;
 717   while ((ret = getopt_long (argc, argv,
 718                              short_options, long_options, &longindex)) != -1)
 719     {
 720       int val;
 721       struct cmdline_option *opt;
 722
 723       /* If LONGINDEX is unchanged, it means RET is referring a short
 724          option.  */
 725       if (longindex == -1)
 726         {
 727           if (ret == '?')
 728             {
 729               print_usage ();
 730               printf ("\n");
 731               printf (_("Try `%s --help' for more options.\n"), exec_name);
 732               exit (2);
 733             }
 734           /* Find the short option character in the mapping.  */
 735           longindex = optmap[ret - 32];
 736         }
 737       val = long_options[longindex].val;
 738
 739       /* Use the retrieved value to locate the option in the
 740          option_data array, and to see if we're dealing with the
 741          negated "--no-FOO" variant of the boolean option "--foo".  */
 742       opt = &option_data[val & ~BOOLEAN_NEG_MARKER];
 743       switch (opt->type)
 744         {
 745         case OPT_VALUE:
 746           setoptval (opt->data, optarg, opt->long_name);
 747           break;
 748         case OPT_BOOLEAN:
 749           if (optarg)
 750             /* The user has specified a value -- use it. */
 751             setoptval (opt->data, optarg, opt->long_name);
 752           else
 753             {
 754               /* NEG is true for `--no-FOO' style boolean options. */
 755               bool neg = !!(val & BOOLEAN_NEG_MARKER);
 756               setoptval (opt->data, neg ? "0" : "1", opt->long_name);
 757             }
 758           break;
 759         case OPT_FUNCALL:
 760           {
 761             void (*func) (void) = (void (*) (void)) opt->data;
 762             func ();
 763           }
 764           break;
 765         case OPT__APPEND_OUTPUT:
 766           setoptval ("logfile", optarg, opt->long_name);
 767           append_to_log = true;
 768           break;
 769         case OPT__EXECUTE:
 770           run_command (optarg);
 771           break;
 772         case OPT__NO:
 773           {
 774             /* We support real --no-FOO flags now, but keep these
 775                short options for convenience and backward
 776                compatibility.  */
 777             char *p;
 778             for (p = optarg; *p; p++)
 779               switch (*p)
 780                 {
 781                 case 'v':
 782                   setoptval ("verbose", "0", opt->long_name);
 783                   break;
 784                 case 'H':
 785                   setoptval ("addhostdir", "0", opt->long_name);
 786                   break;
 787                 case 'd':
 788                   setoptval ("dirstruct", "0", opt->long_name);
 789                   break;
 790                 case 'c':
 791                   setoptval ("noclobber", "1", opt->long_name);
 792                   break;
 793                 case 'p':
 794                   setoptval ("noparent", "1", opt->long_name);
 795                   break;
 796                 default:
 797                   printf (_("%s: illegal option -- `-n%c'\n"), exec_name, *p);
 798                   print_usage ();
 799                   printf ("\n");
 800                   printf (_("Try `%s --help' for more options.\n"), exec_name);
 801                   exit (1);
 802                 }
 803             break;
 804           }
 805         case OPT__PARENT:
 806         case OPT__CLOBBER:
 807           {
 808             /* The wgetrc commands are named noparent and noclobber,
 809                so we must revert the meaning of the cmdline options
 810                before passing the value to setoptval.  */
 811             bool flag = true;
 812             if (optarg)
 813               flag = (*optarg == '1' || TOLOWER (*optarg) == 'y'
 814                       || (TOLOWER (optarg[0]) == 'o'
 815                           && TOLOWER (optarg[1]) == 'n'));
 816             setoptval (opt->type == OPT__PARENT ? "noparent" : "noclobber",
 817                        flag ? "0" : "1", opt->long_name);
 818             break;
 819           }
 820         case OPT__DONT_REMOVE_LISTING:
 821           setoptval ("removelisting", "0", opt->long_name);
 822           break;
 823         }
 824
 825       longindex = -1;
 826     }
 827
 828   /* All user options have now been processed, so it's now safe to do
 829      interoption dependency checks. */
 830
 831   if (opt.reclevel == 0)
 832     opt.reclevel = INFINITE_RECURSION; /* see recur.h for commentary on this */
 833
 834   if (opt.page_requisites && !opt.recursive)
 835     {
 836       /* Don't set opt.recursive here because it would confuse the FTP
 837          code.  Instead, call retrieve_tree below when either
 838          page_requisites or recursive is requested.  */
 839       opt.reclevel = 0;
 840       if (!opt.no_dirstruct)
 841         opt.dirstruct = 1;      /* normally handled by cmd_spec_recursive() */
 842     }
 843
 844   if (opt.verbose == -1)
 845     opt.verbose = !opt.quiet;
 846
 847   /* Sanity checks.  */
 848   if (opt.verbose && opt.quiet)
 849     {
 850       printf (_("Can't be verbose and quiet at the same time.\n"));
 851       print_usage ();
 852       exit (1);
 853     }
 854   if (opt.timestamping && opt.noclobber)
 855     {
 856       printf (_("\
 857 Can't timestamp and not clobber old files at the same time.\n"));
 858       print_usage ();
 859       exit (1);
 860     }
 861 #ifdef ENABLE_IPV6
 862   if (opt.ipv4_only && opt.ipv6_only)
 863     {
 864       printf (_("Cannot specify both --inet4-only and --inet6-only.\n"));
 865       print_usage ();
 866       exit (1);
 867     }
 868 #endif
 869
 870   nurl = argc - optind;
 871   if (!nurl && !opt.input_filename)
 872     {
 873       /* No URL specified.  */
 874       printf (_("%s: missing URL\n"), exec_name);
 875       print_usage ();
 876       printf ("\n");
 877       /* #### Something nicer should be printed here -- similar to the
 878          pre-1.5 `--help' page.  */
 879       printf (_("Try `%s --help' for more options.\n"), exec_name);
 880       exit (1);
 881     }
 882
 883   if (opt.background)
 884     fork_to_background ();
 885
 886   /* Initialize progress.  Have to do this after the options are
 887      processed so we know where the log file is.  */
 888   if (opt.verbose)
 889     set_progress_implementation (opt.progress_type);
 890
 891   /* Fill in the arguments.  */
 892   url = alloca_array (char *, nurl + 1);
 893   for (i = 0; i < nurl; i++, optind++)
 894     {
 895       char *rewritten = rewrite_shorthand_url (argv[optind]);
 896       if (rewritten)
 897         url[i] = rewritten;
 898       else
 899         url[i] = xstrdup (argv[optind]);
 900     }
 901   url[i] = NULL;
 902
 903   /* Initialize logging.  */
 904   log_init (opt.lfilename, append_to_log);
 905
 906   DEBUGP (("DEBUG output created by Wget %s on %s.\n\n", version_string,
 907            OS_TYPE));
 908
 909   /* Open the output filename if necessary.  */
 910   if (opt.output_document)
 911     {
 912       extern FILE *output_stream;
 913       extern bool output_stream_regular;
 914
 915       if (HYPHENP (opt.output_document))
 916         output_stream = stdout;
 917       else
 918         {
 919           struct_fstat st;
 920           output_stream = fopen (opt.output_document,
 921                                  opt.always_rest ? "ab" : "wb");
 922           if (output_stream == NULL)
 923             {
 924               perror (opt.output_document);
 925               exit (1);
 926             }
 927           if (fstat (fileno (output_stream), &st) == 0 && S_ISREG (st.st_mode))
 928             output_stream_regular = true;
 929         }
 930     }
 931
 932 #ifdef WINDOWS
 933   ws_startup ();
 934 #endif
 935
 936 #ifdef SIGHUP
 937   /* Setup the signal handler to redirect output when hangup is
 938      received.  */
 939   if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
 940     signal(SIGHUP, redirect_output_signal);
 941 #endif
 942   /* ...and do the same for SIGUSR1.  */
 943 #ifdef SIGUSR1
 944   signal (SIGUSR1, redirect_output_signal);
 945 #endif
 946 #ifdef SIGPIPE
 947   /* Writing to a closed socket normally signals SIGPIPE, and the
 948      process exits.  What we want is to ignore SIGPIPE and just check
 949      for the return value of write().  */
 950   signal (SIGPIPE, SIG_IGN);
 951 #endif
 952 #ifdef SIGWINCH
 953   signal (SIGWINCH, progress_handle_sigwinch);
 954 #endif
 955
 956   status = RETROK;              /* initialize it, just-in-case */
 957   /* Retrieve the URLs from argument list.  */
 958   for (t = url; *t; t++)
 959     {
 960       char *filename = NULL, *redirected_URL = NULL;
 961       int dt;
 962
 963       if ((opt.recursive || opt.page_requisites)
 964           && url_scheme (*t) != SCHEME_FTP)
 965         status = retrieve_tree (*t);
 966       else
 967         status = retrieve_url (*t, &filename, &redirected_URL, NULL, &dt);
 968
 969       if (opt.delete_after && file_exists_p(filename))
 970         {
 971           DEBUGP (("Removing file due to --delete-after in main():\n"));
 972           logprintf (LOG_VERBOSE, _("Removing %s.\n"), filename);
 973           if (unlink (filename))
 974             logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
 975         }
 976
 977       xfree_null (redirected_URL);
 978       xfree_null (filename);
 979     }
 980
 981   /* And then from the input file, if any.  */
 982   if (opt.input_filename)
 983     {
 984       int count;
 985       status = retrieve_from_file (opt.input_filename, opt.force_html, &count);
 986       if (!count)
 987         logprintf (LOG_NOTQUIET, _("No URLs found in %s.\n"),
 988                    opt.input_filename);
 989     }
 990   /* Print the downloaded sum.  */
 991   if (opt.recursive || opt.page_requisites
 992       || nurl > 1
 993       || (opt.input_filename && total_downloaded_bytes != 0))
 994     {
 995       logprintf (LOG_NOTQUIET,
 996                  _("FINISHED --%s--\nDownloaded: %d files, %s in %s (%s)\n"),
 997                  time_str (NULL),
 998                  opt.numurls,
 999                  human_readable (total_downloaded_bytes),
1000                  secs_to_human_time (total_download_time / 1000),
1001                  retr_rate (total_downloaded_bytes, total_download_time));
1002       /* Print quota warning, if exceeded.  */
1003       if (opt.quota && total_downloaded_bytes > opt.quota)
1004         logprintf (LOG_NOTQUIET,
1005                    _("Download quota of %s EXCEEDED!\n"),
1006                    human_readable (opt.quota));
1007     }
1008
1009   if (opt.cookies_output)
1010     save_cookies ();
1011
1012   if (opt.convert_links && !opt.delete_after)
1013     convert_all_links ();
1014
1015   log_close ();
1016   for (i = 0; i < nurl; i++)
1017     xfree (url[i]);
1018   cleanup ();
1019
1020 #ifdef DEBUG_MALLOC
1021   print_malloc_debug_stats ();
1022 #endif
1023   if (status == RETROK)
1024     return 0;
1025   else
1026     return 1;
1027 }
1028 \f
1029 #if defined(SIGHUP) || defined(SIGUSR1)
1030 /* Hangup signal handler.  When wget receives SIGHUP or SIGUSR1, it
1031    will proceed operation as usual, trying to write into a log file.
1032    If that is impossible, the output will be turned off.  */
1033
1034 static void
1035 redirect_output_signal (int sig)
1036 {
1037   const char *signal_name = (sig == SIGHUP ? "SIGHUP" :
1038                              (sig == SIGUSR1 ? "SIGUSR1" :
1039                               "WTF?!"));
1040   log_request_redirect_output (signal_name);
1041   progress_schedule_redirect ();
1042   signal (sig, redirect_output_signal);
1043 }
1044 #endif