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) 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   { "ftpproxy",         &opt.ftp_proxy,         cmd_string },
 163   { "ftpuser",          &opt.ftp_user,          cmd_string },
 164   { "glob",             &opt.ftp_glob,          cmd_boolean },
 165   { "header",           NULL,                   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 (%s) to %s\n", com, commands[comind].name, 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, const char *optname)
 631 {
 632   /* Prepend "--" to OPTNAME. */
 633   char *dd_optname = (char *) alloca (2 + strlen (optname) + 1);
 634   dd_optname[0] = '-';
 635   dd_optname[1] = '-';
 636   strcpy (dd_optname + 2, optname);
 637
 638   assert (val != NULL);
 639   if (!setval_internal (command_by_name (com), dd_optname, val))
 640     exit (2);
 641 }
 642
 643 /* Parse OPT into command and value and run it.  For example,
 644    run_command("foo=bar") is equivalent to setoptval("foo", "bar").
 645    This is used by the `--execute' flag in main.c.  */
 646
 647 void
 648 run_command (const char *opt)
 649 {
 650   char *com, *val;
 651   int comind;
 652   switch (parse_line (opt, &com, &val, &comind))
 653     {
 654     case line_ok:
 655       if (!setval_internal (comind, com, val))
 656         exit (2);
 657       xfree (com);
 658       xfree (val);
 659       break;
 660     default:
 661       fprintf (stderr, _("%s: Invalid --execute command `%s'\n"),
 662                exec_name, opt);
 663       exit (2);
 664     }
 665 }
 666 \f
 667 /* Generic helper functions, for use with `commands'. */
 668
 669 /* Forward declarations: */
 670 struct decode_item {
 671   const char *name;
 672   int code;
 673 };
 674 static int decode_string PARAMS ((const char *, const struct decode_item *,
 675                                   int, int *));
 676 static int simple_atoi PARAMS ((const char *, const char *, int *));
 677 static int simple_atof PARAMS ((const char *, const char *, double *));
 678
 679 #define CMP1(p, c0) (TOLOWER((p)[0]) == (c0) && (p)[1] == '\0')
 680
 681 #define CMP2(p, c0, c1) (TOLOWER((p)[0]) == (c0)        \
 682                          && TOLOWER((p)[1]) == (c1)     \
 683                          && (p)[2] == '\0')
 684
 685 #define CMP3(p, c0, c1, c2) (TOLOWER((p)[0]) == (c0)    \
 686                      && TOLOWER((p)[1]) == (c1)         \
 687                      && TOLOWER((p)[2]) == (c2)         \
 688                      && (p)[3] == '\0')
 689
 690
 691 /* Store the boolean value from VAL to PLACE.  COM is ignored,
 692    except for error messages.  */
 693 static int
 694 cmd_boolean (const char *com, const char *val, void *place)
 695 {
 696   int bool_value;
 697
 698   if (CMP2 (val, 'o', 'n') || CMP3 (val, 'y', 'e', 's') || CMP1 (val, '1'))
 699     /* "on", "yes" and "1" mean true. */
 700     bool_value = 1;
 701   else if (CMP3 (val, 'o', 'f', 'f') || CMP2 (val, 'n', 'o') || CMP1 (val, '0'))
 702     /* "off", "no" and "0" mean false. */
 703     bool_value = 0;
 704   else
 705     {
 706       fprintf (stderr,
 707                _("%s: %s: Invalid boolean `%s'; use `on' or `off'.\n"),
 708                exec_name, com, val);
 709       return 0;
 710     }
 711
 712   *(int *)place = bool_value;
 713   return 1;
 714 }
 715
 716 /* Store the lockable_boolean {2, 1, 0, -1} value from VAL to PLACE.
 717    COM is ignored, except for error messages.  Values 2 and -1
 718    indicate that once defined, the value may not be changed by
 719    successive wgetrc files or command-line arguments.
 720
 721    Values: 2 - Enable a particular option for good ("always")
 722            1 - Enable an option ("on")
 723            0 - Disable an option ("off")
 724           -1 - Disable an option for good ("never")
 725
 726    #### This hack is currently only used for passive FTP because a
 727    contributor had broken scripts specify --passive-ftp where he
 728    didn't want it.  It should be removed because the same can now be
 729    achieved by replacing the wget executable with a script containing:
 730
 731        exec wget "$@" --no-passive-ftp
 732 */
 733
 734 static int
 735 cmd_lockable_boolean (const char *com, const char *val, void *place)
 736 {
 737   int lockable_boolean_value;
 738
 739   int oldval = *(int *)place;
 740
 741   /*
 742    * If a config file said "always" or "never", don't allow command line
 743    * arguments to override the config file.
 744    */
 745   if (oldval == -1 || oldval == 2)
 746     return 1;
 747
 748   if (CMP2 (val, 'o', 'n') || CMP3 (val, 'y', 'e', 's') || CMP1 (val, '1'))
 749     lockable_boolean_value = 1;
 750   else if (CMP3 (val, 'o', 'f', 'f') || CMP2 (val, 'n', 'o') || CMP1 (val, '0'))
 751     lockable_boolean_value = 0;
 752   else if (0 == strcasecmp (val, "always"))
 753     lockable_boolean_value = 2;
 754   else if (0 == strcasecmp (val, "never"))
 755     lockable_boolean_value = -1;
 756   else
 757     {
 758       fprintf (stderr,
 759                _("%s: %s: Invalid extended boolean `%s';\n\
 760 use one of `on', `off', `always', or `never'.\n"),
 761                exec_name, com, val);
 762       return 0;
 763     }
 764
 765   *(int *)place = lockable_boolean_value;
 766   return 1;
 767 }
 768
 769 /* Set the non-negative integer value from VAL to PLACE.  With
 770    incorrect specification, the number remains unchanged.  */
 771 static int
 772 cmd_number (const char *com, const char *val, void *place)
 773 {
 774   if (!simple_atoi (val, val + strlen (val), place)
 775       || *(int *) place < 0)
 776     {
 777       fprintf (stderr, _("%s: %s: Invalid number `%s'.\n"),
 778                exec_name, com, val);
 779       return 0;
 780     }
 781   return 1;
 782 }
 783
 784 /* Similar to cmd_number(), only accepts `inf' as a synonym for 0.  */
 785 static int
 786 cmd_number_inf (const char *com, const char *val, void *place)
 787 {
 788   if (!strcasecmp (val, "inf"))
 789     {
 790       *(int *)place = 0;
 791       return 1;
 792     }
 793   return cmd_number (com, val, place);
 794 }
 795
 796 /* Copy (strdup) the string at COM to a new location and place a
 797    pointer to *PLACE.  */
 798 static int
 799 cmd_string (const char *com, const char *val, void *place)
 800 {
 801   char **pstring = (char **)place;
 802
 803   xfree_null (*pstring);
 804   *pstring = xstrdup (val);
 805   return 1;
 806 }
 807
 808 #ifndef WINDOWS
 809 # define ISSEP(c) ((c) == '/')
 810 #else
 811 # define ISSEP(c) ((c) == '/' || (c) == '\\')
 812 #endif
 813
 814 /* Like the above, but handles tilde-expansion when reading a user's
 815    `.wgetrc'.  In that case, and if VAL begins with `~', the tilde
 816    gets expanded to the user's home directory.  */
 817 static int
 818 cmd_file (const char *com, const char *val, void *place)
 819 {
 820   char **pstring = (char **)place;
 821
 822   xfree_null (*pstring);
 823
 824   /* #### If VAL is empty, perhaps should set *PLACE to NULL.  */
 825
 826   if (!enable_tilde_expansion || !(*val == '~' && ISSEP (val[1])))
 827     {
 828     noexpand:
 829       *pstring = xstrdup (val);
 830     }
 831   else
 832     {
 833       int homelen;
 834       char *home = home_dir ();
 835       if (!home)
 836         goto noexpand;
 837
 838       homelen = strlen (home);
 839       while (homelen && ISSEP (home[homelen - 1]))
 840         home[--homelen] = '\0';
 841
 842       /* Skip the leading "~/". */
 843       for (++val; ISSEP (*val); val++)
 844         ;
 845
 846       *pstring = concat_strings (home, "/", val, (char *) 0);
 847     }
 848
 849 #ifdef WINDOWS
 850   /* Convert "\" to "/". */
 851   {
 852     char *s;
 853     for (s = *pstring; *s; s++)
 854       if (*s == '\\')
 855         *s = '/';
 856   }
 857 #endif
 858   return 1;
 859 }
 860
 861 /* Like cmd_file, but strips trailing '/' characters.  */
 862 static int
 863 cmd_directory (const char *com, const char *val, void *place)
 864 {
 865   char *s, *t;
 866
 867   /* Call cmd_file() for tilde expansion and separator
 868      canonicalization (backslash -> slash under Windows).  These
 869      things should perhaps be in a separate function.  */
 870   if (!cmd_file (com, val, place))
 871     return 0;
 872
 873   s = *(char **)place;
 874   t = s + strlen (s);
 875   while (t > s && *--t == '/')
 876     *t = '\0';
 877
 878   return 1;
 879 }
 880
 881 /* Split VAL by space to a vector of values, and append those values
 882    to vector pointed to by the PLACE argument.  If VAL is empty, the
 883    PLACE vector is cleared instead.  */
 884
 885 static int
 886 cmd_vector (const char *com, const char *val, void *place)
 887 {
 888   char ***pvec = (char ***)place;
 889
 890   if (*val)
 891     *pvec = merge_vecs (*pvec, sepstring (val));
 892   else
 893     {
 894       free_vec (*pvec);
 895       *pvec = NULL;
 896     }
 897   return 1;
 898 }
 899
 900 static int
 901 cmd_directory_vector (const char *com, const char *val, void *place)
 902 {
 903   char ***pvec = (char ***)place;
 904
 905   if (*val)
 906     {
 907       /* Strip the trailing slashes from directories.  */
 908       char **t, **seps;
 909
 910       seps = sepstring (val);
 911       for (t = seps; t && *t; t++)
 912         {
 913           int len = strlen (*t);
 914           /* Skip degenerate case of root directory.  */
 915           if (len > 1)
 916             {
 917               if ((*t)[len - 1] == '/')
 918                 (*t)[len - 1] = '\0';
 919             }
 920         }
 921       *pvec = merge_vecs (*pvec, seps);
 922     }
 923   else
 924     {
 925       free_vec (*pvec);
 926       *pvec = NULL;
 927     }
 928   return 1;
 929 }
 930
 931 /* Engine for cmd_bytes and cmd_bytes_large: converts a string such as
 932    "100k" or "2.5G" to a floating point number.  */
 933
 934 static int
 935 parse_bytes_helper (const char *val, double *result)
 936 {
 937   double number, mult;
 938   const char *end = val + strlen (val);
 939
 940   /* Check for "inf".  */
 941   if (0 == strcmp (val, "inf"))
 942     {
 943       *result = 0;
 944       return 1;
 945     }
 946
 947   /* Strip trailing whitespace.  */
 948   while (val < end && ISSPACE (end[-1]))
 949     --end;
 950   if (val == end)
 951     return 0;
 952
 953   switch (TOLOWER (end[-1]))
 954     {
 955     case 'k':
 956       --end, mult = 1024.0;
 957       break;
 958     case 'm':
 959       --end, mult = 1048576.0;
 960       break;
 961     case 'g':
 962       --end, mult = 1073741824.0;
 963       break;
 964     case 't':
 965       --end, mult = 1099511627776.0;
 966       break;
 967     default:
 968       /* Not a recognized suffix: assume it's a digit.  (If not,
 969          simple_atof will raise an error.)  */
 970       mult = 1;
 971     }
 972
 973   /* Skip leading and trailing whitespace. */
 974   while (val < end && ISSPACE (*val))
 975     ++val;
 976   while (val < end && ISSPACE (end[-1]))
 977     --end;
 978   if (val == end)
 979     return 0;
 980
 981   if (!simple_atof (val, end, &number) || number < 0)
 982     return 0;
 983
 984   *result = number * mult;
 985   return 1;
 986 }
 987
 988 /* Parse VAL as a number and set its value to PLACE (which should
 989    point to a wgint).
 990
 991    By default, the value is assumed to be in bytes.  If "K", "M", or
 992    "G" are appended, the value is multiplied with 1<<10, 1<<20, or
 993    1<<30, respectively.  Floating point values are allowed and are
 994    cast to integer before use.  The idea is to be able to use things
 995    like 1.5k instead of "1536".
 996
 997    The string "inf" is returned as 0.
 998
 999    In case of error, 0 is returned and memory pointed to by PLACE
1000    remains unmodified.  */
1001
1002 static int
1003 cmd_bytes (const char *com, const char *val, void *place)
1004 {
1005   double byte_value;
1006   if (!parse_bytes_helper (val, &byte_value))
1007     {
1008       fprintf (stderr, _("%s: %s: Invalid byte value `%s'\n"),
1009                exec_name, com, val);
1010       return 0;
1011     }
1012   *(wgint *)place = (wgint)byte_value;
1013   return 1;
1014 }
1015
1016 /* Like cmd_bytes, but PLACE is interpreted as a pointer to
1017    LARGE_INT.  It works by converting the string to double, therefore
1018    working with values up to 2^53-1 without loss of precision.  This
1019    value (8192 TB) is large enough to serve for a while.  */
1020
1021 static int
1022 cmd_bytes_large (const char *com, const char *val, void *place)
1023 {
1024   double byte_value;
1025   if (!parse_bytes_helper (val, &byte_value))
1026     {
1027       fprintf (stderr, _("%s: %s: Invalid byte value `%s'\n"),
1028                exec_name, com, val);
1029       return 0;
1030     }
1031   *(LARGE_INT *)place = (LARGE_INT)byte_value;
1032   return 1;
1033 }
1034
1035 /* Store the value of VAL to *OUT.  The value is a time period, by
1036    default expressed in seconds, but also accepting suffixes "m", "h",
1037    "d", and "w" for minutes, hours, days, and weeks respectively.  */
1038
1039 static int
1040 cmd_time (const char *com, const char *val, void *place)
1041 {
1042   double number, mult;
1043   const char *end = val + strlen (val);
1044
1045   /* Strip trailing whitespace.  */
1046   while (val < end && ISSPACE (end[-1]))
1047     --end;
1048
1049   if (val == end)
1050     {
1051     err:
1052       fprintf (stderr, _("%s: %s: Invalid time period `%s'\n"),
1053                exec_name, com, val);
1054       return 0;
1055     }
1056
1057   switch (TOLOWER (end[-1]))
1058     {
1059     case 's':
1060       --end, mult = 1;          /* seconds */
1061       break;
1062     case 'm':
1063       --end, mult = 60;         /* minutes */
1064       break;
1065     case 'h':
1066       --end, mult = 3600;       /* hours */
1067       break;
1068     case 'd':
1069       --end, mult = 86400.0;    /* days */
1070       break;
1071     case 'w':
1072       --end, mult = 604800.0;   /* weeks */
1073       break;
1074     default:
1075       /* Not a recognized suffix: assume it belongs to the number.
1076          (If not, simple_atof will raise an error.)  */
1077       mult = 1;
1078     }
1079
1080   /* Skip leading and trailing whitespace. */
1081   while (val < end && ISSPACE (*val))
1082     ++val;
1083   while (val < end && ISSPACE (end[-1]))
1084     --end;
1085   if (val == end)
1086     goto err;
1087
1088   if (!simple_atof (val, end, &number))
1089     goto err;
1090
1091   *(double *)place = number * mult;
1092   return 1;
1093 }
1094
1095 #ifdef HAVE_SSL
1096 static int
1097 cmd_cert_type (const char *com, const char *val, void *place)
1098 {
1099   static const struct decode_item choices[] = {
1100     { "pem", keyfile_pem },
1101     { "der", keyfile_asn1 },
1102     { "asn1", keyfile_asn1 },
1103   };
1104   int ok = decode_string (val, choices, countof (choices), place);
1105   if (!ok)
1106     fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
1107   return ok;
1108 }
1109 #endif
1110 \f
1111 /* Specialized helper functions, used by `commands' to handle some
1112    options specially.  */
1113
1114 static int check_user_specified_header PARAMS ((const char *));
1115
1116 static int
1117 cmd_spec_dirstruct (const char *com, const char *val, void *place_ignored)
1118 {
1119   if (!cmd_boolean (com, val, &opt.dirstruct))
1120     return 0;
1121   /* Since dirstruct behaviour is explicitly changed, no_dirstruct
1122      must be affected inversely.  */
1123   if (opt.dirstruct)
1124     opt.no_dirstruct = 0;
1125   else
1126     opt.no_dirstruct = 1;
1127   return 1;
1128 }
1129
1130 static int
1131 cmd_spec_header (const char *com, const char *val, void *place_ignored)
1132 {
1133   /* Empty value means reset the list of headers. */
1134   if (*val == '\0')
1135     {
1136       free_vec (opt.user_headers);
1137       opt.user_headers = NULL;
1138       return 1;
1139     }
1140
1141   if (!check_user_specified_header (val))
1142     {
1143       fprintf (stderr, _("%s: %s: Invalid header `%s'.\n"),
1144                exec_name, com, val);
1145       return 0;
1146     }
1147   opt.user_headers = vec_append (opt.user_headers, val);
1148   return 1;
1149 }
1150
1151 static int
1152 cmd_spec_htmlify (const char *com, const char *val, void *place_ignored)
1153 {
1154   int flag = cmd_boolean (com, val, &opt.htmlify);
1155   if (flag && !opt.htmlify)
1156     opt.remove_listing = 0;
1157   return flag;
1158 }
1159
1160 /* Set the "mirror" mode.  It means: recursive download, timestamping,
1161    no limit on max. recursion depth, and don't remove listings.  */
1162
1163 static int
1164 cmd_spec_mirror (const char *com, const char *val, void *place_ignored)
1165 {
1166   int mirror;
1167
1168   if (!cmd_boolean (com, val, &mirror))
1169     return 0;
1170   if (mirror)
1171     {
1172       opt.recursive = 1;
1173       if (!opt.no_dirstruct)
1174         opt.dirstruct = 1;
1175       opt.timestamping = 1;
1176       opt.reclevel = INFINITE_RECURSION;
1177       opt.remove_listing = 0;
1178     }
1179   return 1;
1180 }
1181
1182 /* Validate --prefer-family and set the choice.  Allowed values are
1183    "IPv4", "IPv6", and "none".  */
1184
1185 static int
1186 cmd_spec_prefer_family (const char *com, const char *val, void *place_ignored)
1187 {
1188   static const struct decode_item choices[] = {
1189     { "IPv4", prefer_ipv4 },
1190     { "IPv6", prefer_ipv6 },
1191     { "none", prefer_none },
1192   };
1193   int ok = decode_string (val, choices, countof (choices),
1194                           (int *) &opt.prefer_family);
1195   if (!ok)
1196     fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
1197   return ok;
1198 }
1199
1200 /* Set progress.type to VAL, but verify that it's a valid progress
1201    implementation before that.  */
1202
1203 static int
1204 cmd_spec_progress (const char *com, const char *val, void *place_ignored)
1205 {
1206   if (!valid_progress_implementation_p (val))
1207     {
1208       fprintf (stderr, _("%s: %s: Invalid progress type `%s'.\n"),
1209                exec_name, com, val);
1210       return 0;
1211     }
1212   xfree_null (opt.progress_type);
1213
1214   /* Don't call set_progress_implementation here.  It will be called
1215      in main() when it becomes clear what the log output is.  */
1216   opt.progress_type = xstrdup (val);
1217   return 1;
1218 }
1219
1220 /* Set opt.recursive to VAL as with cmd_boolean.  If opt.recursive is
1221    set to true, also set opt.dirstruct to 1, unless opt.no_dirstruct
1222    is specified.  */
1223
1224 static int
1225 cmd_spec_recursive (const char *com, const char *val, void *place_ignored)
1226 {
1227   if (!cmd_boolean (com, val, &opt.recursive))
1228     return 0;
1229   else
1230     {
1231       if (opt.recursive && !opt.no_dirstruct)
1232         opt.dirstruct = 1;
1233     }
1234   return 1;
1235 }
1236
1237 static int
1238 cmd_spec_restrict_file_names (const char *com, const char *val, void *place_ignored)
1239 {
1240   int restrict_os = opt.restrict_files_os;
1241   int restrict_ctrl = opt.restrict_files_ctrl;
1242
1243   const char *end = strchr (val, ',');
1244   if (!end)
1245     end = val + strlen (val);
1246
1247 #define VAL_IS(string_literal) BOUNDED_EQUAL (val, end, string_literal)
1248
1249   if (VAL_IS ("unix"))
1250     restrict_os = restrict_unix;
1251   else if (VAL_IS ("windows"))
1252     restrict_os = restrict_windows;
1253   else if (VAL_IS ("nocontrol"))
1254     restrict_ctrl = 0;
1255   else
1256     {
1257     err:
1258       fprintf (stderr,
1259                _("%s: %s: Invalid restriction `%s', use `unix' or `windows'.\n"),
1260                exec_name, com, val);
1261       return 0;
1262     }
1263
1264 #undef VAL_IS
1265
1266   if (*end)
1267     {
1268       if (!strcmp (end + 1, "nocontrol"))
1269         restrict_ctrl = 0;
1270       else
1271         goto err;
1272     }
1273
1274   opt.restrict_files_os = restrict_os;
1275   opt.restrict_files_ctrl = restrict_ctrl;
1276   return 1;
1277 }
1278
1279 #ifdef HAVE_SSL
1280 static int
1281 cmd_spec_secure_protocol (const char *com, const char *val, void *place)
1282 {
1283   static const struct decode_item choices[] = {
1284     { "auto", secure_protocol_auto },
1285     { "sslv2", secure_protocol_sslv2 },
1286     { "sslv3", secure_protocol_sslv3 },
1287     { "tlsv1", secure_protocol_tlsv1 },
1288   };
1289   int ok = decode_string (val, choices, countof (choices), place);
1290   if (!ok)
1291     fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
1292   return ok;
1293 }
1294 #endif
1295
1296 /* Set all three timeout values. */
1297
1298 static int
1299 cmd_spec_timeout (const char *com, const char *val, void *place_ignored)
1300 {
1301   double value;
1302   if (!cmd_time (com, val, &value))
1303     return 0;
1304   opt.read_timeout = value;
1305   opt.connect_timeout = value;
1306   opt.dns_timeout = value;
1307   return 1;
1308 }
1309
1310 static int
1311 cmd_spec_useragent (const char *com, const char *val, void *place_ignored)
1312 {
1313   /* Disallow embedded newlines.  */
1314   if (strchr (val, '\n'))
1315     {
1316       fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"),
1317                exec_name, com, val);
1318       return 0;
1319     }
1320   xfree_null (opt.useragent);
1321   opt.useragent = xstrdup (val);
1322   return 1;
1323 }
1324 \f
1325 /* Miscellaneous useful routines.  */
1326
1327 /* A very simple atoi clone, more useful than atoi because it works on
1328    delimited strings, and has error reportage.  Returns 1 on success,
1329    0 on failure.  If successful, stores result to *DEST.  */
1330
1331 static int
1332 simple_atoi (const char *beg, const char *end, int *dest)
1333 {
1334   int result = 0;
1335   int negative = 0;
1336   const char *p = beg;
1337
1338   while (p < end && ISSPACE (*p))
1339     ++p;
1340   if (p < end && (*p == '-' || *p == '+'))
1341     {
1342       negative = (*p == '-');
1343       ++p;
1344     }
1345   if (p == end)
1346     return 0;
1347
1348   /* Read negative numbers in a separate loop because the most
1349      negative integer cannot be represented as a positive number.  */
1350
1351   if (!negative)
1352     for (; p < end && ISDIGIT (*p); p++)
1353       {
1354         int next = (10 * result) + (*p - '0');
1355         if (next < result)
1356           return 0;             /* overflow */
1357         result = next;
1358       }
1359   else
1360     for (; p < end && ISDIGIT (*p); p++)
1361       {
1362         int next = (10 * result) - (*p - '0');
1363         if (next > result)
1364           return 0;             /* underflow */
1365         result = next;
1366       }
1367
1368   if (p != end)
1369     return 0;
1370
1371   *dest = result;
1372   return 1;
1373 }
1374
1375 /* Trivial atof, with error reporting.  Handles "<digits>[.<digits>]",
1376    doesn't handle exponential notation.  Returns 1 on success, 0 on
1377    failure.  In case of success, stores its result to *DEST.  */
1378
1379 static int
1380 simple_atof (const char *beg, const char *end, double *dest)
1381 {
1382   double result = 0;
1383
1384   int negative = 0;
1385   int seen_dot = 0;
1386   int seen_digit = 0;
1387   double divider = 1;
1388
1389   const char *p = beg;
1390
1391   while (p < end && ISSPACE (*p))
1392     ++p;
1393   if (p < end && (*p == '-' || *p == '+'))
1394     {
1395       negative = (*p == '-');
1396       ++p;
1397     }
1398
1399   for (; p < end; p++)
1400     {
1401       char ch = *p;
1402       if (ISDIGIT (ch))
1403         {
1404           if (!seen_dot)
1405             result = (10 * result) + (ch - '0');
1406           else
1407             result += (ch - '0') / (divider *= 10);
1408           seen_digit = 1;
1409         }
1410       else if (ch == '.')
1411         {
1412           if (!seen_dot)
1413             seen_dot = 1;
1414           else
1415             return 0;
1416         }
1417       else
1418         return 0;
1419     }
1420   if (!seen_digit)
1421     return 0;
1422   if (negative)
1423     result = -result;
1424
1425   *dest = result;
1426   return 1;
1427 }
1428
1429 /* Verify that the user-specified header in S is valid.  It must
1430    contain a colon preceded by non-white-space characters and must not
1431    contain newlines.  */
1432
1433 static int
1434 check_user_specified_header (const char *s)
1435 {
1436   const char *p;
1437
1438   for (p = s; *p && *p != ':' && !ISSPACE (*p); p++);
1439   /* The header MUST contain `:' preceded by at least one
1440      non-whitespace character.  */
1441   if (*p != ':' || p == s)
1442     return 0;
1443   /* The header MUST NOT contain newlines.  */
1444   if (strchr (s, '\n'))
1445     return 0;
1446   return 1;
1447 }
1448
1449 /* Decode VAL into a number, according to ITEMS. */
1450
1451 static int
1452 decode_string (const char *val, const struct decode_item *items, int itemcount,
1453                int *place)
1454 {
1455   int i;
1456   for (i = 0; i < itemcount; i++)
1457     if (0 == strcasecmp (val, items[i].name))
1458       {
1459         *place = items[i].code;
1460         return 1;
1461       }
1462   return 0;
1463 }
1464
1465 \f
1466 void cleanup_html_url PARAMS ((void));
1467 void http_cleanup PARAMS ((void));
1468
1469
1470 /* Free the memory allocated by global variables.  */
1471 void
1472 cleanup (void)
1473 {
1474   /* Free external resources, close files, etc. */
1475
1476   {
1477     extern FILE *output_stream;
1478     if (output_stream)
1479       fclose (output_stream);
1480     /* No need to check for error because Wget flushes its output (and
1481        checks for errors) after any data arrives.  */
1482   }
1483
1484   /* We're exiting anyway so there's no real need to call free()
1485      hundreds of times.  Skipping the frees will make Wget exit
1486      faster.
1487
1488      However, when detecting leaks, it's crucial to free() everything
1489      because then you can find the real leaks, i.e. the allocated
1490      memory which grows with the size of the program.  */
1491
1492 #ifdef DEBUG_MALLOC
1493   convert_cleanup ();
1494   res_cleanup ();
1495   http_cleanup ();
1496   cleanup_html_url ();
1497   host_cleanup ();
1498   log_cleanup ();
1499
1500   {
1501     extern acc_t *netrc_list;
1502     free_netrc (netrc_list);
1503   }
1504   xfree_null (opt.lfilename);
1505   xfree_null (opt.dir_prefix);
1506   xfree_null (opt.input_filename);
1507   xfree_null (opt.output_document);
1508   free_vec (opt.accepts);
1509   free_vec (opt.rejects);
1510   free_vec (opt.excludes);
1511   free_vec (opt.includes);
1512   free_vec (opt.domains);
1513   free_vec (opt.follow_tags);
1514   free_vec (opt.ignore_tags);
1515   xfree_null (opt.progress_type);
1516   xfree_null (opt.ftp_user);
1517   xfree_null (opt.ftp_passwd);
1518   xfree_null (opt.ftp_proxy);
1519   xfree_null (opt.https_proxy);
1520   xfree_null (opt.http_proxy);
1521   free_vec (opt.no_proxy);
1522   xfree_null (opt.useragent);
1523   xfree_null (opt.referer);
1524   xfree_null (opt.http_user);
1525   xfree_null (opt.http_passwd);
1526   free_vec (opt.user_headers);
1527 # ifdef HAVE_SSL
1528   xfree_null (opt.cert_file);
1529   xfree_null (opt.private_key);
1530   xfree_null (opt.ca_directory);
1531   xfree_null (opt.ca_cert);
1532   xfree_null (opt.random_file);
1533   xfree_null (opt.egd_file);
1534 # endif
1535   xfree_null (opt.bind_address);
1536   xfree_null (opt.cookies_input);
1537   xfree_null (opt.cookies_output);
1538   xfree_null (opt.user);
1539   xfree_null (opt.passwd);
1540 #endif /* DEBUG_MALLOC */
1541 }