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   { "askpassword",      &opt.ask_passwd,        cmd_boolean },
 117   { "authnochallenge",  &opt.auth_without_challenge,
 118                                                 cmd_boolean },
 119   { "background",       &opt.background,        cmd_boolean },
 120   { "backupconverted",  &opt.backup_converted,  cmd_boolean },
 121   { "backups",          &opt.backups,           cmd_number },
 122   { "base",             &opt.base_href,         cmd_string },
 123   { "bindaddress",      &opt.bind_address,      cmd_string },
 124 #ifdef HAVE_SSL
 125   { "cacertificate",    &opt.ca_cert,           cmd_file },
 126 #endif
 127   { "cache",            &opt.allow_cache,       cmd_boolean },
 128 #ifdef HAVE_SSL
 129   { "cadirectory",      &opt.ca_directory,      cmd_directory },
 130   { "certificate",      &opt.cert_file,         cmd_file },
 131   { "certificatetype",  &opt.cert_type,         cmd_cert_type },
 132   { "checkcertificate", &opt.check_cert,        cmd_boolean },
 133 #endif
 134   { "connecttimeout",   &opt.connect_timeout,   cmd_time },
 135   { "contentdisposition", &opt.content_disposition, cmd_boolean },
 136   { "continue",         &opt.always_rest,       cmd_boolean },
 137   { "convertlinks",     &opt.convert_links,     cmd_boolean },
 138   { "cookies",          &opt.cookies,           cmd_boolean },
 139   { "cutdirs",          &opt.cut_dirs,          cmd_number },
 140 #ifdef ENABLE_DEBUG
 141   { "debug",            &opt.debug,             cmd_boolean },
 142 #endif
 143   { "defaultpage",      &opt.default_page,      cmd_string},
 144   { "deleteafter",      &opt.delete_after,      cmd_boolean },
 145   { "dirprefix",        &opt.dir_prefix,        cmd_directory },
 146   { "dirstruct",        NULL,                   cmd_spec_dirstruct },
 147   { "dnscache",         &opt.dns_cache,         cmd_boolean },
 148   { "dnstimeout",       &opt.dns_timeout,       cmd_time },
 149   { "domains",          &opt.domains,           cmd_vector },
 150   { "dotbytes",         &opt.dot_bytes,         cmd_bytes },
 151   { "dotsinline",       &opt.dots_in_line,      cmd_number },
 152   { "dotspacing",       &opt.dot_spacing,       cmd_number },
 153   { "dotstyle",         &opt.dot_style,         cmd_string },
 154 #ifdef HAVE_SSL
 155   { "egdfile",          &opt.egd_file,          cmd_file },
 156 #endif
 157   { "excludedirectories", &opt.excludes,        cmd_directory_vector },
 158   { "excludedomains",   &opt.exclude_domains,   cmd_vector },
 159   { "followftp",        &opt.follow_ftp,        cmd_boolean },
 160   { "followtags",       &opt.follow_tags,       cmd_vector },
 161   { "forcehtml",        &opt.force_html,        cmd_boolean },
 162   { "ftppasswd",        &opt.ftp_passwd,        cmd_string }, /* deprecated */
 163   { "ftppassword",      &opt.ftp_passwd,        cmd_string },
 164   { "ftpproxy",         &opt.ftp_proxy,         cmd_string },
 165   { "ftpuser",          &opt.ftp_user,          cmd_string },
 166   { "glob",             &opt.ftp_glob,          cmd_boolean },
 167   { "header",           NULL,                   cmd_spec_header },
 168   { "htmlextension",    &opt.html_extension,    cmd_boolean },
 169   { "htmlify",          NULL,                   cmd_spec_htmlify },
 170   { "httpkeepalive",    &opt.http_keep_alive,   cmd_boolean },
 171   { "httppasswd",       &opt.http_passwd,       cmd_string }, /* deprecated */
 172   { "httppassword",     &opt.http_passwd,       cmd_string },
 173   { "httpproxy",        &opt.http_proxy,        cmd_string },
 174   { "httpsproxy",       &opt.https_proxy,       cmd_string },
 175   { "httpuser",         &opt.http_user,         cmd_string },
 176   { "ignorecase",       &opt.ignore_case,       cmd_boolean },
 177   { "ignorelength",     &opt.ignore_length,     cmd_boolean },
 178   { "ignoretags",       &opt.ignore_tags,       cmd_vector },
 179   { "includedirectories", &opt.includes,        cmd_directory_vector },
 180 #ifdef ENABLE_IPV6
 181   { "inet4only",        &opt.ipv4_only,         cmd_boolean },
 182   { "inet6only",        &opt.ipv6_only,         cmd_boolean },
 183 #endif
 184   { "input",            &opt.input_filename,    cmd_file },
 185   { "iri",              &opt.enable_iri,        cmd_boolean },
 186   { "keepsessioncookies", &opt.keep_session_cookies, cmd_boolean },
 187   { "limitrate",        &opt.limit_rate,        cmd_bytes },
 188   { "loadcookies",      &opt.cookies_input,     cmd_file },
 189   { "locale",           &opt.locale,            cmd_string },
 190   { "logfile",          &opt.lfilename,         cmd_file },
 191   { "login",            &opt.ftp_user,          cmd_string },/* deprecated*/
 192   { "maxredirect",      &opt.max_redirect,      cmd_number },
 193   { "mirror",           NULL,                   cmd_spec_mirror },
 194   { "netrc",            &opt.netrc,             cmd_boolean },
 195   { "noclobber",        &opt.noclobber,         cmd_boolean },
 196   { "noparent",         &opt.no_parent,         cmd_boolean },
 197   { "noproxy",          &opt.no_proxy,          cmd_vector },
 198   { "numtries",         &opt.ntry,              cmd_number_inf },/* deprecated*/
 199   { "outputdocument",   &opt.output_document,   cmd_file },
 200   { "pagerequisites",   &opt.page_requisites,   cmd_boolean },
 201   { "passiveftp",       &opt.ftp_pasv,          cmd_boolean },
 202   { "passwd",           &opt.ftp_passwd,        cmd_string },/* deprecated*/
 203   { "password",         &opt.passwd,            cmd_string },
 204   { "postdata",         &opt.post_data,         cmd_string },
 205   { "postfile",         &opt.post_file_name,    cmd_file },
 206   { "preferfamily",     NULL,                   cmd_spec_prefer_family },
 207   { "preservepermissions", &opt.preserve_perm,  cmd_boolean },
 208 #ifdef HAVE_SSL
 209   { "privatekey",       &opt.private_key,       cmd_file },
 210   { "privatekeytype",   &opt.private_key_type,  cmd_cert_type },
 211 #endif
 212   { "progress",         &opt.progress_type,     cmd_spec_progress },
 213   { "protocoldirectories", &opt.protocol_directories, cmd_boolean },
 214   { "proxypasswd",      &opt.proxy_passwd,      cmd_string }, /* deprecated */
 215   { "proxypassword",    &opt.proxy_passwd,      cmd_string },
 216   { "proxyuser",        &opt.proxy_user,        cmd_string },
 217   { "quiet",            &opt.quiet,             cmd_boolean },
 218   { "quota",            &opt.quota,             cmd_bytes_sum },
 219 #ifdef HAVE_SSL
 220   { "randomfile",       &opt.random_file,       cmd_file },
 221 #endif
 222   { "randomwait",       &opt.random_wait,       cmd_boolean },
 223   { "readtimeout",      &opt.read_timeout,      cmd_time },
 224   { "reclevel",         &opt.reclevel,          cmd_number_inf },
 225   { "recursive",        NULL,                   cmd_spec_recursive },
 226   { "referer",          &opt.referer,           cmd_string },
 227   { "reject",           &opt.rejects,           cmd_vector },
 228   { "relativeonly",     &opt.relative_only,     cmd_boolean },
 229   { "remoteencoding",   &opt.encoding_remote,   cmd_string },
 230   { "removelisting",    &opt.remove_listing,    cmd_boolean },
 231   { "restrictfilenames", NULL,                  cmd_spec_restrict_file_names },
 232   { "retrsymlinks",     &opt.retr_symlinks,     cmd_boolean },
 233   { "retryconnrefused", &opt.retry_connrefused, cmd_boolean },
 234   { "robots",           &opt.use_robots,        cmd_boolean },
 235   { "savecookies",      &opt.cookies_output,    cmd_file },
 236   { "saveheaders",      &opt.save_headers,      cmd_boolean },
 237 #ifdef HAVE_SSL
 238   { "secureprotocol",   &opt.secure_protocol,   cmd_spec_secure_protocol },
 239 #endif
 240   { "serverresponse",   &opt.server_response,   cmd_boolean },
 241   { "spanhosts",        &opt.spanhost,          cmd_boolean },
 242   { "spider",           &opt.spider,            cmd_boolean },
 243   { "strictcomments",   &opt.strict_comments,   cmd_boolean },
 244   { "timeout",          NULL,                   cmd_spec_timeout },
 245   { "timestamping",     &opt.timestamping,      cmd_boolean },
 246   { "tries",            &opt.ntry,              cmd_number_inf },
 247   { "useproxy",         &opt.use_proxy,         cmd_boolean },
 248   { "user",             &opt.user,              cmd_string },
 249   { "useragent",        NULL,                   cmd_spec_useragent },
 250   { "verbose",          NULL,                   cmd_spec_verbose },
 251   { "wait",             &opt.wait,              cmd_time },
 252   { "waitretry",        &opt.waitretry,         cmd_time },
 253 #ifdef MSDOS
 254   { "wdebug",           &opt.wdebug,            cmd_boolean },
 255 #endif
 256 };
 257
 258 /* Look up CMDNAME in the commands[] and return its position in the
 259    array.  If CMDNAME is not found, return -1.  */
 260
 261 static int
 262 command_by_name (const char *cmdname)
 263 {
 264   /* Use binary search for speed.  Wget has ~100 commands, which
 265      guarantees a worst case performance of 7 string comparisons.  */
 266   int lo = 0, hi = countof (commands) - 1;
 267
 268   while (lo <= hi)
 269     {
 270       int mid = (lo + hi) >> 1;
 271       int cmp = strcasecmp (cmdname, commands[mid].name);
 272       if (cmp < 0)
 273         hi = mid - 1;
 274       else if (cmp > 0)
 275         lo = mid + 1;
 276       else
 277         return mid;
 278     }
 279   return -1;
 280 }
 281 \f
 282 /* Reset the variables to default values.  */
 283 static void
 284 defaults (void)
 285 {
 286   char *tmp;
 287
 288   /* Most of the default values are 0 (and 0.0, NULL, and false).
 289      Just reset everything, and fill in the non-zero values.  Note
 290      that initializing pointers to NULL this way is technically
 291      illegal, but porting Wget to a machine where NULL is not all-zero
 292      bit pattern will be the least of the implementors' worries.  */
 293   xzero (opt);
 294
 295   opt.cookies = true;
 296   opt.verbose = -1;
 297   opt.ntry = 20;
 298   opt.reclevel = 5;
 299   opt.add_hostdir = true;
 300   opt.netrc = true;
 301   opt.ftp_glob = true;
 302   opt.htmlify = true;
 303   opt.http_keep_alive = true;
 304   opt.use_proxy = true;
 305   tmp = getenv ("no_proxy");
 306   if (tmp)
 307     opt.no_proxy = sepstring (tmp);
 308   opt.prefer_family = prefer_none;
 309   opt.allow_cache = true;
 310
 311   opt.read_timeout = 900;
 312   opt.use_robots = true;
 313
 314   opt.remove_listing = true;
 315
 316   opt.dot_bytes = 1024;
 317   opt.dot_spacing = 10;
 318   opt.dots_in_line = 50;
 319
 320   opt.dns_cache = true;
 321   opt.ftp_pasv = true;
 322
 323 #ifdef HAVE_SSL
 324   opt.check_cert = true;
 325 #endif
 326
 327   /* The default for file name restriction defaults to the OS type. */
 328 #if defined(WINDOWS) || defined(MSDOS) || defined(__CYGWIN__)
 329   opt.restrict_files_os = restrict_windows;
 330 #else
 331   opt.restrict_files_os = restrict_unix;
 332 #endif
 333   opt.restrict_files_ctrl = true;
 334   opt.restrict_files_case = restrict_no_case_restriction;
 335
 336   opt.max_redirect = 20;
 337
 338 #ifdef ENABLE_IRI
 339   opt.enable_iri = true;
 340 #else
 341   opt.enable_iri = false;
 342 #endif
 343   opt.locale = NULL;
 344   opt.encoding_remote = NULL;
 345 }
 346 \f
 347 /* Return the user's home directory (strdup-ed), or NULL if none is
 348    found.  */
 349 char *
 350 home_dir (void)
 351 {
 352   static char buf[PATH_MAX];
 353   static char *home;
 354
 355   if (!home)
 356     {
 357       home = getenv ("HOME");
 358       if (!home)
 359         {
 360 #if defined(MSDOS)
 361           /* Under MSDOS, if $HOME isn't defined, use the directory where
 362              `wget.exe' resides.  */
 363           const char *_w32_get_argv0 (void); /* in libwatt.a/pcconfig.c */
 364           char *p;
 365
 366           strcpy (buf, _w32_get_argv0 ());
 367           p = strrchr (buf, '/');            /* djgpp */
 368           if (!p)
 369             p = strrchr (buf, '\\');          /* others */
 370           assert (p);
 371           *p = '\0';
 372           home = buf;
 373 #elif !defined(WINDOWS)
 374           /* If HOME is not defined, try getting it from the password
 375              file.  */
 376           struct passwd *pwd = getpwuid (getuid ());
 377           if (!pwd || !pwd->pw_dir)
 378             return NULL;
 379           strcpy (buf, pwd->pw_dir);
 380           home = buf;
 381 #else  /* !WINDOWS */
 382           /* Under Windows, if $HOME isn't defined, use the directory where
 383              `wget.exe' resides.  */
 384           home = ws_mypath ();
 385 #endif /* WINDOWS */
 386         }
 387     }
 388
 389   return home ? xstrdup (home) : NULL;
 390 }
 391
 392 /* Check the 'WGETRC' environment variable and return the file name
 393    if  'WGETRC' is set and is a valid file.
 394    If the `WGETRC' variable exists but the file does not exist, the
 395    function will exit().  */
 396 char *
 397 wgetrc_env_file_name (void)
 398 {
 399   char *env = getenv ("WGETRC");
 400   if (env && *env)
 401     {
 402       if (!file_exists_p (env))
 403         {
 404           fprintf (stderr, _("%s: WGETRC points to %s, which doesn't exist.\n"),
 405                    exec_name, env);
 406           exit (1);
 407         }
 408       return xstrdup (env);
 409     }
 410   return NULL;
 411 }
 412
 413 /* Check for the existance of '$HOME/.wgetrc' and return it's path
 414    if it exists and is set.  */
 415 char *
 416 wgetrc_user_file_name (void)
 417 {
 418   char *home = home_dir ();
 419   char *file = NULL;
 420   if (home)
 421     file = aprintf ("%s/.wgetrc", home);
 422   xfree_null (home);
 423   if (!file)
 424     return NULL;
 425   if (!file_exists_p (file))
 426     {
 427       xfree (file);
 428       return NULL;
 429     }
 430   return file;
 431 }
 432
 433 /* Return the path to the user's .wgetrc.  This is either the value of
 434    `WGETRC' environment variable, or `$HOME/.wgetrc'.
 435
 436    Additionally, for windows, look in the directory where wget.exe
 437    resides.  */
 438 char *
 439 wgetrc_file_name (void)
 440 {
 441   char *home = NULL;
 442   char *file = wgetrc_env_file_name ();
 443   if (file && *file)
 444     return file;
 445
 446   file = wgetrc_user_file_name ();
 447
 448 #ifdef WINDOWS
 449   /* Under Windows, if we still haven't found .wgetrc, look for the file
 450      `wget.ini' in the directory where `wget.exe' resides; we do this for
 451      backward compatibility with previous versions of Wget.
 452      SYSTEM_WGETRC should not be defined under WINDOWS.  */
 453   home = home_dir ();
 454   if (!file || !file_exists_p (file))
 455     {
 456       xfree_null (file);
 457       file = NULL;
 458       home = ws_mypath ();
 459       if (home)
 460         file = aprintf ("%s/wget.ini", home);
 461     }
 462   xfree_null (home);
 463 #endif /* WINDOWS */
 464
 465   if (!file)
 466     return NULL;
 467   if (!file_exists_p (file))
 468     {
 469       xfree (file);
 470       return NULL;
 471     }
 472   return file;
 473 }
 474
 475 /* Return values of parse_line. */
 476 enum parse_line {
 477   line_ok,
 478   line_empty,
 479   line_syntax_error,
 480   line_unknown_command
 481 };
 482
 483 static enum parse_line parse_line (const char *, char **, char **, int *);
 484 static bool setval_internal (int, const char *, const char *);
 485
 486 /* Initialize variables from a wgetrc file.  Returns zero (failure) if
 487    there were errors in the file.  */
 488
 489 static bool
 490 run_wgetrc (const char *file)
 491 {
 492   FILE *fp;
 493   char *line;
 494   int ln;
 495   int errcnt = 0;
 496
 497   fp = fopen (file, "rb");
 498   if (!fp)
 499     {
 500       fprintf (stderr, _("%s: Cannot read %s (%s).\n"), exec_name,
 501                file, strerror (errno));
 502       return true;                      /* not a fatal error */
 503     }
 504   enable_tilde_expansion = true;
 505   ln = 1;
 506   while ((line = read_whole_line (fp)) != NULL)
 507     {
 508       char *com = NULL, *val = NULL;
 509       int comind;
 510
 511       /* Parse the line.  */
 512       switch (parse_line (line, &com, &val, &comind))
 513         {
 514         case line_ok:
 515           /* If everything is OK, set the value.  */
 516           if (!setval_internal (comind, com, val))
 517             {
 518               fprintf (stderr, _("%s: Error in %s at line %d.\n"),
 519                        exec_name, file, ln);
 520               ++errcnt;
 521             }
 522           break;
 523         case line_syntax_error:
 524           fprintf (stderr, _("%s: Syntax error in %s at line %d.\n"),
 525                    exec_name, file, ln);
 526           ++errcnt;
 527           break;
 528         case line_unknown_command:
 529           fprintf (stderr, _("%s: Unknown command %s in %s at line %d.\n"),
 530                    exec_name, quote (com), file, ln);
 531           ++errcnt;
 532           break;
 533         case line_empty:
 534           break;
 535         default:
 536           abort ();
 537         }
 538       xfree_null (com);
 539       xfree_null (val);
 540       xfree (line);
 541       ++ln;
 542     }
 543   enable_tilde_expansion = false;
 544   fclose (fp);
 545
 546   return errcnt == 0;
 547 }
 548
 549 /* Initialize the defaults and run the system wgetrc and user's own
 550    wgetrc.  */
 551 void
 552 initialize (void)
 553 {
 554   char *file;
 555   int ok = true;
 556
 557   /* Load the hard-coded defaults.  */
 558   defaults ();
 559
 560   /* If SYSTEM_WGETRC is defined, use it.  */
 561 #ifdef SYSTEM_WGETRC
 562   if (file_exists_p (SYSTEM_WGETRC))
 563     ok &= run_wgetrc (SYSTEM_WGETRC);
 564 #endif
 565   /* Override it with your own, if one exists.  */
 566   file = wgetrc_file_name ();
 567   if (!file)
 568     return;
 569   /* #### We should canonicalize `file' and SYSTEM_WGETRC with
 570      something like realpath() before comparing them with `strcmp'  */
 571 #ifdef SYSTEM_WGETRC
 572   if (!strcmp (file, SYSTEM_WGETRC))
 573     {
 574       fprintf (stderr, _("\
 575 %s: Warning: Both system and user wgetrc point to %s.\n"),
 576                exec_name, quote (file));
 577     }
 578   else
 579 #endif
 580     ok &= run_wgetrc (file);
 581
 582   /* If there were errors processing either `.wgetrc', abort. */
 583   if (!ok)
 584     exit (2);
 585
 586   xfree (file);
 587   return;
 588 }
 589
 590 /* Remove dashes and underscores from S, modifying S in the
 591    process. */
 592
 593 static void
 594 dehyphen (char *s)
 595 {
 596   char *t = s;                  /* t - tortoise */
 597   char *h = s;                  /* h - hare     */
 598   while (*h)
 599     if (*h == '_' || *h == '-')
 600       ++h;
 601     else
 602       *t++ = *h++;
 603   *t = '\0';
 604 }
 605
 606 /* Parse the line pointed by line, with the syntax:
 607    <sp>* command <sp>* = <sp>* value <sp>*
 608    Uses malloc to allocate space for command and value.
 609
 610    Returns one of line_ok, line_empty, line_syntax_error, or
 611    line_unknown_command.
 612
 613    In case of line_ok, *COM and *VAL point to freshly allocated
 614    strings, and *COMIND points to com's index.  In case of error or
 615    empty line, their values are unmodified.  */
 616
 617 static enum parse_line
 618 parse_line (const char *line, char **com, char **val, int *comind)
 619 {
 620   const char *p;
 621   const char *end = line + strlen (line);
 622   const char *cmdstart, *cmdend;
 623   const char *valstart, *valend;
 624
 625   char *cmdcopy;
 626   int ind;
 627
 628   /* Skip leading and trailing whitespace.  */
 629   while (*line && c_isspace (*line))
 630     ++line;
 631   while (end > line && c_isspace (end[-1]))
 632     --end;
 633
 634   /* Skip empty lines and comments.  */
 635   if (!*line || *line == '#')
 636     return line_empty;
 637
 638   p = line;
 639
 640   cmdstart = p;
 641   while (p < end && (c_isalnum (*p) || *p == '_' || *p == '-'))
 642     ++p;
 643   cmdend = p;
 644
 645   /* Skip '=', as well as any space before or after it. */
 646   while (p < end && c_isspace (*p))
 647     ++p;
 648   if (p == end || *p != '=')
 649     return line_syntax_error;
 650   ++p;
 651   while (p < end && c_isspace (*p))
 652     ++p;
 653
 654   valstart = p;
 655   valend   = end;
 656
 657   /* The syntax is valid (even though the command might not be).  Fill
 658      in the command name and value.  */
 659   *com = strdupdelim (cmdstart, cmdend);
 660   *val = strdupdelim (valstart, valend);
 661
 662   /* The line now known to be syntactically correct.  Check whether
 663      the command is valid.  */
 664   BOUNDED_TO_ALLOCA (cmdstart, cmdend, cmdcopy);
 665   dehyphen (cmdcopy);
 666   ind = command_by_name (cmdcopy);
 667   if (ind == -1)
 668     return line_unknown_command;
 669
 670   /* Report success to the caller. */
 671   *comind = ind;
 672   return line_ok;
 673 }
 674
 675 /* Run commands[comind].action. */
 676
 677 static bool
 678 setval_internal (int comind, const char *com, const char *val)
 679 {
 680   assert (0 <= comind && ((size_t) comind) < countof (commands));
 681   DEBUGP (("Setting %s (%s) to %s\n", com, commands[comind].name, val));
 682   return commands[comind].action (com, val, commands[comind].place);
 683 }
 684
 685 /* Run command COM with value VAL.  If running the command produces an
 686    error, report the error and exit.
 687
 688    This is intended to be called from main() to modify Wget's behavior
 689    through command-line switches.  Since COM is hard-coded in main(),
 690    it is not canonicalized, and this aborts when COM is not found.
 691
 692    If COMIND's are exported to init.h, this function will be changed
 693    to accept COMIND directly.  */
 694
 695 void
 696 setoptval (const char *com, const char *val, const char *optname)
 697 {
 698   /* Prepend "--" to OPTNAME. */
 699   char *dd_optname = (char *) alloca (2 + strlen (optname) + 1);
 700   dd_optname[0] = '-';
 701   dd_optname[1] = '-';
 702   strcpy (dd_optname + 2, optname);
 703
 704   assert (val != NULL);
 705   if (!setval_internal (command_by_name (com), dd_optname, val))
 706     exit (2);
 707 }
 708
 709 /* Parse OPT into command and value and run it.  For example,
 710    run_command("foo=bar") is equivalent to setoptval("foo", "bar").
 711    This is used by the `--execute' flag in main.c.  */
 712
 713 void
 714 run_command (const char *opt)
 715 {
 716   char *com, *val;
 717   int comind;
 718   switch (parse_line (opt, &com, &val, &comind))
 719     {
 720     case line_ok:
 721       if (!setval_internal (comind, com, val))
 722         exit (2);
 723       xfree (com);
 724       xfree (val);
 725       break;
 726     default:
 727       fprintf (stderr, _("%s: Invalid --execute command %s\n"),
 728                exec_name, quote (opt));
 729       exit (2);
 730     }
 731 }
 732 \f
 733 /* Generic helper functions, for use with `commands'. */
 734
 735 /* Forward declarations: */
 736 struct decode_item {
 737   const char *name;
 738   int code;
 739 };
 740 static bool decode_string (const char *, const struct decode_item *, int, int *);
 741 static bool simple_atoi (const char *, const char *, int *);
 742 static bool simple_atof (const char *, const char *, double *);
 743
 744 #define CMP1(p, c0) (c_tolower((p)[0]) == (c0) && (p)[1] == '\0')
 745
 746 #define CMP2(p, c0, c1) (c_tolower((p)[0]) == (c0)        \
 747                          && c_tolower((p)[1]) == (c1)     \
 748                          && (p)[2] == '\0')
 749
 750 #define CMP3(p, c0, c1, c2) (c_tolower((p)[0]) == (c0)    \
 751                      && c_tolower((p)[1]) == (c1)         \
 752                      && c_tolower((p)[2]) == (c2)         \
 753                      && (p)[3] == '\0')
 754
 755
 756 /* Store the boolean value from VAL to PLACE.  COM is ignored,
 757    except for error messages.  */
 758 static bool
 759 cmd_boolean (const char *com, const char *val, void *place)
 760 {
 761   bool value;
 762
 763   if (CMP2 (val, 'o', 'n') || CMP3 (val, 'y', 'e', 's') || CMP1 (val, '1'))
 764     /* "on", "yes" and "1" mean true. */
 765     value = true;
 766   else if (CMP3 (val, 'o', 'f', 'f') || CMP2 (val, 'n', 'o') || CMP1 (val, '0'))
 767     /* "off", "no" and "0" mean false. */
 768     value = false;
 769   else
 770     {
 771       fprintf (stderr,
 772                _("%s: %s: Invalid boolean %s; use `on' or `off'.\n"),
 773                exec_name, com, quote (val));
 774       return false;
 775     }
 776
 777   *(bool *) place = value;
 778   return true;
 779 }
 780
 781 /* Set the non-negative integer value from VAL to PLACE.  With
 782    incorrect specification, the number remains unchanged.  */
 783 static bool
 784 cmd_number (const char *com, const char *val, void *place)
 785 {
 786   if (!simple_atoi (val, val + strlen (val), place)
 787       || *(int *) place < 0)
 788     {
 789       fprintf (stderr, _("%s: %s: Invalid number %s.\n"),
 790                exec_name, com, quote (val));
 791       return false;
 792     }
 793   return true;
 794 }
 795
 796 /* Similar to cmd_number(), only accepts `inf' as a synonym for 0.  */
 797 static bool
 798 cmd_number_inf (const char *com, const char *val, void *place)
 799 {
 800   if (!strcasecmp (val, "inf"))
 801     {
 802       *(int *) place = 0;
 803       return true;
 804     }
 805   return cmd_number (com, val, place);
 806 }
 807
 808 /* Copy (strdup) the string at COM to a new location and place a
 809    pointer to *PLACE.  */
 810 static bool
 811 cmd_string (const char *com, const char *val, void *place)
 812 {
 813   char **pstring = (char **)place;
 814
 815   xfree_null (*pstring);
 816   *pstring = xstrdup (val);
 817   return true;
 818 }
 819
 820 #if defined(WINDOWS) || defined(MSDOS)
 821 # define ISSEP(c) ((c) == '/' || (c) == '\\')
 822 #else
 823 # define ISSEP(c) ((c) == '/')
 824 #endif
 825
 826 /* Like the above, but handles tilde-expansion when reading a user's
 827    `.wgetrc'.  In that case, and if VAL begins with `~', the tilde
 828    gets expanded to the user's home directory.  */
 829 static bool
 830 cmd_file (const char *com, const char *val, void *place)
 831 {
 832   char **pstring = (char **)place;
 833
 834   xfree_null (*pstring);
 835
 836   /* #### If VAL is empty, perhaps should set *PLACE to NULL.  */
 837
 838   if (!enable_tilde_expansion || !(*val == '~' && ISSEP (val[1])))
 839     {
 840     noexpand:
 841       *pstring = xstrdup (val);
 842     }
 843   else
 844     {
 845       int homelen;
 846       char *home = home_dir ();
 847       if (!home)
 848         goto noexpand;
 849
 850       homelen = strlen (home);
 851       while (homelen && ISSEP (home[homelen - 1]))
 852         home[--homelen] = '\0';
 853
 854       /* Skip the leading "~/". */
 855       for (++val; ISSEP (*val); val++)
 856         ;
 857
 858       *pstring = concat_strings (home, "/", val, (char *) 0);
 859     }
 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