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

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