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

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