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

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