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