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