/* Reading/parsing the initialization file.
- Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001
+ Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2003
Free Software Foundation, Inc.
This file is part of GNU Wget.
#endif
#ifdef HAVE_PWD_H
-#include <pwd.h>
+# include <pwd.h>
#endif
+#include <assert.h>
#include "wget.h"
#include "utils.h"
#include "init.h"
#include "host.h"
-#include "recur.h"
#include "netrc.h"
#include "cookies.h" /* for cookie_jar_delete */
#include "progress.h"
CMD_DECLARE (cmd_spec_progress);
CMD_DECLARE (cmd_spec_recursive);
CMD_DECLARE (cmd_spec_restrict_file_names);
+CMD_DECLARE (cmd_spec_timeout);
CMD_DECLARE (cmd_spec_useragent);
/* List of recognized commands, each consisting of name, closure and function.
When adding a new command, simply add it to the list, but be sure to keep the
- list sorted alphabetically, as comind() depends on it. Also, be sure to add
+ list sorted alphabetically, as findcmd() depends on it. Also, be sure to add
any entries that allocate memory (e.g. cmd_string and cmd_vector guys) to the
cleanup() function below. */
static struct {
{ "base", &opt.base_href, cmd_string },
{ "bindaddress", &opt.bind_address, cmd_string },
{ "cache", &opt.allow_cache, cmd_boolean },
+ { "connecttimeout", &opt.connect_timeout, cmd_time },
{ "continue", &opt.always_rest, cmd_boolean },
{ "convertlinks", &opt.convert_links, cmd_boolean },
{ "cookies", &opt.cookies, cmd_boolean },
{ "dirprefix", &opt.dir_prefix, cmd_directory },
{ "dirstruct", NULL, cmd_spec_dirstruct },
{ "dnscache", &opt.dns_cache, cmd_boolean },
+ { "dnstimeout", &opt.dns_timeout, cmd_time },
{ "domains", &opt.domains, cmd_vector },
{ "dotbytes", &opt.dot_bytes, cmd_bytes },
{ "dotsinline", &opt.dots_in_line, cmd_number },
{ "quiet", &opt.quiet, cmd_boolean },
{ "quota", &opt.quota, cmd_bytes },
{ "randomwait", &opt.random_wait, cmd_boolean },
+ { "readtimeout", &opt.read_timeout, cmd_time },
{ "reclevel", &opt.reclevel, cmd_number_inf },
{ "recursive", NULL, cmd_spec_recursive },
{ "referer", &opt.referer, cmd_string },
{ "sslprotocol", &opt.sslprotocol, cmd_number },
#endif /* HAVE_SSL */
{ "strictcomments", &opt.strict_comments, cmd_boolean },
- { "timeout", &opt.timeout, cmd_time },
+ { "timeout", NULL, cmd_spec_timeout },
{ "timestamping", &opt.timestamping, cmd_boolean },
{ "tries", &opt.ntry, cmd_number_inf },
{ "useproxy", &opt.use_proxy, cmd_boolean },
is not found, -1 is returned. This function uses binary search. */
static int
-comind (const char *com)
+findcmd (const char *com)
{
- int lo = 0, hi = ARRAY_SIZE (commands) - 1;
+ int lo = 0, hi = countof (commands) - 1;
while (lo <= hi)
{
opt.cookies = 1;
opt.verbose = -1;
- opt.dir_prefix = xstrdup (".");
opt.ntry = 20;
opt.reclevel = 5;
opt.add_hostdir = 1;
opt.no_proxy = sepstring (tmp);
opt.allow_cache = 1;
-#ifdef HAVE_SELECT
- opt.timeout = 900;
-#endif
+ opt.read_timeout = 900;
opt.use_robots = 1;
opt.remove_listing = 1;
{
if (!file_exists_p (env))
{
- fprintf (stderr, "%s: %s: %s.\n", exec_name, env, strerror (errno));
+ fprintf (stderr, _("%s: WGETRC points to %s, which doesn't exist.\n"),
+ exec_name, env);
exit (1);
}
return xstrdup (env);
return file;
}
-/* Initialize variables from a wgetrc file */
+static int parse_line PARAMS ((const char *, char **, char **, int *));
+static int setval_internal PARAMS ((int, const char *, const char *));
+
+/* Initialize variables from a wgetrc file. */
+
static void
run_wgetrc (const char *file)
{
while ((line = read_whole_line (fp)))
{
char *com, *val;
- int status;
+ int comind, status;
/* Parse the line. */
- status = parse_line (line, &com, &val);
+ status = parse_line (line, &com, &val, &comind);
xfree (line);
/* If everything is OK, set the value. */
if (status == 1)
{
- if (!setval (com, val))
+ if (!setval_internal (comind, com, val))
fprintf (stderr, _("%s: Error in %s at line %d.\n"), exec_name,
file, ln);
xfree (com);
file = wgetrc_file_name ();
if (!file)
return;
- /* #### We should somehow canonicalize `file' and SYSTEM_WGETRC,
- really. */
+ /* #### We should canonicalize `file' and SYSTEM_WGETRC with
+ something like realpath() before comparing them with `strcmp' */
#ifdef SYSTEM_WGETRC
if (!strcmp (file, SYSTEM_WGETRC))
{
return;
}
\f
+/* Remove dashes and underscores from S, modifying S in the
+ process. */
+
+static void
+dehyphen (char *s)
+{
+ char *t = s; /* t - tortoise */
+ char *h = s; /* h - hare */
+ while (*h)
+ if (*h == '_' || *h == '-')
+ ++h;
+ else
+ *t++ = *h++;
+ *t = '\0';
+}
+
/* Parse the line pointed by line, with the syntax:
- <sp>* command <sp>* = <sp>* value <newline>
+ <sp>* command <sp>* = <sp>* value <sp>*
Uses malloc to allocate space for command and value.
If the line is invalid, data is freed and 0 is returned.
Return values:
1 - success
- 0 - failure
- -1 - empty */
-int
-parse_line (const char *line, char **com, char **val)
+ 0 - error
+ -1 - empty
+
+ In case of success, *COM and *VAL point to freshly allocated
+ strings, and *COMIND points to com's index. In case of error or
+ empty line, those values are unaffected. */
+
+static int
+parse_line (const char *line, char **com, char **val, int *comind)
{
- const char *p = line;
- const char *orig_comptr, *end;
- char *new_comptr;
+ const char *p;
+ const char *end = line + strlen (line);
+ const char *cmdstart, *cmdend;
+ const char *valstart, *valend;
- /* Skip whitespace. */
- while (*p && ISSPACE (*p))
- ++p;
+ char *cmdcopy;
+ int ind;
- /* Don't process empty lines. */
- if (!*p || *p == '#')
+ /* Skip leading and trailing whitespace. */
+ while (*line && ISSPACE (*line))
+ ++line;
+ while (end > line && ISSPACE (end[-1]))
+ --end;
+
+ /* Skip empty lines and comments. */
+ if (!*line || *line == '#')
return -1;
- for (orig_comptr = p; ISALPHA (*p) || *p == '_' || *p == '-'; p++)
- ;
- /* The next char should be space or '='. */
- if (!ISSPACE (*p) && (*p != '='))
+ p = line;
+
+ cmdstart = p;
+ while (p < end && (ISALPHA (*p) || *p == '_' || *p == '-'))
+ ++p;
+ cmdend = p;
+
+ /* Skip '=', as well as any space before or after it. */
+ while (p < end && ISSPACE (*p))
+ ++p;
+ if (p == end || *p != '=')
return 0;
- /* Here we cannot use strdupdelim() as we normally would because we
- want to skip the `-' and `_' characters in the input string. */
- *com = (char *)xmalloc (p - orig_comptr + 1);
- for (new_comptr = *com; orig_comptr < p; orig_comptr++)
- {
- if (*orig_comptr == '_' || *orig_comptr == '-')
- continue;
- *new_comptr++ = *orig_comptr;
- }
- *new_comptr = '\0';
- /* If the command is invalid, exit now. */
- if (comind (*com) == -1)
- {
- xfree (*com);
- return 0;
- }
+ ++p;
+ while (p < end && ISSPACE (*p))
+ ++p;
- /* Skip spaces before '='. */
- for (; ISSPACE (*p); p++);
- /* If '=' not found, bail out. */
- if (*p != '=')
- {
- xfree (*com);
- return 0;
- }
- /* Skip spaces after '='. */
- for (++p; ISSPACE (*p); p++);
- /* Get the ending position for VAL by starting with the end of the
- line and skipping whitespace. */
- end = line + strlen (line) - 1;
- while (end > p && ISSPACE (*end))
- --end;
- *val = strdupdelim (p, end + 1);
+ valstart = p;
+ valend = end;
+
+ /* The line now known to be syntactically correct. Check whether
+ the command is valid. */
+ BOUNDED_TO_ALLOCA (cmdstart, cmdend, cmdcopy);
+ dehyphen (cmdcopy);
+ ind = findcmd (cmdcopy);
+ if (ind == -1)
+ return 0;
+
+ /* The command is valid. Now fill in the values and report success
+ to the caller. */
+ *comind = ind;
+ *com = strdupdelim (cmdstart, cmdend);
+ *val = strdupdelim (valstart, valend);
return 1;
}
-/* Set COM to VAL. This is the meat behind processing `.wgetrc'. No
- fatals -- error signal prints a warning and resets to default
- value. All error messages are printed to stderr, *not* to
- opt.lfile, since opt.lfile wasn't even generated yet. */
-int
-setval (const char *com, const char *val)
+/* Run commands[comind].action. */
+
+static int
+setval_internal (int comind, const char *com, const char *val)
{
- int ind;
+ assert (0 <= comind && comind < countof (commands));
+ return ((*commands[comind].action) (com, val, commands[comind].closure));
+}
- if (!com || !val)
- return 0;
- ind = comind (com);
- if (ind == -1)
+/* Run command COM with value VAL. If running the command produces an
+ error, report the error and exit.
+
+ This is intended to be called from main() with commands not
+ provided by the user, therefore it aborts when an unknown command
+ is encountered. Once the COMIND's are exported to init.h, this
+ function will be changed to accept COMIND directly. */
+
+void
+setoptval (const char *com, const char *val)
+{
+ if (!setval_internal (findcmd (com), com, val))
+ exit (2);
+}
+
+/* Parse OPT into command and value and run it. For example,
+ run_command("foo=bar") is equivalent to setoptval("foo", "bar").
+ This is used by the `--execute' flag in main.c. */
+
+void
+run_command (const char *opt)
+{
+ char *com, *val;
+ int comind;
+ int status = parse_line (opt, &com, &val, &comind);
+ if (status == 1)
{
- /* #### Should I just abort()? */
-#ifdef DEBUG
- fprintf (stderr, _("%s: BUG: unknown command `%s', value `%s'.\n"),
- exec_name, com, val);
-#endif
- return 0;
+ if (!setval_internal (comind, com, val))
+ exit (2);
+ xfree (com);
+ xfree (val);
+ }
+ else if (status == 0)
+ {
+ fprintf (stderr, _("%s: Invalid --execute command `%s'\n"),
+ exec_name, opt);
+ exit (2);
}
- return ((*commands[ind].action) (com, val, commands[ind].closure));
}
\f
/* Generic helper functions, for use with `commands'. */
-static int myatoi PARAMS ((const char *s));
+#define CMP1(p, c0) (TOLOWER((p)[0]) == (c0) && (p)[1] == '\0')
+
+#define CMP2(p, c0, c1) (TOLOWER((p)[0]) == (c0) \
+ && TOLOWER((p)[1]) == (c1) \
+ && (p)[2] == '\0')
+
+#define CMP3(p, c0, c1, c2) (TOLOWER((p)[0]) == (c0) \
+ && TOLOWER((p)[1]) == (c1) \
+ && TOLOWER((p)[2]) == (c2) \
+ && (p)[3] == '\0')
+
/* Store the boolean value from VAL to CLOSURE. COM is ignored,
except for error messages. */
cmd_boolean (const char *com, const char *val, void *closure)
{
int bool_value;
- const char *v = val;
-#define LC(x) TOLOWER(x)
-
- if ((LC(v[0]) == 'o' && LC(v[1]) == 'n' && !v[2])
- ||
- (LC(v[0]) == 'y' && LC(v[1]) == 'e' && LC(v[2]) == 's' && !v[3])
- ||
- (v[0] == '1' && !v[1]))
+
+ if (CMP2 (val, 'o', 'n') || CMP3 (val, 'y', 'e', 's') || CMP1 (val, '1'))
/* "on", "yes" and "1" mean true. */
bool_value = 1;
- else if ((LC(v[0]) == 'o' && LC(v[1]) == 'f' && LC(v[2]) == 'f' && !v[3])
- ||
- (LC(v[0]) == 'n' && LC(v[1]) == 'o' && !v[2])
- ||
- (v[0] == '0' && !v[1]))
+ else if (CMP3 (val, 'o', 'f', 'f') || CMP2 (val, 'n', 'o') || CMP1 (val, '0'))
/* "off", "no" and "0" mean false. */
bool_value = 0;
else
{
- fprintf (stderr, _("%s: %s: Please specify on or off.\n"),
- exec_name, com);
+ fprintf (stderr,
+ _("%s: %s: Invalid boolean `%s', use `on' or `off'.\n"),
+ exec_name, com, val);
return 0;
}
return 1;
}
-/* Store the lockable_boolean {2, 1, 0, -1} value from VAL to CLOSURE. COM is
- ignored, except for error messages. Values 2 and -1 indicate that once
- defined, the value may not be changed by successive wgetrc files or
- command-line arguments.
+/* Store the lockable_boolean {2, 1, 0, -1} value from VAL to CLOSURE.
+ COM is ignored, except for error messages. Values 2 and -1
+ indicate that once defined, the value may not be changed by
+ successive wgetrc files or command-line arguments.
Values: 2 - Enable a particular option for good ("always")
1 - Enable an option ("on")
{
int lockable_boolean_value;
+ int oldval = *(int *)closure;
+
/*
* If a config file said "always" or "never", don't allow command line
* arguments to override the config file.
*/
- if (*(int *)closure == -1 || *(int *)closure == 2)
+ if (oldval == -1 || oldval == 2)
return 1;
- if (!strcasecmp (val, "always") || !strcmp (val, "2"))
+ if (0 == strcasecmp (val, "always") || CMP1 (val, '2'))
lockable_boolean_value = 2;
- else if (!strcasecmp (val, "on")
- || !strcasecmp (val, "yes")
- || !strcmp (val, "1"))
+ else if (CMP2 (val, 'o', 'n') || CMP3 (val, 'y', 'e', 's') || CMP1 (val, '1'))
lockable_boolean_value = 1;
- else if (!strcasecmp (val, "off")
- || !strcasecmp (val, "no")
- || !strcmp (val, "0"))
+ else if (CMP3 (val, 'o', 'f', 'f') || CMP2 (val, 'n', 'o') || CMP1 (val, '0'))
lockable_boolean_value = 0;
- else if (!strcasecmp (val, "never") || !strcmp (val, "-1"))
+ else if (0 == strcasecmp (val, "never") || CMP2 (val, '-', '1'))
lockable_boolean_value = -1;
else
{
- fprintf (stderr, _("%s: %s: Please specify always, on, off, "
- "or never.\n"),
- exec_name, com);
+ fprintf (stderr,
+ _("%s: %s: Invalid boolean `%s', use always, on, off, or never.\n"),
+ exec_name, com, val);
return 0;
}
return 1;
}
+static int simple_atoi PARAMS ((const char *, const char *, int *));
+
/* Set the non-negative integer value from VAL to CLOSURE. With
incorrect specification, the number remains unchanged. */
static int
cmd_number (const char *com, const char *val, void *closure)
{
- int num = myatoi (val);
-
- if (num == -1)
+ if (!simple_atoi (val, val + strlen (val), closure))
{
- fprintf (stderr, _("%s: %s: Invalid specification `%s'.\n"),
+ fprintf (stderr, _("%s: %s: Invalid number `%s'.\n"),
exec_name, com, val);
return 0;
}
- *(int *)closure = num;
return 1;
}
return 1;
}
+#ifndef WINDOWS
+# define ISSEP(c) ((c) == '/')
+#else
+# define ISSEP(c) ((c) == '/' || (c) == '\\')
+#endif
+
/* Like the above, but handles tilde-expansion when reading a user's
`.wgetrc'. In that case, and if VAL begins with `~', the tilde
gets expanded to the user's home directory. */
/* #### If VAL is empty, perhaps should set *CLOSURE to NULL. */
- if (!enable_tilde_expansion || !(*val == '~' && (*(val + 1) == '/'
-#ifdef WINDOWS
- || *(val + 1) == '\\'
-#endif
- )))
+ if (!enable_tilde_expansion || !(*val == '~' && ISSEP (val[1])))
{
noexpand:
*pstring = xstrdup (val);
goto noexpand;
homelen = strlen (home);
- while (homelen && (home[homelen - 1] == '/'
-#ifdef WINDOWS
- || home[homelen - 1] == '\\'
-#endif
- ))
+ while (homelen && ISSEP (home[homelen - 1]))
home[--homelen] = '\0';
/* Skip the leading "~/". */
-#ifdef WINDOWS
- for (++val; *val == '/' || *val == '\\'; val++)
+ for (++val; ISSEP (*val); val++)
;
-#else
- for (++val; *val == '/'; val++)
- ;
-#endif
result = xmalloc (homelen + 1 + strlen (val) + 1);
memcpy (result, home, homelen);
*pstring = result;
}
+
#ifdef WINDOWS
/* Convert "\" to "/". */
{
return 1;
}
-/* Merge the vector (array of strings separated with `,') in COM with
- the vector (NULL-terminated array of strings) pointed to by
- CLOSURE. */
+/* Split VAL by space to a vector of values, and append those values
+ to vector pointed to by the CLOSURE argument. If VAL is empty, the
+ CLOSURE vector is cleared instead. */
+
static int
cmd_vector (const char *com, const char *val, void *closure)
{
return 1;
}
-/* Set the value stored in VAL to CLOSURE (which should point to a
- long int), allowing several postfixes, with the following syntax
- (regexp):
+static int simple_atof PARAMS ((const char *, const char *, double *));
+
+/* Parse VAL as a number and set its value to CLOSURE (which should
+ point to a long int).
- [0-9]+ -> bytes
- [0-9]+[kK] -> bytes * 1024
- [0-9]+[mM] -> bytes * 1024 * 1024
- inf -> 0
+ By default, the value is assumed to be in bytes. If "K", "M", or
+ "G" are appended, the value is multiplied with 1<<10, 1<<20, or
+ 1<<30, respectively. Floating point values are allowed and are
+ cast to integer before use. The idea is to be able to use things
+ like 1.5k instead of "1536".
+
+ The string "inf" is returned as 0.
+
+ In case of error, 0 is returned and memory pointed to by CLOSURE
+ remains unmodified. */
- Anything else is flagged as incorrect, and CLOSURE is unchanged. */
static int
cmd_bytes (const char *com, const char *val, void *closure)
{
- long result;
- long *out = (long *)closure;
- const char *p;
+ long mult;
+ double number;
+ const char *end = val + strlen (val);
- result = 0;
- p = val;
/* Check for "inf". */
- if (p[0] == 'i' && p[1] == 'n' && p[2] == 'f' && p[3] == '\0')
+ if (0 == strcmp (val, "inf"))
{
- *out = 0;
+ *(long *)closure = 0;
return 1;
}
- /* Search for digits and construct result. */
- for (; *p && ISDIGIT (*p); p++)
- result = (10 * result) + (*p - '0');
- /* If no digits were found, or more than one character is following
- them, bail out. */
- if (p == val || (*p != '\0' && *(p + 1) != '\0'))
+
+ /* Strip trailing whitespace. */
+ while (val < end && ISSPACE (end[-1]))
+ --end;
+
+ if (val == end)
{
- printf (_("%s: Invalid specification `%s'\n"), com, val);
+ err:
+ fprintf (stderr, _("%s: %s: Invalid byte value `%s'\n"),
+ exec_name, com, val);
return 0;
}
- /* Search for a designator. */
- switch (TOLOWER (*p))
+
+ switch (TOLOWER (end[-1]))
{
- case '\0':
- /* None */
- break;
case 'k':
- /* Kilobytes */
- result *= 1024;
+ --end, mult = 1L<<10;
break;
case 'm':
- /* Megabytes */
- result *= (long)1024 * 1024;
+ --end, mult = 1L<<20;
break;
case 'g':
- /* Gigabytes */
- result *= (long)1024 * 1024 * 1024;
+ --end, mult = 1L<<30;
break;
default:
- printf (_("%s: Invalid specification `%s'\n"), com, val);
- return 0;
+ /* Not a recognized suffix: assume it belongs to the number.
+ (If not, atof simple_atof will raise an error.) */
+ mult = 1;
}
- *out = result;
+
+ /* Skip leading and trailing whitespace. */
+ while (val < end && ISSPACE (*val))
+ ++val;
+ while (val < end && ISSPACE (end[-1]))
+ --end;
+ if (val == end)
+ goto err;
+
+ if (!simple_atof (val, end, &number))
+ goto err;
+
+ *(long *)closure = (long)(number * mult);
return 1;
}
-/* Store the value of VAL to *OUT, allowing suffixes for minutes and
- hours. */
+/* Store the value of VAL to *OUT. The value is a time period, by
+ default expressed in seconds, but also accepting suffixes "m", "h",
+ "d", and "w" for minutes, hours, days, and weeks respectively. */
+
static int
cmd_time (const char *com, const char *val, void *closure)
{
- long result = 0;
- const char *p = val;
+ double number, mult;
+ const char *end = val + strlen (val);
- /* Search for digits and construct result. */
- for (; *p && ISDIGIT (*p); p++)
- result = (10 * result) + (*p - '0');
- /* If no digits were found, or more than one character is following
- them, bail out. */
- if (p == val || (*p != '\0' && *(p + 1) != '\0'))
+ /* Strip trailing whitespace. */
+ while (val < end && ISSPACE (end[-1]))
+ --end;
+
+ if (val == end)
{
- printf (_("%s: Invalid specification `%s'\n"), com, val);
+ err:
+ fprintf (stderr, _("%s: %s: Invalid time period `%s'\n"),
+ exec_name, com, val);
return 0;
}
- /* Search for a suffix. */
- switch (TOLOWER (*p))
+
+ switch (TOLOWER (end[-1]))
{
- case '\0':
- /* None */
+ case 's':
+ --end, mult = 1; /* seconds */
break;
case 'm':
- /* Minutes */
- result *= 60;
+ --end, mult = 60; /* minutes */
break;
case 'h':
- /* Seconds */
- result *= 3600;
+ --end, mult = 3600; /* hours */
break;
case 'd':
- /* Days (overflow on 16bit machines) */
- result *= 86400L;
+ --end, mult = 86400.0; /* days */
break;
case 'w':
- /* Weeks :-) */
- result *= 604800L;
+ --end, mult = 604800.0; /* weeks */
break;
default:
- printf (_("%s: Invalid specification `%s'\n"), com, val);
- return 0;
+ /* Not a recognized suffix: assume it belongs to the number.
+ (If not, atof simple_atof will raise an error.) */
+ mult = 1;
}
- *(long *)closure = result;
+
+ /* Skip leading and trailing whitespace. */
+ while (val < end && ISSPACE (*val))
+ ++val;
+ while (val < end && ISSPACE (end[-1]))
+ --end;
+ if (val == end)
+ goto err;
+
+ if (!simple_atof (val, end, &number))
+ goto err;
+
+ *(double *)closure = number * mult;
return 1;
}
\f
if (!check_user_specified_header (val))
{
- fprintf (stderr, _("%s: %s: Invalid specification `%s'.\n"),
+ fprintf (stderr, _("%s: %s: Invalid header `%s'.\n"),
exec_name, com, val);
return 0;
}
return flag;
}
+/* Set the "mirror" mode. It means: recursive download, timestamping,
+ no limit on max. recursion depth, and don't remove listings. */
+
static int
cmd_spec_mirror (const char *com, const char *val, void *closure)
{
return 1;
}
+/* Set progress.type to VAL, but verify that it's a valid progress
+ implementation before that. */
+
static int
cmd_spec_progress (const char *com, const char *val, void *closure)
{
return 1;
}
+/* Set opt.recursive to VAL as with cmd_boolean. If opt.recursive is
+ set to true, also set opt.dirstruct to 1, unless opt.no_dirstruct
+ is specified. */
+
static int
cmd_spec_recursive (const char *com, const char *val, void *closure)
{
else
{
err:
- fprintf (stderr, _("%s: %s: Invalid specification `%s'.\n"),
+ fprintf (stderr,
+ _("%s: %s: Invalid restriction `%s', use `unix' or `windows'.\n"),
exec_name, com, val);
return 0;
}
return 1;
}
+/* Set all three timeout values. */
+
+static int
+cmd_spec_timeout (const char *com, const char *val, void *closure)
+{
+ double value;
+ if (!cmd_time (com, val, &value))
+ return 0;
+ opt.read_timeout = value;
+ opt.connect_timeout = value;
+ opt.dns_timeout = value;
+ return 1;
+}
+
static int
cmd_spec_useragent (const char *com, const char *val, void *closure)
{
junk to the server. */
if (!*val || strchr (val, '\n'))
{
- fprintf (stderr, _("%s: %s: Invalid specification `%s'.\n"),
+ fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"),
exec_name, com, val);
return 0;
}
\f
/* Miscellaneous useful routines. */
-/* Return the integer value of a positive integer written in S, or -1
- if an error was encountered. */
+/* A very simple atoi clone, more portable than strtol and friends,
+ but reports errors, unlike atoi. Returns 1 on success, 0 on
+ failure. In case of success, stores result to *DEST. */
+
static int
-myatoi (const char *s)
+simple_atoi (const char *beg, const char *end, int *dest)
{
- int res;
- const char *orig = s;
+ int result = 0;
+ const char *p;
- for (res = 0; *s && ISDIGIT (*s); s++)
- res = 10 * res + (*s - '0');
- if (*s || orig == s)
- return -1;
- else
- return res;
+ if (beg == end)
+ return 0;
+
+ for (p = beg; p < end && ISDIGIT (*p); p++)
+ result = (10 * result) + (*p - '0');
+
+ if (p != end)
+ return 0;
+
+ *dest = result;
+ return 1;
+}
+
+/* Trivial atof, with error reporting. Handles "<digits>[.<digits>]",
+ doesn't handle exponential notation. Returns 1 on success, 0 on
+ failure. In case of success, stores its result to *DEST. */
+
+static int
+simple_atof (const char *beg, const char *end, double *dest)
+{
+ double result = 0;
+
+ int seen_dot = 0;
+ int seen_digit = 0;
+ double divider = 1;
+
+ const char *p;
+
+ for (p = beg; p < end; p++)
+ {
+ char ch = *p;
+ if (ISDIGIT (ch))
+ {
+ if (!seen_dot)
+ result = (10 * result) + (ch - '0');
+ else
+ result += (ch - '0') / (divider *= 10);
+ seen_digit = 1;
+ }
+ else if (ch == '.')
+ {
+ if (!seen_dot)
+ seen_dot = 1;
+ else
+ return 0;
+ }
+ else
+ return 0;
+ }
+ if (!seen_digit)
+ return 0;
+
+ *dest = result;
+ return 1;
}
static int
memory which grows with the size of the program. */
#ifdef DEBUG_MALLOC
- recursive_cleanup ();
+ convert_cleanup ();
res_cleanup ();
http_cleanup ();
cleanup_html_url ();
free_netrc (netrc_list);
}
FREE_MAYBE (opt.lfilename);
- xfree (opt.dir_prefix);
+ FREE_MAYBE (opt.dir_prefix);
FREE_MAYBE (opt.input_filename);
FREE_MAYBE (opt.output_document);
free_vec (opt.accepts);