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

   1 /* Reading/parsing the initialization file.
   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
  38 #include <string.h>
  39 #include <errno.h>
  40 #include <limits.h>
  41 /* not all systems provide PATH_MAX in limits.h */
  42 #ifndef PATH_MAX
  43 # include <sys/param.h>
  44 # ifndef PATH_MAX
  45 #  define PATH_MAX MAXPATHLEN
  46 # endif
  47 #endif
  48
  49
  50 #ifdef HAVE_PWD_H
  51 # include <pwd.h>
  52 #endif
  53 #include <assert.h>
  54
  55 #include "utils.h"
  56 #include "init.h"
  57 #include "host.h"
  58 #include "netrc.h"
  59 #include "progress.h"
  60 #include "recur.h"              /* for INFINITE_RECURSION */
  61 #include "convert.h"            /* for convert_cleanup */
  62 #include "res.h"                /* for res_cleanup */
  63 #include "http.h"               /* for http_cleanup */
  64 #include "retr.h"               /* for output_stream */
  65
  66 #ifdef TESTING
  67 #include "test.h"
  68 #endif
  69
  70
  71
  72 #define CMD_DECLARE(func) static bool func (const char *, const char *, void *)
  73
  74 CMD_DECLARE (cmd_boolean);
  75 CMD_DECLARE (cmd_bytes);
  76 CMD_DECLARE (cmd_bytes_sum);
  77 #ifdef HAVE_SSL
  78 CMD_DECLARE (cmd_cert_type);
  79 #endif
  80 CMD_DECLARE (cmd_directory_vector);
  81 CMD_DECLARE (cmd_number);
  82 CMD_DECLARE (cmd_number_inf);
  83 CMD_DECLARE (cmd_string);
  84 CMD_DECLARE (cmd_file);
  85 CMD_DECLARE (cmd_directory);
  86 CMD_DECLARE (cmd_time);
  87 CMD_DECLARE (cmd_vector);
  88
  89 CMD_DECLARE (cmd_spec_dirstruct);
  90 CMD_DECLARE (cmd_spec_header);
  91 CMD_DECLARE (cmd_spec_htmlify);
  92 CMD_DECLARE (cmd_spec_mirror);
  93 CMD_DECLARE (cmd_spec_prefer_family);
  94 CMD_DECLARE (cmd_spec_progress);
  95 CMD_DECLARE (cmd_spec_recursive);
  96 CMD_DECLARE (cmd_spec_restrict_file_names);
  97 #ifdef HAVE_SSL
  98 CMD_DECLARE (cmd_spec_secure_protocol);
  99 #endif
 100 CMD_DECLARE (cmd_spec_timeout);
 101 CMD_DECLARE (cmd_spec_useragent);
 102 CMD_DECLARE (cmd_spec_verbose);
 103
 104 /* List of recognized commands, each consisting of name, place and
 105    function.  When adding a new command, simply add it to the list,
 106    but be sure to keep the list sorted alphabetically, as
 107    command_by_name's binary search depends on it.  Also, be sure to
 108    add any entries that allocate memory (e.g. cmd_string and
 109    cmd_vector) to the cleanup() function below. */
 110
 111 static const struct {
 112   const char *name;
 113   void *place;
 114   bool (*action) (const char *, const char *, void *);
 115 } commands[] = {
 116   /* KEEP THIS LIST ALPHABETICALLY SORTED */
 117   { "accept",           &opt.accepts,           cmd_vector },
 118   { "addhostdir",       &opt.add_hostdir,       cmd_boolean },
 119   { "adjustextension",  &opt.adjust_extension,  cmd_boolean },
 120   { "alwaysrest",       &opt.always_rest,       cmd_boolean }, /* deprecated */
 121   { "askpassword",      &opt.ask_passwd,        cmd_boolean },
 122   { "authnochallenge",  &opt.auth_without_challenge,
 123                                                 cmd_boolean },
 124   { "background",       &opt.background,        cmd_boolean },
 125   { "backupconverted",  &opt.backup_converted,  cmd_boolean },
 126   { "backups",          &opt.backups,           cmd_number },
 127   { "base",             &opt.base_href,         cmd_string },
 128   { "bindaddress",      &opt.bind_address,      cmd_string },
 129 #ifdef HAVE_SSL
 130   { "cacertificate",    &opt.ca_cert,           cmd_file },
 131 #endif
 132   { "cache",            &opt.allow_cache,       cmd_boolean },
 133 #ifdef HAVE_SSL
 134   { "cadirectory",      &opt.ca_directory,      cmd_directory },
 135   { "certificate",      &opt.cert_file,         cmd_file },
 136   { "certificatetype",  &opt.cert_type,         cmd_cert_type },
 137   { "checkcertificate", &opt.check_cert,        cmd_boolean },
 138 #endif
 139   { "connecttimeout",   &opt.connect_timeout,   cmd_time },
 140   { "contentdisposition", &opt.content_disposition, cmd_boolean },
 141   { "continue",         &opt.always_rest,       cmd_boolean },
 142   { "convertlinks",     &opt.convert_links,     cmd_boolean },
 143   { "cookies",          &opt.cookies,           cmd_boolean },
 144   { "cutdirs",          &opt.cut_dirs,          cmd_number },
 145 #ifdef ENABLE_DEBUG
 146   { "debug",            &opt.debug,             cmd_boolean },
 147 #endif
 148   { "defaultpage",      &opt.default_page,      cmd_string},
 149   { "deleteafter",      &opt.delete_after,      cmd_boolean },
 150   { "dirprefix",        &opt.dir_prefix,        cmd_directory },
 151   { "dirstruct",        NULL,                   cmd_spec_dirstruct },
 152   { "dnscache",         &opt.dns_cache,         cmd_boolean },
 153   { "dnstimeout",       &opt.dns_timeout,       cmd_time },
 154   { "domains",          &opt.domains,           cmd_vector },
 155   { "dotbytes",         &opt.dot_bytes,         cmd_bytes },
 156   { "dotsinline",       &opt.dots_in_line,      cmd_number },
 157   { "dotspacing",       &opt.dot_spacing,       cmd_number },
 158   { "dotstyle",         &opt.dot_style,         cmd_string }, /* deprecated */
 159 #ifdef HAVE_SSL
 160   { "egdfile",          &opt.egd_file,          cmd_file },
 161 #endif
 162   { "excludedirectories", &opt.excludes,        cmd_directory_vector },
 163   { "excludedomains",   &opt.exclude_domains,   cmd_vector },
 164   { "followftp",        &opt.follow_ftp,        cmd_boolean },
 165   { "followtags",       &opt.follow_tags,       cmd_vector },
 166   { "forcehtml",        &opt.force_html,        cmd_boolean },
 167   { "ftppasswd",        &opt.ftp_passwd,        cmd_string }, /* deprecated */
 168   { "ftppassword",      &opt.ftp_passwd,        cmd_string },
 169   { "ftpproxy",         &opt.ftp_proxy,         cmd_string },
 170 #ifdef __VMS
 171   { "ftpstmlf",         &opt.ftp_stmlf,         cmd_boolean },
 172 #endif /* def __VMS */
 173   { "ftpuser",          &opt.ftp_user,          cmd_string },
 174   { "glob",             &opt.ftp_glob,          cmd_boolean },
 175   { "header",           NULL,                   cmd_spec_header },
 176   { "htmlextension",    &opt.adjust_extension,  cmd_boolean }, /* deprecated */
 177   { "htmlify",          NULL,                   cmd_spec_htmlify },
 178   { "httpkeepalive",    &opt.http_keep_alive,   cmd_boolean },
 179   { "httppasswd",       &opt.http_passwd,       cmd_string }, /* deprecated */
 180   { "httppassword",     &opt.http_passwd,       cmd_string },
 181   { "httpproxy",        &opt.http_proxy,        cmd_string },
 182   { "httpsproxy",       &opt.https_proxy,       cmd_string },
 183   { "httpuser",         &opt.http_user,         cmd_string },
 184   { "ignorecase",       &opt.ignore_case,       cmd_boolean },
 185   { "ignorelength",     &opt.ignore_length,     cmd_boolean },
 186   { "ignoretags",       &opt.ignore_tags,       cmd_vector },
 187   { "includedirectories", &opt.includes,        cmd_directory_vector },
 188 #ifdef ENABLE_IPV6
 189   { "inet4only",        &opt.ipv4_only,         cmd_boolean },
 190   { "inet6only",        &opt.ipv6_only,         cmd_boolean },
 191 #endif
 192   { "input",            &opt.input_filename,    cmd_file },
 193   { "iri",              &opt.enable_iri,        cmd_boolean },
 194   { "keepsessioncookies", &opt.keep_session_cookies, cmd_boolean },
 195   { "limitrate",        &opt.limit_rate,        cmd_bytes },
 196   { "loadcookies",      &opt.cookies_input,     cmd_file },
 197   { "localencoding",    &opt.locale,            cmd_string },
 198   { "logfile",          &opt.lfilename,         cmd_file },
 199   { "login",            &opt.ftp_user,          cmd_string },/* deprecated*/
 200   { "maxredirect",      &opt.max_redirect,      cmd_number },
 201   { "mirror",           NULL,                   cmd_spec_mirror },
 202   { "netrc",            &opt.netrc,             cmd_boolean },
 203   { "noclobber",        &opt.noclobber,         cmd_boolean },
 204   { "noparent",         &opt.no_parent,         cmd_boolean },
 205   { "noproxy",          &opt.no_proxy,          cmd_vector },
 206   { "numtries",         &opt.ntry,              cmd_number_inf },/* deprecated*/
 207   { "outputdocument",   &opt.output_document,   cmd_file },
 208   { "pagerequisites",   &opt.page_requisites,   cmd_boolean },
 209   { "passiveftp",       &opt.ftp_pasv,          cmd_boolean },
 210   { "passwd",           &opt.ftp_passwd,        cmd_string },/* deprecated*/
 211   { "password",         &opt.passwd,            cmd_string },
 212   { "postdata",         &opt.post_data,         cmd_string },
 213   { "postfile",         &opt.post_file_name,    cmd_file },
 214   { "preferfamily",     NULL,                   cmd_spec_prefer_family },
 215   { "preservepermissions", &opt.preserve_perm,  cmd_boolean },/* deprecated */
 216 #ifdef HAVE_SSL
 217   { "privatekey",       &opt.private_key,       cmd_file },
 218   { "privatekeytype",   &opt.private_key_type,  cmd_cert_type },
 219 #endif
 220   { "progress",         &opt.progress_type,     cmd_spec_progress },
 221   { "protocoldirectories", &opt.protocol_directories, cmd_boolean },
 222   { "proxypasswd",      &opt.proxy_passwd,      cmd_string }, /* deprecated */
 223   { "proxypassword",    &opt.proxy_passwd,      cmd_string },
 224   { "proxyuser",        &opt.proxy_user,        cmd_string },
 225   { "quiet",            &opt.quiet,             cmd_boolean },
 226   { "quota",            &opt.quota,             cmd_bytes_sum },
 227 #ifdef HAVE_SSL
 228   { "randomfile",       &opt.random_file,       cmd_file },
 229 #endif
 230   { "randomwait",       &opt.random_wait,       cmd_boolean },
 231   { "readtimeout",      &opt.read_timeout,      cmd_time },
 232   { "reclevel",         &opt.reclevel,          cmd_number_inf },
 233   { "recursive",        NULL,                   cmd_spec_recursive },
 234   { "referer",          &opt.referer,           cmd_string },
 235   { "reject",           &opt.rejects,           cmd_vector },
 236   { "relativeonly",     &opt.relative_only,     cmd_boolean },
 237   { "remoteencoding",   &opt.encoding_remote,   cmd_string },
 238   { "removelisting",    &opt.remove_listing,    cmd_boolean },
 239   { "restrictfilenames", NULL,                  cmd_spec_restrict_file_names },
 240   { "retrsymlinks",     &opt.retr_symlinks,     cmd_boolean },
 241   { "retryconnrefused", &opt.retry_connrefused, cmd_boolean },
 242   { "robots",           &opt.use_robots,        cmd_boolean },
 243   { "savecookies",      &opt.cookies_output,    cmd_file },
 244   { "saveheaders",      &opt.save_headers,      cmd_boolean },
 245 #ifdef HAVE_SSL
 246   { "secureprotocol",   &opt.secure_protocol,   cmd_spec_secure_protocol },
 247 #endif
 248   { "serverresponse",   &opt.server_response,   cmd_boolean },
 249   { "spanhosts",        &opt.spanhost,          cmd_boolean },
 250   { "spider",           &opt.spider,            cmd_boolean },
 251   { "strictcomments",   &opt.strict_comments,   cmd_boolean },
 252   { "timeout",          NULL,                   cmd_spec_timeout },
 253   { "timestamping",     &opt.timestamping,      cmd_boolean },
 254   { "tries",            &opt.ntry,              cmd_number_inf },
 255   { "useproxy",         &opt.use_proxy,         cmd_boolean },
 256   { "user",             &opt.user,              cmd_string },
 257   { "useragent",        NULL,                   cmd_spec_useragent },
 258   { "verbose",          NULL,                   cmd_spec_verbose },
 259   { "wait",             &opt.wait,              cmd_time },
 260   { "waitretry",        &opt.waitretry,         cmd_time },
 261 #ifdef USE_WATT32
 262   { "wdebug",           &opt.wdebug,            cmd_boolean },
 263 #endif
 264 };
 265
 266 /* Look up CMDNAME in the commands[] and return its position in the
 267    array.  If CMDNAME is not found, return -1.  */
 268
 269 static int
 270 command_by_name (const char *cmdname)
 271 {
 272   /* Use binary search for speed.  Wget has ~100 commands, which
 273      guarantees a worst case performance of 7 string comparisons.  */
 274   int lo = 0, hi = countof (commands) - 1;
 275
 276   while (lo <= hi)
 277     {
 278       int mid = (lo + hi) >> 1;
 279       int cmp = strcasecmp (cmdname, commands[mid].name);
 280       if (cmp < 0)
 281         hi = mid - 1;
 282       else if (cmp > 0)
 283         lo = mid + 1;
 284       else
 285         return mid;
 286     }
 287   return -1;
 288 }
 289 \f
 290 /* Reset the variables to default values.  */
 291 static void
 292 defaults (void)
 293 {
 294   char *tmp;
 295
 296   /* Most of the default values are 0 (and 0.0, NULL, and false).
 297      Just reset everything, and fill in the non-zero values.  Note
 298      that initializing pointers to NULL this way is technically
 299      illegal, but porting Wget to a machine where NULL is not all-zero
 300      bit pattern will be the least of the implementors' worries.  */
 301   xzero (opt);
 302
 303   opt.cookies = true;
 304   opt.verbose = -1;
 305   opt.ntry = 20;
 306   opt.reclevel = 5;
 307   opt.add_hostdir = true;
 308   opt.netrc = true;
 309   opt.ftp_glob = true;
 310   opt.htmlify = true;
 311   opt.http_keep_alive = true;
 312   opt.use_proxy = true;
 313   tmp = getenv ("no_proxy");
 314   if (tmp)
 315     opt.no_proxy = sepstring (tmp);
 316   opt.prefer_family = prefer_none;
 317   opt.allow_cache = true;
 318
 319   opt.read_timeout = 900;
 320   opt.use_robots = true;
 321
 322   opt.remove_listing = true;
 323
 324   opt.dot_bytes = 1024;
 325   opt.dot_spacing = 10;
 326   opt.dots_in_line = 50;
 327
 328   opt.dns_cache = true;
 329   opt.ftp_pasv = true;
 330
 331 #ifdef HAVE_SSL
 332   opt.check_cert = true;
 333 #endif
 334
 335   /* The default for file name restriction defaults to the OS type. */
 336 #if defined(WINDOWS) || defined(MSDOS) || defined(__CYGWIN__)
 337   opt.restrict_files_os = restrict_windows;
 338 #else
 339   opt.restrict_files_os = restrict_unix;
 340 #endif
 341   opt.restrict_files_ctrl = true;
 342   opt.restrict_files_nonascii = false;
 343   opt.restrict_files_case = restrict_no_case_restriction;
 344
 345   opt.max_redirect = 20;
 346
 347   opt.waitretry = 10;
 348
 349 #ifdef ENABLE_IRI
 350   opt.enable_iri = true;
 351 #else
 352   opt.enable_iri = false;
 353 #endif
 354   opt.locale = NULL;
 355   opt.encoding_remote = NULL;
 356 }
 357 \f
 358 /* Return the user's home directory (strdup-ed), or NULL if none is
 359    found.  */
 360 char *
 361 home_dir (void)
 362 {
 363   static char buf[PATH_MAX];
 364   static char *home;
 365
 366   if (!home)
 367     {
 368       home = getenv ("HOME");
 369       if (!home)
 370         {
 371 #if defined(MSDOS)
 372           /* Under MSDOS, if $HOME isn't defined, use the directory where
 373              `wget.exe' resides.  */
 374           const char *_w32_get_argv0 (void); /* in libwatt.a/pcconfig.c */
 375           char *p;
 376
 377           strcpy (buf, _w32_get_argv0 ());
 378           p = strrchr (buf, '/');            /* djgpp */
 379           if (!p)
 380             p = strrchr (buf, '\\');          /* others */
 381           assert (p);
 382           *p = '\0';
 383           home = buf;
 384 #elif !defined(WINDOWS)
 385           /* If HOME is not defined, try getting it from the password
 386              file.  */
 387           struct passwd *pwd = getpwuid (getuid ());
 388           if (!pwd || !pwd->pw_dir)
 389             return NULL;
 390           strcpy (buf, pwd->pw_dir);
 391           home = buf;
 392 #else  /* !WINDOWS */
 393           /* Under Windows, if $HOME isn't defined, use the directory where
 394              `wget.exe' resides.  */
 395           home = ws_mypath ();
 396 #endif /* WINDOWS */
 397         }
 398     }
 399
 400   return home ? xstrdup (home) : NULL;
 401 }
 402
 403 /* Check the 'WGETRC' environment variable and return the file name
 404    if  'WGETRC' is set and is a valid file.
 405    If the `WGETRC' variable exists but the file does not exist, the
 406    function will exit().  */
 407 char *
 408 wgetrc_env_file_name (void)
 409 {
 410   char *env = getenv ("WGETRC");
 411   if (env && *env)
 412     {
 413       if (!file_exists_p (env))
 414         {
 415           fprintf (stderr, _("%s: WGETRC points to %s, which doesn't exist.\n"),
 416                    exec_name, env);
 417           exit (1);
 418         }
 419       return xstrdup (env);
 420     }
 421   return NULL;
 422 }
 423
 424 /* Check for the existance of '$HOME/.wgetrc' and return it's path
 425    if it exists and is set.  */
 426 char *
 427 wgetrc_user_file_name (void)
 428 {
 429   char *home = home_dir ();
 430   char *file = NULL;
 431   /* If that failed, try $HOME/.wgetrc (or equivalent).  */
 432
 433 #ifdef __VMS
 434   file = "SYS$LOGIN:.wgetrc";
 435 #else /* def __VMS */
 436   home = home_dir ();
 437   if (home)
 438     file = aprintf ("%s/.wgetrc", home);
 439   xfree_null (home);
 440 #endif /* def __VMS [else] */
 441
 442   if (!file)
 443     return NULL;
 444   if (!file_exists_p (file))
 445     {
 446       xfree (file);
 447       return NULL;
 448     }
 449   return file;
 450 }
 451
 452 /* Return the path to the user's .wgetrc.  This is either the value of
 453    `WGETRC' environment variable, or `$HOME/.wgetrc'.
 454
 455    Additionally, for windows, look in the directory where wget.exe
 456    resides.  */
 457 char *
 458 wgetrc_file_name (void)
 459 {
 460   char *file = wgetrc_env_file_name ();
 461   if (file && *file)
 462     return file;
 463
 464   file = wgetrc_user_file_name ();
 465
 466 #ifdef WINDOWS
 467   /* Under Windows, if we still haven't found .wgetrc, look for the file
 468      `wget.ini' in the directory where `wget.exe' resides; we do this for
 469      backward compatibility with previous versions of Wget.
 470      SYSTEM_WGETRC should not be defined under WINDOWS.  */
 471   if (!file)
 472     {
 473       char *home = home_dir ();
 474       xfree_null (file);
 475       file = NULL;
 476       home = ws_mypath ();
 477       if (home)
 478         {
 479           file = aprintf ("%s/wget.ini", home);
 480           if (!file_exists_p (file))
 481             {
 482               xfree (file);
 483               file = NULL;
 484             }
 485           xfree (home);
 486         }
 487     }
 488 #endif /* WINDOWS */
 489
 490   return file;
 491 }
 492
 493 /* Return values of parse_line. */
 494 enum parse_line {
 495   line_ok,
 496   line_empty,
 497   line_syntax_error,
 498   line_unknown_command
 499 };
 500
 501 static enum parse_line parse_line (const char *, char **, char **, int *);
 502 static bool setval_internal (int, const char *, const char *);
 503 static bool setval_internal_tilde (int, const char *, const char *);
 504
 505 /* Initialize variables from a wgetrc file.  Returns zero (failure) if
 506    there were errors in the file.  */
 507
 508 static bool
 509 run_wgetrc (const char *file)
 510 {
 511   FILE *fp;
 512   char *line;
 513   int ln;
 514   int errcnt = 0;
 515
 516   fp = fopen (file, "r");
 517   if (!fp)
 518     {
 519       fprintf (stderr, _("%s: Cannot read %s (%s).\n"), exec_name,
 520                file, strerror (errno));
 521       return true;                      /* not a fatal error */
 522     }
 523   ln = 1;
 524   while ((line = read_whole_line (fp)) != NULL)
 525     {
 526       char *com = NULL, *val = NULL;
 527       int comind;
 528
 529       /* Parse the line.  */
 530       switch (parse_line (line, &com, &val, &comind))
 531         {
 532         case line_ok:
 533           /* If everything is OK, set the value.  */
 534           if (!setval_internal_tilde (comind, com, val))
 535             {
 536               fprintf (stderr, _("%s: Error in %s at line %d.\n"),
 537                        exec_name, file, ln);
 538               ++errcnt;
 539             }
 540           break;
 541         case line_syntax_error:
 542           fprintf (stderr, _("%s: Syntax error in %s at line %d.\n"),
 543                    exec_name, file, ln);
 544           ++errcnt;
 545           break;
 546         case line_unknown_command:
 547           fprintf (stderr, _("%s: Unknown command %s in %s at line %d.\n"),
 548                    exec_name, quote (com), file, ln);
 549           ++errcnt;
 550           break;
 551         case line_empty:
 552           break;
 553         default:
 554           abort ();
 555         }
 556       xfree_null (com);
 557       xfree_null (val);
 558       xfree (line);
 559       ++ln;
 560     }
 561   fclose (fp);
 562
 563   return errcnt == 0;
 564 }
 565
 566 /* Initialize the defaults and run the system wgetrc and user's own
 567    wgetrc.  */
 568 void
 569 initialize (void)
 570 {
 571   char *file, *env_sysrc;
 572   int ok = true;
 573
 574   /* Load the hard-coded defaults.  */
 575   defaults ();
 576
 577   /* Run a non-standard system rc file when the according environment
 578      variable has been set. For internal testing purposes only!  */
 579   env_sysrc = getenv ("SYSTEM_WGETRC");
 580   if (env_sysrc && file_exists_p (env_sysrc))
 581     ok &= run_wgetrc (env_sysrc);
 582   /* Otherwise, if SYSTEM_WGETRC is defined, use it.  */
 583 #ifdef SYSTEM_WGETRC
 584   else if (file_exists_p (SYSTEM_WGETRC))
 585     ok &= run_wgetrc (SYSTEM_WGETRC);
 586 #endif
 587   /* Override it with your own, if one exists.  */
 588   file = wgetrc_file_name ();
 589   if (!file)
 590     return;
 591   /* #### We should canonicalize `file' and SYSTEM_WGETRC with
 592      something like realpath() before comparing them with `strcmp'  */
 593 #ifdef SYSTEM_WGETRC
 594   if (!strcmp (file, SYSTEM_WGETRC))
 595     {
 596       fprintf (stderr, _("\
 597 %s: Warning: Both system and user wgetrc point to %s.\n"),
 598                exec_name, quote (file));
 599     }
 600   else
 601 #endif
 602     ok &= run_wgetrc (file);
 603
 604   /* If there were errors processing either `.wgetrc', abort. */
 605   if (!ok)
 606     exit (2);
 607
 608   xfree (file);
 609   return;
 610 }
 611
 612 /* Remove dashes and underscores from S, modifying S in the
 613    process. */
 614
 615 static void
 616 dehyphen (char *s)
 617 {
 618   char *t = s;                  /* t - tortoise */
 619   char *h = s;                  /* h - hare     */
 620   while (*h)
 621     if (*h == '_' || *h == '-')
 622       ++h;
 623     else
 624       *t++ = *h++;
 625   *t = '\0';
 626 }
 627
 628 /* Parse the line pointed by line, with the syntax:
 629    <sp>* command <sp>* = <sp>* value <sp>*
 630    Uses malloc to allocate space for command and value.
 631
 632    Returns one of line_ok, line_empty, line_syntax_error, or
 633    line_unknown_command.
 634
 635    In case of line_ok, *COM and *VAL point to freshly allocated
 636    strings, and *COMIND points to com's index.  In case of error or
 637    empty line, their values are unmodified.  */
 638
 639 static enum parse_line
 640 parse_line (const char *line, char **com, char **val, int *comind)
 641 {
 642   const char *p;
 643   const char *end = line + strlen (line);
 644   const char *cmdstart, *cmdend;
 645   const char *valstart, *valend;
 646
 647   char *cmdcopy;
 648   int ind;
 649
 650   /* Skip leading and trailing whitespace.  */
 651   while (*line && c_isspace (*line))
 652     ++line;
 653   while (end > line && c_isspace (end[-1]))
 654     --end;
 655
 656   /* Skip empty lines and comments.  */
 657   if (!*line || *line == '#')
 658     return line_empty;
 659
 660   p = line;
 661
 662   cmdstart = p;
 663   while (p < end && (c_isalnum (*p) || *p == '_' || *p == '-'))
 664     ++p;
 665   cmdend = p;
 666
 667   /* Skip '=', as well as any space before or after it. */
 668   while (p < end && c_isspace (*p))
 669     ++p;
 670   if (p == end || *p != '=')
 671     return line_syntax_error;
 672   ++p;
 673   while (p < end && c_isspace (*p))
 674     ++p;
 675
 676   valstart = p;
 677   valend   = end;
 678
 679   /* The syntax is valid (even though the command might not be).  Fill
 680      in the command name and value.  */
 681   *com = strdupdelim (cmdstart, cmdend);
 682   *val = strdupdelim (valstart, valend);
 683
 684   /* The line now known to be syntactically correct.  Check whether
 685      the command is valid.  */
 686   BOUNDED_TO_ALLOCA (cmdstart, cmdend, cmdcopy);
 687   dehyphen (cmdcopy);
 688   ind = command_by_name (cmdcopy);
 689   if (ind == -1)
 690     return line_unknown_command;
 691
 692   /* Report success to the caller. */
 693   *comind = ind;
 694   return line_ok;
 695 }
 696
 697 #if defined(WINDOWS) || defined(MSDOS)
 698 # define ISSEP(c) ((c) == '/' || (c) == '\\')
 699 #else
 700 # define ISSEP(c) ((c) == '/')
 701 #endif
 702
 703 /* Run commands[comind].action. */
 704
 705 static bool
 706 setval_internal (int comind, const char *com, const char *val)
 707 {
 708   assert (0 <= comind && ((size_t) comind) < countof (commands));
 709   DEBUGP (("Setting %s (%s) to %s\n", com, commands[comind].name, val));
 710   return commands[comind].action (com, val, commands[comind].place);
 711 }
 712
 713 static bool
 714 setval_internal_tilde (int comind, const char *com, const char *val)
 715 {
 716   bool ret;
 717   int homelen;
 718   char *home;
 719   char **pstring;
 720   ret = setval_internal (comind, com, val);
 721
 722   /* We make tilde expansion for cmd_file and cmd_directory */
 723   if (((commands[comind].action == cmd_file) ||
 724        (commands[comind].action == cmd_directory))
 725       && ret && (*val == '~' && ISSEP (val[1])))
 726     {
 727       pstring = commands[comind].place;
 728       home = home_dir ();
 729       if (home)
 730         {
 731           homelen = strlen (home);
 732           while (homelen && ISSEP (home[homelen - 1]))
 733             home[--homelen] = '\0';
 734
 735           /* Skip the leading "~/". */
 736           for (++val; ISSEP (*val); val++)
 737             ;
 738           *pstring = concat_strings (home, "/", val, (char *)0);
 739         }
 740     }
 741   return ret;
 742 }
 743
 744 /* Run command COM with value VAL.  If running the command produces an
 745    error, report the error and exit.
 746
 747    This is intended to be called from main() to modify Wget's behavior
 748    through command-line switches.  Since COM is hard-coded in main(),
 749    it is not canonicalized, and this aborts when COM is not found.
 750
 751    If COMIND's are exported to init.h, this function will be changed
 752    to accept COMIND directly.  */
 753
 754 void
 755 setoptval (const char *com, const char *val, const char *optname)
 756 {
 757   /* Prepend "--" to OPTNAME. */
 758   char *dd_optname = (char *) alloca (2 + strlen (optname) + 1);
 759   dd_optname[0] = '-';
 760   dd_optname[1] = '-';
 761   strcpy (dd_optname + 2, optname);
 762
 763   assert (val != NULL);
 764   if (!setval_internal (command_by_name (com), dd_optname, val))
 765     exit (2);
 766 }
 767
 768 /* Parse OPT into command and value and run it.  For example,
 769    run_command("foo=bar") is equivalent to setoptval("foo", "bar").
 770    This is used by the `--execute' flag in main.c.  */
 771
 772 void
 773 run_command (const char *opt)
 774 {
 775   char *com, *val;
 776   int comind;
 777   switch (parse_line (opt, &com, &val, &comind))
 778     {
 779     case line_ok:
 780       if (!setval_internal (comind, com, val))
 781         exit (2);
 782       xfree (com);
 783       xfree (val);
 784       break;
 785     default:
 786       fprintf (stderr, _("%s: Invalid --execute command %s\n"),
 787                exec_name, quote (opt));
 788       exit (2);
 789     }
 790 }
 791 \f
 792 /* Generic helper functions, for use with `commands'. */
 793
 794 /* Forward declarations: */
 795 struct decode_item {
 796   const char *name;
 797   int code;
 798 };
 799 static bool decode_string (const char *, const struct decode_item *, int, int *);
 800 static bool simple_atoi (const char *, const char *, int *);
 801 static bool simple_atof (const char *, const char *, double *);
 802
 803 #define CMP1(p, c0) (c_tolower((p)[0]) == (c0) && (p)[1] == '\0')
 804
 805 #define CMP2(p, c0, c1) (c_tolower((p)[0]) == (c0)        \
 806                          && c_tolower((p)[1]) == (c1)     \
 807                          && (p)[2] == '\0')
 808
 809 #define CMP3(p, c0, c1, c2) (c_tolower((p)[0]) == (c0)    \
 810                      && c_tolower((p)[1]) == (c1)         \
 811                      && c_tolower((p)[2]) == (c2)         \
 812                      && (p)[3] == '\0')
 813
 814
 815 /* Store the boolean value from VAL to PLACE.  COM is ignored,
 816    except for error messages.  */
 817 static bool
 818 cmd_boolean (const char *com, const char *val, void *place)
 819 {
 820   bool value;
 821
 822   if (CMP2 (val, 'o', 'n') || CMP3 (val, 'y', 'e', 's') || CMP1 (val, '1'))
 823     /* "on", "yes" and "1" mean true. */
 824     value = true;
 825   else if (CMP3 (val, 'o', 'f', 'f') || CMP2 (val, 'n', 'o') || CMP1 (val, '0'))
 826     /* "off", "no" and "0" mean false. */
 827     value = false;
 828   else
 829     {
 830       fprintf (stderr,
 831                _("%s: %s: Invalid boolean %s; use `on' or `off'.\n"),
 832                exec_name, com, quote (val));
 833       return false;
 834     }
 835
 836   *(bool *) place = value;
 837   return true;
 838 }
 839
 840 /* Set the non-negative integer value from VAL to PLACE.  With
 841    incorrect specification, the number remains unchanged.  */
 842 static bool
 843 cmd_number (const char *com, const char *val, void *place)
 844 {
 845   if (!simple_atoi (val, val + strlen (val), place)
 846       || *(int *) place < 0)
 847     {
 848       fprintf (stderr, _("%s: %s: Invalid number %s.\n"),
 849                exec_name, com, quote (val));
 850       return false;
 851     }
 852   return true;
 853 }
 854
 855 /* Similar to cmd_number(), only accepts `inf' as a synonym for 0.  */
 856 static bool
 857 cmd_number_inf (const char *com, const char *val, void *place)
 858 {
 859   if (!strcasecmp (val, "inf"))
 860     {
 861       *(int *) place = 0;
 862       return true;
 863     }
 864   return cmd_number (com, val, place);
 865 }
 866
 867 /* Copy (strdup) the string at COM to a new location and place a
 868    pointer to *PLACE.  */
 869 static bool
 870 cmd_string (const char *com, const char *val, void *place)
 871 {
 872   char **pstring = (char **)place;
 873
 874   xfree_null (*pstring);
 875   *pstring = xstrdup (val);
 876   return true;
 877 }
 878
 879
 880 /* Like the above, but handles tilde-expansion when reading a user's
 881    `.wgetrc'.  In that case, and if VAL begins with `~', the tilde
 882    gets expanded to the user's home directory.  */
 883 static bool
 884 cmd_file (const char *com, const char *val, void *place)
 885 {
 886   char **pstring = (char **)place;
 887
 888   xfree_null (*pstring);
 889
 890   /* #### If VAL is empty, perhaps should set *PLACE to NULL.  */
 891
 892   *pstring = xstrdup (val);
 893
 894 #if defined(WINDOWS) || defined(MSDOS)
 895   /* Convert "\" to "/". */
 896   {
 897     char *s;
 898     for (s = *pstring; *s; s++)
 899       if (*s == '\\')
 900         *s = '/';
 901   }
 902 #endif
 903   return true;
 904 }
 905
 906 /* Like cmd_file, but strips trailing '/' characters.  */
 907 static bool
 908 cmd_directory (const char *com, const char *val, void *place)
 909 {
 910   char *s, *t;
 911
 912   /* Call cmd_file() for tilde expansion and separator
 913      canonicalization (backslash -> slash under Windows).  These
 914      things should perhaps be in a separate function.  */
 915   if (!cmd_file (com, val, place))
 916     return false;
 917
 918   s = *(char **)place;
 919   t = s + strlen (s);
 920   while (t > s && *--t == '/')
 921     *t = '\0';
 922
 923   return true;
 924 }
 925
 926 /* Split VAL by space to a vector of values, and append those values
 927    to vector pointed to by the PLACE argument.  If VAL is empty, the
 928    PLACE vector is cleared instead.  */
 929
 930 static bool
 931 cmd_vector (const char *com, const char *val, void *place)
 932 {
 933   char ***pvec = (char ***)place;
 934
 935   if (*val)
 936     *pvec = merge_vecs (*pvec, sepstring (val));
 937   else
 938     {
 939       free_vec (*pvec);
 940       *pvec = NULL;
 941     }
 942   return true;
 943 }
 944
 945 static bool
 946 cmd_directory_vector (const char *com, const char *val, void *place)
 947 {
 948   char ***pvec = (char ***)place;
 949
 950   if (*val)
 951     {
 952       /* Strip the trailing slashes from directories.  */
 953       char **t, **seps;
 954
 955       seps = sepstring (val);
 956       for (t = seps; t && *t; t++)
 957         {
 958           int len = strlen (*t);
 959           /* Skip degenerate case of root directory.  */
 960           if (len > 1)
 961             {
 962               if ((*t)[len - 1] == '/')
 963                 (*t)[len - 1] = '\0';
 964             }
 965         }
 966       *pvec = merge_vecs (*pvec, seps);
 967     }
 968   else
 969     {
 970       free_vec (*pvec);
 971       *pvec = NULL;
 972     }
 973   return true;
 974 }
 975
 976 /* Engine for cmd_bytes and cmd_bytes_sum: converts a string such as
 977    "100k" or "2.5G" to a floating point number.  */
 978
 979 static bool
 980 parse_bytes_helper (const char *val, double *result)
 981 {
 982   double number, mult;
 983   const char *end = val + strlen (val);
 984
 985   /* Check for "inf".  */
 986   if (0 == strcmp (val, "inf"))
 987     {
 988       *result = 0;
 989       return true;
 990     }
 991
 992   /* Strip trailing whitespace.  */
 993   while (val < end && c_isspace (end[-1]))
 994     --end;
 995   if (val == end)
 996     return false;
 997
 998   switch (c_tolower (end[-1]))
 999     {
1000     case 'k':
1001       --end, mult = 1024.0;
1002       break;
1003     case 'm':
1004       --end, mult = 1048576.0;
1005       break;
1006     case 'g':
1007       --end, mult = 1073741824.0;
1008       break;
1009     case 't':
1010       --end, mult = 1099511627776.0;
1011       break;
1012     default:
1013       /* Not a recognized suffix: assume it's a digit.  (If not,
1014          simple_atof will raise an error.)  */
1015       mult = 1;
1016     }
1017
1018   /* Skip leading and trailing whitespace. */
1019   while (val < end && c_isspace (*val))
1020     ++val;
1021   while (val < end && c_isspace (end[-1]))
1022     --end;
1023   if (val == end)
1024     return false;
1025
1026   if (!simple_atof (val, end, &number) || number < 0)
1027     return false;
1028
1029   *result = number * mult;
1030   return true;
1031 }
1032
1033 /* Parse VAL as a number and set its value to PLACE (which should
1034    point to a wgint).
1035
1036    By default, the value is assumed to be in bytes.  If "K", "M", or
1037    "G" are appended, the value is multiplied with 1<<10, 1<<20, or
1038    1<<30, respectively.  Floating point values are allowed and are
1039    cast to integer before use.  The idea is to be able to use things
1040    like 1.5k instead of "1536".
1041
1042    The string "inf" is returned as 0.
1043
1044    In case of error, false is returned and memory pointed to by PLACE
1045    remains unmodified.  */
1046
1047 static bool
1048 cmd_bytes (const char *com, const char *val, void *place)
1049 {
1050   double byte_value;
1051   if (!parse_bytes_helper (val, &byte_value))
1052     {
1053       fprintf (stderr, _("%s: %s: Invalid byte value %s\n"),
1054                exec_name, com, quote (val));
1055       return false;
1056     }
1057   *(wgint *)place = (wgint)byte_value;
1058   return true;
1059 }
1060
1061 /* Like cmd_bytes, but PLACE is interpreted as a pointer to
1062    SIZE_SUM.  It works by converting the string to double, therefore
1063    working with values up to 2^53-1 without loss of precision.  This
1064    value (8192 TB) is large enough to serve for a while.  */
1065
1066 static bool
1067 cmd_bytes_sum (const char *com, const char *val, void *place)
1068 {
1069   double byte_value;
1070   if (!parse_bytes_helper (val, &byte_value))
1071     {
1072       fprintf (stderr, _("%s: %s: Invalid byte value %s\n"),
1073                exec_name, com, quote (val));
1074       return false;
1075     }
1076   *(SUM_SIZE_INT *) place = (SUM_SIZE_INT) byte_value;
1077   return true;
1078 }
1079
1080 /* Store the value of VAL to *OUT.  The value is a time period, by
1081    default expressed in seconds, but also accepting suffixes "m", "h",
1082    "d", and "w" for minutes, hours, days, and weeks respectively.  */
1083
1084 static bool
1085 cmd_time (const char *com, const char *val, void *place)
1086 {
1087   double number, mult;
1088   const char *end = val + strlen (val);
1089
1090   /* Strip trailing whitespace.  */
1091   while (val < end && c_isspace (end[-1]))
1092     --end;
1093
1094   if (val == end)
1095     {
1096     err:
1097       fprintf (stderr, _("%s: %s: Invalid time period %s\n"),
1098                exec_name, com, quote (val));
1099       return false;
1100     }
1101
1102   switch (c_tolower (end[-1]))
1103     {
1104     case 's':
1105       --end, mult = 1;          /* seconds */
1106       break;
1107     case 'm':
1108       --end, mult = 60;         /* minutes */
1109       break;
1110     case 'h':
1111       --end, mult = 3600;       /* hours */
1112       break;
1113     case 'd':
1114       --end, mult = 86400.0;    /* days */
1115       break;
1116     case 'w':
1117       --end, mult = 604800.0;   /* weeks */
1118       break;
1119     default:
1120       /* Not a recognized suffix: assume it belongs to the number.
1121          (If not, simple_atof will raise an error.)  */
1122       mult = 1;
1123     }
1124
1125   /* Skip leading and trailing whitespace. */
1126   while (val < end && c_isspace (*val))
1127     ++val;
1128   while (val < end && c_isspace (end[-1]))
1129     --end;
1130   if (val == end)
1131     goto err;
1132
1133   if (!simple_atof (val, end, &number))
1134     goto err;
1135
1136   *(double *)place = number * mult;
1137   return true;
1138 }
1139
1140 #ifdef HAVE_SSL
1141 static bool
1142 cmd_cert_type (const char *com, const char *val, void *place)
1143 {
1144   static const struct decode_item choices[] = {
1145     { "pem", keyfile_pem },
1146     { "der", keyfile_asn1 },
1147     { "asn1", keyfile_asn1 },
1148   };
1149   int ok = decode_string (val, choices, countof (choices), place);
1150   if (!ok)
1151     fprintf (stderr, _("%s: %s: Invalid value %s.\n"), exec_name, com, quote (val));
1152   return ok;
1153 }
1154 #endif
1155 \f
1156 /* Specialized helper functions, used by `commands' to handle some
1157    options specially.  */
1158
1159 static bool check_user_specified_header (const char *);
1160
1161 static bool
1162 cmd_spec_dirstruct (const char *com, const char *val, void *place_ignored)
1163 {
1164   if (!cmd_boolean (com, val, &opt.dirstruct))
1165     return false;
1166   /* Since dirstruct behaviour is explicitly changed, no_dirstruct
1167      must be affected inversely.  */
1168   if (opt.dirstruct)
1169     opt.no_dirstruct = false;
1170   else
1171     opt.no_dirstruct = true;
1172   return true;
1173 }
1174
1175 static bool
1176 cmd_spec_header (const char *com, const char *val, void *place_ignored)
1177 {
1178   /* Empty value means reset the list of headers. */
1179   if (*val == '\0')
1180     {
1181       free_vec (opt.user_headers);
1182       opt.user_headers = NULL;
1183       return true;
1184     }
1185
1186   if (!check_user_specified_header (val))
1187     {
1188       fprintf (stderr, _("%s: %s: Invalid header %s.\n"),
1189                exec_name, com, quote (val));
1190       return false;
1191     }
1192   opt.user_headers = vec_append (opt.user_headers, val);
1193   return true;
1194 }
1195
1196 static bool
1197 cmd_spec_htmlify (const char *com, const char *val, void *place_ignored)
1198 {
1199   int flag = cmd_boolean (com, val, &opt.htmlify);
1200   if (flag && !opt.htmlify)
1201     opt.remove_listing = false;
1202   return flag;
1203 }
1204
1205 /* Set the "mirror" mode.  It means: recursive download, timestamping,
1206    no limit on max. recursion depth, and don't remove listings.  */
1207
1208 static bool
1209 cmd_spec_mirror (const char *com, const char *val, void *place_ignored)
1210 {
1211   int mirror;
1212
1213   if (!cmd_boolean (com, val, &mirror))
1214     return false;
1215   if (mirror)
1216     {
1217       opt.recursive = true;
1218       if (!opt.no_dirstruct)
1219         opt.dirstruct = true;
1220       opt.timestamping = true;
1221       opt.reclevel = INFINITE_RECURSION;
1222       opt.remove_listing = false;
1223     }
1224   return true;
1225 }
1226
1227 /* Validate --prefer-family and set the choice.  Allowed values are
1228    "IPv4", "IPv6", and "none".  */
1229
1230 static bool
1231 cmd_spec_prefer_family (const char *com, const char *val, void *place_ignored)
1232 {
1233   static const struct decode_item choices[] = {
1234     { "IPv4", prefer_ipv4 },
1235     { "IPv6", prefer_ipv6 },
1236     { "none", prefer_none },
1237   };
1238   int prefer_family = prefer_none;
1239   int ok = decode_string (val, choices, countof (choices), &prefer_family);
1240   if (!ok)
1241     fprintf (stderr, _("%s: %s: Invalid value %s.\n"), exec_name, com, quote (val));
1242   opt.prefer_family = prefer_family;
1243   return ok;
1244 }
1245
1246 /* Set progress.type to VAL, but verify that it's a valid progress
1247    implementation before that.  */
1248
1249 static bool
1250 cmd_spec_progress (const char *com, const char *val, void *place_ignored)
1251 {
1252   if (!valid_progress_implementation_p (val))
1253     {
1254       fprintf (stderr, _("%s: %s: Invalid progress type %s.\n"),
1255                exec_name, com, quote (val));
1256       return false;
1257     }
1258   xfree_null (opt.progress_type);
1259
1260   /* Don't call set_progress_implementation here.  It will be called
1261      in main() when it becomes clear what the log output is.  */
1262   opt.progress_type = xstrdup (val);
1263   return true;
1264 }
1265
1266 /* Set opt.recursive to VAL as with cmd_boolean.  If opt.recursive is
1267    set to true, also set opt.dirstruct to true, unless opt.no_dirstruct
1268    is specified.  */
1269
1270 static bool
1271 cmd_spec_recursive (const char *com, const char *val, void *place_ignored)
1272 {
1273   if (!cmd_boolean (com, val, &opt.recursive))
1274     return false;
1275   else
1276     {
1277       if (opt.recursive && !opt.no_dirstruct)
1278         opt.dirstruct = true;
1279     }
1280   return true;
1281 }
1282
1283 static bool
1284 cmd_spec_restrict_file_names (const char *com, const char *val, void *place_ignored)
1285 {
1286   int restrict_os = opt.restrict_files_os;
1287   int restrict_ctrl = opt.restrict_files_ctrl;
1288   int restrict_case = opt.restrict_files_case;
1289   int restrict_nonascii = opt.restrict_files_nonascii;
1290
1291   const char *end;
1292
1293 #define VAL_IS(string_literal) BOUNDED_EQUAL (val, end, string_literal)
1294
1295   do
1296     {
1297       end = strchr (val, ',');
1298       if (!end)
1299         end = val + strlen (val);
1300
1301       if (VAL_IS ("unix"))
1302         restrict_os = restrict_unix;
1303       else if (VAL_IS ("windows"))
1304         restrict_os = restrict_windows;
1305       else if (VAL_IS ("lowercase"))
1306         restrict_case = restrict_lowercase;
1307       else if (VAL_IS ("uppercase"))
1308         restrict_case = restrict_uppercase;
1309       else if (VAL_IS ("nocontrol"))
1310         restrict_ctrl = false;
1311       else if (VAL_IS ("ascii"))
1312         restrict_nonascii = true;
1313       else
1314         {
1315           fprintf (stderr, _("\
1316 %s: %s: Invalid restriction %s,\n\
1317     use [unix|windows],[lowercase|uppercase],[nocontrol],[ascii].\n"),
1318                    exec_name, com, quote (val));
1319           return false;
1320         }
1321
1322       if (*end)
1323         val = end + 1;
1324     }
1325   while (*val && *end);
1326
1327 #undef VAL_IS
1328
1329   opt.restrict_files_os = restrict_os;
1330   opt.restrict_files_ctrl = restrict_ctrl;
1331   opt.restrict_files_case = restrict_case;
1332   opt.restrict_files_nonascii = restrict_nonascii;
1333
1334   return true;
1335 }
1336
1337 #ifdef HAVE_SSL
1338 static bool
1339 cmd_spec_secure_protocol (const char *com, const char *val, void *place)
1340 {
1341   static const struct decode_item choices[] = {
1342     { "auto", secure_protocol_auto },
1343     { "sslv2", secure_protocol_sslv2 },
1344     { "sslv3", secure_protocol_sslv3 },
1345     { "tlsv1", secure_protocol_tlsv1 },
1346   };
1347   int ok = decode_string (val, choices, countof (choices), place);
1348   if (!ok)
1349     fprintf (stderr, _("%s: %s: Invalid value %s.\n"), exec_name, com, quote (val));
1350   return ok;
1351 }
1352 #endif
1353
1354 /* Set all three timeout values. */
1355
1356 static bool
1357 cmd_spec_timeout (const char *com, const char *val, void *place_ignored)
1358 {
1359   double value;
1360   if (!cmd_time (com, val, &value))
1361     return false;
1362   opt.read_timeout = value;
1363   opt.connect_timeout = value;
1364   opt.dns_timeout = value;
1365   return true;
1366 }
1367
1368 static bool
1369 cmd_spec_useragent (const char *com, const char *val, void *place_ignored)
1370 {
1371   /* Disallow embedded newlines.  */
1372   if (strchr (val, '\n'))
1373     {
1374       fprintf (stderr, _("%s: %s: Invalid value %s.\n"),
1375                exec_name, com, quote (val));
1376       return false;
1377     }
1378   xfree_null (opt.useragent);
1379   opt.useragent = xstrdup (val);
1380   return true;
1381 }
1382
1383 /* The "verbose" option cannot be cmd_boolean because the variable is
1384    not bool -- it's of type int (-1 means uninitialized because of
1385    some random hackery for disallowing -q -v).  */
1386
1387 static bool
1388 cmd_spec_verbose (const char *com, const char *val, void *place_ignored)
1389 {
1390   bool flag;
1391   if (cmd_boolean (com, val, &flag))
1392     {
1393       opt.verbose = flag;
1394       return true;
1395     }
1396   return false;
1397 }
1398 \f
1399 /* Miscellaneous useful routines.  */
1400
1401 /* A very simple atoi clone, more useful than atoi because it works on
1402    delimited strings, and has error reportage.  Returns true on success,
1403    false on failure.  If successful, stores result to *DEST.  */
1404
1405 static bool
1406 simple_atoi (const char *beg, const char *end, int *dest)
1407 {
1408   int result = 0;
1409   bool negative = false;
1410   const char *p = beg;
1411
1412   while (p < end && c_isspace (*p))
1413     ++p;
1414   if (p < end && (*p == '-' || *p == '+'))
1415     {
1416       negative = (*p == '-');
1417       ++p;
1418     }
1419   if (p == end)
1420     return false;
1421
1422   /* Read negative numbers in a separate loop because the most
1423      negative integer cannot be represented as a positive number.  */
1424
1425   if (!negative)
1426     for (; p < end && c_isdigit (*p); p++)
1427       {
1428         int next = (10 * result) + (*p - '0');
1429         if (next < result)
1430           return false;         /* overflow */
1431         result = next;
1432       }
1433   else
1434     for (; p < end && c_isdigit (*p); p++)
1435       {
1436         int next = (10 * result) - (*p - '0');
1437         if (next > result)
1438           return false;         /* underflow */
1439         result = next;
1440       }
1441
1442   if (p != end)
1443     return false;
1444
1445   *dest = result;
1446   return true;
1447 }
1448
1449 /* Trivial atof, with error reporting.  Handles "<digits>[.<digits>]",
1450    doesn't handle exponential notation.  Returns true on success,
1451    false on failure.  In case of success, stores its result to
1452    *DEST.  */
1453
1454 static bool
1455 simple_atof (const char *beg, const char *end, double *dest)
1456 {
1457   double result = 0;
1458
1459   bool negative = false;
1460   bool seen_dot = false;
1461   bool seen_digit = false;
1462   double divider = 1;
1463
1464   const char *p = beg;
1465
1466   while (p < end && c_isspace (*p))
1467     ++p;
1468   if (p < end && (*p == '-' || *p == '+'))
1469     {
1470       negative = (*p == '-');
1471       ++p;
1472     }
1473
1474   for (; p < end; p++)
1475     {
1476       char ch = *p;
1477       if (c_isdigit (ch))
1478         {
1479           if (!seen_dot)
1480             result = (10 * result) + (ch - '0');
1481           else
1482             result += (ch - '0') / (divider *= 10);
1483           seen_digit = true;
1484         }
1485       else if (ch == '.')
1486         {
1487           if (!seen_dot)
1488             seen_dot = true;
1489           else
1490             return false;
1491         }
1492       else
1493         return false;
1494     }
1495   if (!seen_digit)
1496     return false;
1497   if (negative)
1498     result = -result;
1499
1500   *dest = result;
1501   return true;
1502 }
1503
1504 /* Verify that the user-specified header in S is valid.  It must
1505    contain a colon preceded by non-white-space characters and must not
1506    contain newlines.  */
1507
1508 static bool
1509 check_user_specified_header (const char *s)
1510 {
1511   const char *p;
1512
1513   for (p = s; *p && *p != ':' && !c_isspace (*p); p++)
1514     ;
1515   /* The header MUST contain `:' preceded by at least one
1516      non-whitespace character.  */
1517   if (*p != ':' || p == s)
1518     return false;
1519   /* The header MUST NOT contain newlines.  */
1520   if (strchr (s, '\n'))
1521     return false;
1522   return true;
1523 }
1524
1525 /* Decode VAL into a number, according to ITEMS. */
1526
1527 static bool
1528 decode_string (const char *val, const struct decode_item *items, int itemcount,
1529                int *place)
1530 {
1531   int i;
1532   for (i = 0; i < itemcount; i++)
1533     if (0 == strcasecmp (val, items[i].name))
1534       {
1535         *place = items[i].code;
1536         return true;
1537       }
1538   return false;
1539 }
1540
1541 \f
1542 void cleanup_html_url (void);
1543
1544
1545 /* Free the memory allocated by global variables.  */
1546 void
1547 cleanup (void)
1548 {
1549   /* Free external resources, close files, etc. */
1550
1551   if (output_stream)
1552     fclose (output_stream);
1553   /* No need to check for error because Wget flushes its output (and
1554      checks for errors) after any data arrives.  */
1555
1556   /* We're exiting anyway so there's no real need to call free()
1557      hundreds of times.  Skipping the frees will make Wget exit
1558      faster.
1559
1560      However, when detecting leaks, it's crucial to free() everything
1561      because then you can find the real leaks, i.e. the allocated
1562      memory which grows with the size of the program.  */
1563
1564 #ifdef DEBUG_MALLOC
1565   convert_cleanup ();
1566   res_cleanup ();
1567   http_cleanup ();
1568   cleanup_html_url ();
1569   host_cleanup ();
1570   log_cleanup ();
1571
1572   {
1573     extern acc_t *netrc_list;
1574     free_netrc (netrc_list);
1575   }
1576   xfree_null (opt.lfilename);
1577   xfree_null (opt.dir_prefix);
1578   xfree_null (opt.input_filename);
1579   xfree_null (opt.output_document);
1580   free_vec (opt.accepts);
1581   free_vec (opt.rejects);
1582   free_vec (opt.excludes);
1583   free_vec (opt.includes);
1584   free_vec (opt.domains);
1585   free_vec (opt.follow_tags);
1586   free_vec (opt.ignore_tags);
1587   xfree_null (opt.progress_type);
1588   xfree_null (opt.ftp_user);
1589   xfree_null (opt.ftp_passwd);
1590   xfree_null (opt.ftp_proxy);
1591   xfree_null (opt.https_proxy);
1592   xfree_null (opt.http_proxy);
1593   free_vec (opt.no_proxy);
1594   xfree_null (opt.useragent);
1595   xfree_null (opt.referer);
1596   xfree_null (opt.http_user);
1597   xfree_null (opt.http_passwd);
1598   free_vec (opt.user_headers);
1599 # ifdef HAVE_SSL
1600   xfree_null (opt.cert_file);
1601   xfree_null (opt.private_key);
1602   xfree_null (opt.ca_directory);
1603   xfree_null (opt.ca_cert);
1604   xfree_null (opt.random_file);
1605   xfree_null (opt.egd_file);
1606 # endif
1607   xfree_null (opt.bind_address);
1608   xfree_null (opt.cookies_input);
1609   xfree_null (opt.cookies_output);
1610   xfree_null (opt.user);
1611   xfree_null (opt.passwd);
1612   xfree_null (opt.base_href);
1613
1614 #endif /* DEBUG_MALLOC */
1615 }
1616 \f
1617 /* Unit testing routines.  */
1618
1619 #ifdef TESTING
1620
1621 const char *
1622 test_commands_sorted()
1623 {
1624   int prev_idx = 0, next_idx = 1;
1625   int command_count = countof (commands) - 1;
1626   int cmp = 0;
1627   while (next_idx <= command_count)
1628     {
1629       cmp = strcasecmp (commands[prev_idx].name, commands[next_idx].name);
1630       if (cmp > 0)
1631         {
1632           mu_assert ("FAILED", false);
1633           break;
1634         }
1635       else
1636         {
1637           prev_idx ++;
1638           next_idx ++;
1639         }
1640     }
1641   return NULL;
1642 }
1643
1644 const char *
1645 test_cmd_spec_restrict_file_names()
1646 {
1647   int i;
1648   struct {
1649     char *val;
1650     int expected_restrict_files_os;
1651     int expected_restrict_files_ctrl;
1652     int expected_restrict_files_case;
1653     bool result;
1654   } test_array[] = {
1655     { "windows", restrict_windows, true, restrict_no_case_restriction, true },
1656     { "windows,", restrict_windows, true, restrict_no_case_restriction, true },
1657     { "windows,lowercase", restrict_windows, true, restrict_lowercase, true },
1658     { "unix,nocontrol,lowercase,", restrict_unix, false, restrict_lowercase, true },
1659   };
1660
1661   for (i = 0; i < sizeof(test_array)/sizeof(test_array[0]); ++i)
1662     {
1663       bool res;
1664
1665       defaults();
1666       res = cmd_spec_restrict_file_names ("dummy", test_array[i].val, NULL);
1667
1668       /*
1669       fprintf (stderr, "test_cmd_spec_restrict_file_names: TEST %d\n", i); fflush (stderr);
1670       fprintf (stderr, "opt.restrict_files_os: %d\n",   opt.restrict_files_os); fflush (stderr);
1671       fprintf (stderr, "opt.restrict_files_ctrl: %d\n", opt.restrict_files_ctrl); fflush (stderr);
1672       fprintf (stderr, "opt.restrict_files_case: %d\n", opt.restrict_files_case); fflush (stderr);
1673       */
1674       mu_assert ("test_cmd_spec_restrict_file_names: wrong result",
1675                  res == test_array[i].result
1676                  && opt.restrict_files_os   == test_array[i].expected_restrict_files_os
1677                  && opt.restrict_files_ctrl == test_array[i].expected_restrict_files_ctrl
1678                  && opt.restrict_files_case == test_array[i].expected_restrict_files_case);
1679     }
1680
1681   return NULL;
1682 }
1683
1684 #endif /* TESTING */
1685