/* Reading/parsing the initialization file.
- Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001
+ Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2003, 2004
Free Software Foundation, Inc.
This file is part of GNU Wget.
#endif
#include <errno.h>
-#ifdef WINDOWS
-# include <winsock.h>
-#else
-# include <sys/socket.h>
-# include <netinet/in.h>
-#ifndef __BEOS__
-# include <arpa/inet.h>
-#endif
-#endif
-
#ifdef HAVE_PWD_H
# include <pwd.h>
#endif
#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"
+#include "recur.h" /* for INFINITE_RECURSION */
#ifndef errno
extern int errno;
CMD_DECLARE (cmd_boolean);
CMD_DECLARE (cmd_bytes);
+CMD_DECLARE (cmd_bytes_large);
CMD_DECLARE (cmd_directory_vector);
CMD_DECLARE (cmd_lockable_boolean);
CMD_DECLARE (cmd_number);
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 findcmd() depends on it. Also, be sure to add
- any entries that allocate memory (e.g. cmd_string and cmd_vector guys) to the
+/* 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
+ command_by_name 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 {
- char *name;
+ const char *name;
void *closure;
int (*action) PARAMS ((const char *, const char *, void *));
} commands[] = {
{ "convertlinks", &opt.convert_links, cmd_boolean },
{ "cookies", &opt.cookies, cmd_boolean },
{ "cutdirs", &opt.cut_dirs, cmd_number },
-#ifdef DEBUG
+#ifdef ENABLE_DEBUG
{ "debug", &opt.debug, cmd_boolean },
#endif
{ "deleteafter", &opt.delete_after, cmd_boolean },
{ "followftp", &opt.follow_ftp, cmd_boolean },
{ "followtags", &opt.follow_tags, cmd_vector },
{ "forcehtml", &opt.force_html, cmd_boolean },
+ { "ftppasswd", &opt.ftp_pass, cmd_string },
{ "ftpproxy", &opt.ftp_proxy, cmd_string },
{ "glob", &opt.ftp_glob, cmd_boolean },
- { "header", NULL, cmd_spec_header },
+ { "header", &opt.user_headers, cmd_spec_header },
{ "htmlextension", &opt.html_extension, cmd_boolean },
{ "htmlify", NULL, cmd_spec_htmlify },
{ "httpkeepalive", &opt.http_keep_alive, cmd_boolean },
{ "ignorelength", &opt.ignore_length, cmd_boolean },
{ "ignoretags", &opt.ignore_tags, cmd_vector },
{ "includedirectories", &opt.includes, cmd_directory_vector },
+#ifdef ENABLE_IPV6
+ { "inet4only", &opt.ipv4_only, cmd_boolean },
+ { "inet6only", &opt.ipv6_only, cmd_boolean },
+#endif
{ "input", &opt.input_filename, cmd_file },
+ { "keepsessioncookies", &opt.keep_session_cookies, cmd_boolean },
{ "killlonger", &opt.kill_longer, cmd_boolean },
{ "limitrate", &opt.limit_rate, cmd_bytes },
{ "loadcookies", &opt.cookies_input, cmd_file },
{ "outputdocument", &opt.output_document, cmd_file },
{ "pagerequisites", &opt.page_requisites, cmd_boolean },
{ "passiveftp", &opt.ftp_pasv, cmd_lockable_boolean },
- { "passwd", &opt.ftp_pass, cmd_string },
{ "postdata", &opt.post_data, cmd_string },
{ "postfile", &opt.post_file_name, cmd_file },
+ { "preservepermissions", &opt.preserve_perm, cmd_boolean },
{ "progress", &opt.progress_type, cmd_spec_progress },
+ { "protocoldirectories", &opt.protocol_directories, cmd_boolean },
{ "proxypasswd", &opt.proxy_passwd, cmd_string },
{ "proxyuser", &opt.proxy_user, cmd_string },
{ "quiet", &opt.quiet, cmd_boolean },
- { "quota", &opt.quota, cmd_bytes },
+ { "quota", &opt.quota, cmd_bytes_large },
{ "randomwait", &opt.random_wait, cmd_boolean },
{ "readtimeout", &opt.read_timeout, cmd_time },
{ "reclevel", &opt.reclevel, cmd_number_inf },
{ "waitretry", &opt.waitretry, cmd_time }
};
-/* Look up COM in the commands[] array and return its index. If COM
- is not found, -1 is returned. This function uses binary search. */
+/* Look up CMDNAME in the commands[] and return its position in the
+ array. If CMDNAME is not found, return -1. */
static int
-findcmd (const char *com)
+command_by_name (const char *cmdname)
{
+ /* Use binary search for speed. Wget has ~100 commands, which
+ guarantees a worst case performance of 7 string comparisons. */
int lo = 0, hi = countof (commands) - 1;
while (lo <= hi)
{
int mid = (lo + hi) >> 1;
- int cmp = strcasecmp (com, commands[mid].name);
+ int cmp = strcasecmp (cmdname, commands[mid].name);
if (cmp < 0)
hi = mid - 1;
else if (cmp > 0)
NULL this way is technically illegal, but porting Wget to a
machine where NULL is not all-zero bit pattern will be the least
of the implementors' worries. */
- memset (&opt, 0, sizeof (opt));
+ xzero (opt);
opt.cookies = 1;
-
opt.verbose = -1;
opt.ntry = 20;
opt.reclevel = 5;
return NULL;
home = pwd->pw_dir;
#else /* WINDOWS */
- home = "C:\\";
- /* #### Maybe I should grab home_dir from registry, but the best
- that I could get from there is user's Start menu. It sucks! */
+ /* Under Windows, if $HOME isn't defined, use the directory where
+ `wget.exe' resides. */
+ home = ws_mypath ();
#endif /* WINDOWS */
}
{
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);
}
-#ifndef WINDOWS
/* If that failed, try $HOME/.wgetrc. */
home = home_dir ();
if (home)
- {
- file = (char *)xmalloc (strlen (home) + 1 + strlen (".wgetrc") + 1);
- sprintf (file, "%s/.wgetrc", home);
- }
- FREE_MAYBE (home);
-#else /* WINDOWS */
- /* Under Windows, "home" is (for the purposes of this function) the
- directory where `wget.exe' resides, and `wget.ini' will be used
- as file name. SYSTEM_WGETRC should not be defined under WINDOWS.
+ file = aprintf ("%s/.wgetrc", home);
+ xfree_null (home);
- It is not as trivial as I assumed, because on 95 argv[0] is full
- path, but on NT you get what you typed in command line. --dbudor */
- home = ws_mypath ();
- if (home)
+#ifdef WINDOWS
+ /* Under Windows, if we still haven't found .wgetrc, look for the file
+ `wget.ini' in the directory where `wget.exe' resides; we do this for
+ backward compatibility with previous versions of Wget.
+ SYSTEM_WGETRC should not be defined under WINDOWS. */
+ if (!file || !file_exists_p (file))
{
- file = (char *)xmalloc (strlen (home) + strlen ("wget.ini") + 1);
- sprintf (file, "%swget.ini", home);
+ xfree_null (file);
+ file = NULL;
+ home = ws_mypath ();
+ if (home)
+ file = aprintf ("%s/wget.ini", home);
}
#endif /* WINDOWS */
}
enable_tilde_expansion = 1;
ln = 1;
- while ((line = read_whole_line (fp)))
+ while ((line = read_whole_line (fp)) != NULL)
{
char *com, *val;
int comind, status;
}
/* 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 */
+ 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)
the command is valid. */
BOUNDED_TO_ALLOCA (cmdstart, cmdend, cmdcopy);
dehyphen (cmdcopy);
- ind = findcmd (cmdcopy);
+ ind = command_by_name (cmdcopy);
if (ind == -1)
return 0;
setval_internal (int comind, const char *com, const char *val)
{
assert (0 <= comind && comind < countof (commands));
+ DEBUGP (("Setting %s (%d) to %s\n", com, comind, val));
return ((*commands[comind].action) (com, val, commands[comind].closure));
}
/* 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. */
+ This is intended to be called from main() to modify Wget's behavior
+ through command-line switches. Since COM is hard-coded in main(),
+ it is not canonicalized, and this aborts when COM is not found.
+
+ If COMIND's are exported to init.h, this function will be changed
+ to accept COMIND directly. */
void
setoptval (const char *com, const char *val)
{
- int comind = findcmd (com);
- assert (comind != -1);
- if (!setval_internal (comind, com, val))
+ assert (val != NULL);
+ if (!setval_internal (command_by_name (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)
{
}
else if (status == 0)
{
- fprintf (stderr, "Invalid command `%s'\n", opt);
+ fprintf (stderr, _("%s: Invalid --execute command `%s'\n"),
+ exec_name, opt);
exit (2);
}
}
\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;
}
{
char **pstring = (char **)closure;
- FREE_MAYBE (*pstring);
+ xfree_null (*pstring);
*pstring = xstrdup (val);
return 1;
}
{
char **pstring = (char **)closure;
- FREE_MAYBE (*pstring);
+ xfree_null (*pstring);
/* #### If VAL is empty, perhaps should set *CLOSURE to NULL. */
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;
}
-/* Poor man's atof: handles only <digits>.<digits>. 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 = beg;
-
- while (p < end)
- {
- 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;
- }
- }
- if (!seen_digit)
- return 0;
-
- *dest = result;
- return 1;
-}
-
-/* Parse VAL as a number and set its value to CLOSURE (which should
- point to a long int).
-
- 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.
+static int simple_atof PARAMS ((const char *, const char *, double *));
- In case of error, 0 is returned and memory pointed to by CLOSURE
- remains unmodified. */
+/* Engine for cmd_bytes and cmd_bytes_large: converts a string such as
+ "100k" or "2.5G" to a floating point number. */
static int
-cmd_bytes (const char *com, const char *val, void *closure)
+parse_bytes_helper (const char *val, double *result)
{
- long mult;
- double number;
+ double number, mult;
const char *end = val + strlen (val);
/* Check for "inf". */
if (0 == strcmp (val, "inf"))
{
- *(long *)closure = 0;
+ *result = 0;
return 1;
}
/* Strip trailing whitespace. */
while (val < end && ISSPACE (end[-1]))
--end;
-
if (val == end)
- {
- err:
- fprintf (stderr, _("%s: Invalid byte value `%s'\n"), com, val);
- return 0;
- }
+ return 0;
switch (TOLOWER (end[-1]))
{
case 'k':
- --end, mult = 1L<<10;
+ --end, mult = 1024.0;
break;
case 'm':
- --end, mult = 1L<<20;
+ --end, mult = 1048576.0;
break;
case 'g':
- --end, mult = 1L<<30;
+ --end, mult = 1073741824.0;
+ break;
+ case 't':
+ --end, mult = 1099511627776.0;
break;
default:
- /* Not a recognized suffix: assume it belongs to the number.
- (If not, atof simple_atof will raise an error.) */
+ /* Not a recognized suffix: assume it's a digit. (If not,
+ simple_atof will raise an error.) */
mult = 1;
}
while (val < end && ISSPACE (end[-1]))
--end;
if (val == end)
- goto err;
+ return 0;
if (!simple_atof (val, end, &number))
- goto err;
+ return 0;
+
+ *result = number * mult;
+ return 1;
+}
+
+/* Parse VAL as a number and set its value to CLOSURE (which should
+ point to a wgint).
+
+ 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. */
+
+static int
+cmd_bytes (const char *com, const char *val, void *closure)
+{
+ double byte_value;
+ if (!parse_bytes_helper (val, &byte_value))
+ {
+ fprintf (stderr, _("%s: %s: Invalid byte value `%s'\n"),
+ exec_name, com, val);
+ return 0;
+ }
+ *(wgint *)closure = (wgint)byte_value;
+ return 1;
+}
+
+/* Like cmd_bytes, but CLOSURE is interpreted as a pointer to
+ LARGE_INT. It works by converting the string to double, therefore
+ working with values up to 2^53-1 without loss of precision. This
+ value (8192 TB) is large enough to serve for a while. */
- *(long *)closure = (long)(number * mult);
+static int
+cmd_bytes_large (const char *com, const char *val, void *closure)
+{
+ double byte_value;
+ if (!parse_bytes_helper (val, &byte_value))
+ {
+ fprintf (stderr, _("%s: %s: Invalid byte value `%s'\n"),
+ exec_name, com, val);
+ return 0;
+ }
+ *(LARGE_INT *)closure = (LARGE_INT)byte_value;
return 1;
}
if (val == end)
{
err:
- fprintf (stderr, _("%s: Invalid time specification `%s'\n"), com, val);
+ fprintf (stderr, _("%s: %s: Invalid time period `%s'\n"),
+ exec_name, com, val);
return 0;
}
static int
cmd_spec_header (const char *com, const char *val, void *closure)
{
- if (!*val)
- {
- /* Empty header means reset headers. */
- FREE_MAYBE (opt.user_header);
- opt.user_header = NULL;
- }
- else
+ if (!check_user_specified_header (val))
{
- int i;
-
- if (!check_user_specified_header (val))
- {
- fprintf (stderr, _("%s: %s: Invalid specification `%s'.\n"),
- exec_name, com, val);
- return 0;
- }
- i = opt.user_header ? strlen (opt.user_header) : 0;
- opt.user_header = (char *)xrealloc (opt.user_header, i + strlen (val)
- + 2 + 1);
- strcpy (opt.user_header + i, val);
- i += strlen (val);
- opt.user_header[i++] = '\r';
- opt.user_header[i++] = '\n';
- opt.user_header[i] = '\0';
+ fprintf (stderr, _("%s: %s: Invalid header `%s'.\n"),
+ exec_name, com, val);
+ return 0;
}
- return 1;
+ return cmd_vector (com, val, closure);
}
static int
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)
{
exec_name, com, val);
return 0;
}
- FREE_MAYBE (opt.progress_type);
+ xfree_null (opt.progress_type);
/* Don't call set_progress_implementation here. It will be called
in main() when it becomes clear what the log output is. */
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;
}
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
{
/* Free external resources, close files, etc. */
- if (opt.dfp)
- fclose (opt.dfp);
+ {
+ extern FILE *output_stream;
+ if (output_stream)
+ fclose (output_stream);
+ /* No need to check for error because Wget flushes its output (and
+ checks for errors) after any data arrives. */
+ }
/* We're exiting anyway so there's no real need to call free()
hundreds of times. Skipping the frees will make Wget exit
memory which grows with the size of the program. */
#ifdef DEBUG_MALLOC
- recursive_cleanup ();
+ convert_cleanup ();
res_cleanup ();
http_cleanup ();
cleanup_html_url ();
downloaded_files_free ();
host_cleanup ();
- cookie_jar_delete (wget_cookie_jar);
+ if (wget_cookie_jar)
+ cookie_jar_delete (wget_cookie_jar);
{
extern acc_t *netrc_list;
free_netrc (netrc_list);
}
- FREE_MAYBE (opt.lfilename);
- FREE_MAYBE (opt.dir_prefix);
- FREE_MAYBE (opt.input_filename);
- FREE_MAYBE (opt.output_document);
+ xfree_null (opt.lfilename);
+ xfree_null (opt.dir_prefix);
+ xfree_null (opt.input_filename);
+ xfree_null (opt.output_document);
free_vec (opt.accepts);
free_vec (opt.rejects);
free_vec (opt.excludes);
free_vec (opt.domains);
free_vec (opt.follow_tags);
free_vec (opt.ignore_tags);
- FREE_MAYBE (opt.progress_type);
+ xfree_null (opt.progress_type);
xfree (opt.ftp_acc);
- FREE_MAYBE (opt.ftp_pass);
- FREE_MAYBE (opt.ftp_proxy);
- FREE_MAYBE (opt.https_proxy);
- FREE_MAYBE (opt.http_proxy);
+ xfree_null (opt.ftp_pass);
+ xfree_null (opt.ftp_proxy);
+ xfree_null (opt.https_proxy);
+ xfree_null (opt.http_proxy);
free_vec (opt.no_proxy);
- FREE_MAYBE (opt.useragent);
- FREE_MAYBE (opt.referer);
- FREE_MAYBE (opt.http_user);
- FREE_MAYBE (opt.http_passwd);
- FREE_MAYBE (opt.user_header);
+ xfree_null (opt.useragent);
+ xfree_null (opt.referer);
+ xfree_null (opt.http_user);
+ xfree_null (opt.http_passwd);
+ xfree_null (opt.user_header);
#ifdef HAVE_SSL
- FREE_MAYBE (opt.sslcertkey);
- FREE_MAYBE (opt.sslcertfile);
+ xfree_null (opt.sslcertkey);
+ xfree_null (opt.sslcertfile);
#endif /* HAVE_SSL */
- FREE_MAYBE (opt.bind_address);
- FREE_MAYBE (opt.cookies_input);
- FREE_MAYBE (opt.cookies_output);
+ xfree_null (opt.bind_address);
+ xfree_null (opt.cookies_input);
+ xfree_null (opt.cookies_output);
#endif
}
projects / wget / blobdiff