/* Reading/parsing the initialization file.
- Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2003, 2004
- Free Software Foundation, Inc.
+ Copyright (C) 2005 Free Software Foundation, Inc.
This file is part of GNU Wget.
#include "init.h"
#include "host.h"
#include "netrc.h"
-#include "cookies.h" /* for cookie_jar_delete */
#include "progress.h"
#include "recur.h" /* for INFINITE_RECURSION */
+#include "convert.h" /* for convert_cleanup */
+#include "res.h" /* for res_cleanup */
#ifndef errno
extern int errno;
#endif
-extern struct cookie_jar *wget_cookie_jar;
-
/* We want tilde expansion enabled only when reading `.wgetrc' lines;
otherwise, it will be performed by the shell. This variable will
be set by the wgetrc-reading function. */
CMD_DECLARE (cmd_boolean);
CMD_DECLARE (cmd_bytes);
CMD_DECLARE (cmd_bytes_large);
+#ifdef HAVE_SSL
+CMD_DECLARE (cmd_cert_type);
+#endif
CMD_DECLARE (cmd_directory_vector);
CMD_DECLARE (cmd_lockable_boolean);
CMD_DECLARE (cmd_number);
CMD_DECLARE (cmd_spec_header);
CMD_DECLARE (cmd_spec_htmlify);
CMD_DECLARE (cmd_spec_mirror);
+CMD_DECLARE (cmd_spec_prefer_family);
CMD_DECLARE (cmd_spec_progress);
CMD_DECLARE (cmd_spec_recursive);
CMD_DECLARE (cmd_spec_restrict_file_names);
+#ifdef HAVE_SSL
+CMD_DECLARE (cmd_spec_secure_protocol);
+#endif
CMD_DECLARE (cmd_spec_timeout);
CMD_DECLARE (cmd_spec_useragent);
-/* List of recognized commands, each consisting of name, closure and
+/* List of recognized commands, each consisting of name, place 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
static struct {
const char *name;
- void *closure;
+ void *place;
int (*action) PARAMS ((const char *, const char *, void *));
} commands[] = {
{ "accept", &opt.accepts, cmd_vector },
{ "backups", &opt.backups, cmd_number },
{ "base", &opt.base_href, cmd_string },
{ "bindaddress", &opt.bind_address, cmd_string },
+#ifdef HAVE_SSL
+ { "cacertificate", &opt.ca_cert, cmd_file },
+#endif
{ "cache", &opt.allow_cache, cmd_boolean },
+#ifdef HAVE_SSL
+ { "cadirectory", &opt.ca_directory, cmd_directory },
+ { "certificate", &opt.cert_file, cmd_file },
+ { "certificatetype", &opt.cert_type, cmd_cert_type },
+ { "checkcertificate", &opt.check_cert, cmd_boolean },
+#endif
{ "connecttimeout", &opt.connect_timeout, cmd_time },
{ "continue", &opt.always_rest, cmd_boolean },
{ "convertlinks", &opt.convert_links, cmd_boolean },
{ "dotspacing", &opt.dot_spacing, cmd_number },
{ "dotstyle", &opt.dot_style, cmd_string },
#ifdef HAVE_SSL
- { "egdfile", &opt.sslegdsock, cmd_file },
+ { "egdfile", &opt.egd_file, cmd_file },
#endif
{ "excludedirectories", &opt.excludes, cmd_directory_vector },
{ "excludedomains", &opt.exclude_domains, cmd_vector },
{ "passiveftp", &opt.ftp_pasv, cmd_lockable_boolean },
{ "postdata", &opt.post_data, cmd_string },
{ "postfile", &opt.post_file_name, cmd_file },
+ { "preferfamily", NULL, cmd_spec_prefer_family },
{ "preservepermissions", &opt.preserve_perm, cmd_boolean },
+#ifdef HAVE_SSL
+ { "privatekey", &opt.private_key, cmd_file },
+ { "privatekeytype", &opt.private_key_type, cmd_cert_type },
+#endif
{ "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_large },
+ { "randomfile", &opt.random_file, cmd_file },
{ "randomwait", &opt.random_wait, cmd_boolean },
{ "readtimeout", &opt.read_timeout, cmd_time },
{ "reclevel", &opt.reclevel, cmd_number_inf },
{ "robots", &opt.use_robots, cmd_boolean },
{ "savecookies", &opt.cookies_output, cmd_file },
{ "saveheaders", &opt.save_headers, cmd_boolean },
+#ifdef HAVE_SSL
+ { "secureprotocol", &opt.secure_protocol, cmd_spec_secure_protocol },
+#endif
{ "serverresponse", &opt.server_response, cmd_boolean },
{ "spanhosts", &opt.spanhost, cmd_boolean },
{ "spider", &opt.spider, cmd_boolean },
-#ifdef HAVE_SSL
- { "sslcadir", &opt.sslcadir, cmd_directory },
- { "sslcafile", &opt.sslcafile, cmd_file },
- { "sslcertfile", &opt.sslcertfile, cmd_file },
- { "sslcertkey", &opt.sslcertkey, cmd_file },
- { "sslcerttype", &opt.sslcerttype, cmd_number },
- { "sslcheckcert", &opt.sslcheckcert, cmd_number },
- { "sslprotocol", &opt.sslprotocol, cmd_number },
-#endif /* HAVE_SSL */
{ "strictcomments", &opt.strict_comments, cmd_boolean },
{ "timeout", NULL, cmd_spec_timeout },
{ "timestamping", &opt.timestamping, cmd_boolean },
opt.dns_cache = 1;
opt.ftp_pasv = 1;
+#ifdef HAVE_SSL
+ opt.check_cert = 1;
+#endif
+
/* The default for file name restriction defaults to the OS type. */
#if !defined(WINDOWS) && !defined(__CYGWIN__)
opt.restrict_files_os = restrict_unix;
{
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));
+ return ((*commands[comind].action) (com, val, commands[comind].place));
}
/* Run command COM with value VAL. If running the command produces an
\f
/* Generic helper functions, for use with `commands'. */
+/* Forward declarations: */
+struct decode_item {
+ const char *name;
+ int code;
+};
+static int decode_string PARAMS ((const char *, const struct decode_item *,
+ int, int *));
+static int simple_atoi PARAMS ((const char *, const char *, int *));
+static int simple_atof PARAMS ((const char *, const char *, double *));
+
#define CMP1(p, c0) (TOLOWER((p)[0]) == (c0) && (p)[1] == '\0')
#define CMP2(p, c0, c1) (TOLOWER((p)[0]) == (c0) \
&& (p)[3] == '\0')
-/* Store the boolean value from VAL to CLOSURE. COM is ignored,
+/* Store the boolean value from VAL to PLACE. COM is ignored,
except for error messages. */
static int
-cmd_boolean (const char *com, const char *val, void *closure)
+cmd_boolean (const char *com, const char *val, void *place)
{
int bool_value;
return 0;
}
- *(int *)closure = bool_value;
+ *(int *)place = bool_value;
return 1;
}
-/* Store the lockable_boolean {2, 1, 0, -1} value from VAL to CLOSURE.
+/* Store the lockable_boolean {2, 1, 0, -1} value from VAL to PLACE.
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.
0 - Disable an option ("off")
-1 - Disable an option for good ("never") */
static int
-cmd_lockable_boolean (const char *com, const char *val, void *closure)
+cmd_lockable_boolean (const char *com, const char *val, void *place)
{
int lockable_boolean_value;
- int oldval = *(int *)closure;
+ int oldval = *(int *)place;
/*
* If a config file said "always" or "never", don't allow command line
return 0;
}
- *(int *)closure = lockable_boolean_value;
+ *(int *)place = lockable_boolean_value;
return 1;
}
-static int simple_atoi PARAMS ((const char *, const char *, int *));
-
-/* Set the non-negative integer value from VAL to CLOSURE. With
+/* Set the non-negative integer value from VAL to PLACE. With
incorrect specification, the number remains unchanged. */
static int
-cmd_number (const char *com, const char *val, void *closure)
+cmd_number (const char *com, const char *val, void *place)
{
- if (!simple_atoi (val, val + strlen (val), closure))
+ if (!simple_atoi (val, val + strlen (val), place)
+ || *(int *) place < 0)
{
fprintf (stderr, _("%s: %s: Invalid number `%s'.\n"),
exec_name, com, val);
/* Similar to cmd_number(), only accepts `inf' as a synonym for 0. */
static int
-cmd_number_inf (const char *com, const char *val, void *closure)
+cmd_number_inf (const char *com, const char *val, void *place)
{
if (!strcasecmp (val, "inf"))
{
- *(int *)closure = 0;
+ *(int *)place = 0;
return 1;
}
- return cmd_number (com, val, closure);
+ return cmd_number (com, val, place);
}
/* Copy (strdup) the string at COM to a new location and place a
- pointer to *CLOSURE. */
+ pointer to *PLACE. */
static int
-cmd_string (const char *com, const char *val, void *closure)
+cmd_string (const char *com, const char *val, void *place)
{
- char **pstring = (char **)closure;
+ char **pstring = (char **)place;
xfree_null (*pstring);
*pstring = xstrdup (val);
`.wgetrc'. In that case, and if VAL begins with `~', the tilde
gets expanded to the user's home directory. */
static int
-cmd_file (const char *com, const char *val, void *closure)
+cmd_file (const char *com, const char *val, void *place)
{
- char **pstring = (char **)closure;
+ char **pstring = (char **)place;
xfree_null (*pstring);
- /* #### If VAL is empty, perhaps should set *CLOSURE to NULL. */
+ /* #### If VAL is empty, perhaps should set *PLACE to NULL. */
if (!enable_tilde_expansion || !(*val == '~' && ISSEP (val[1])))
{
}
else
{
- char *result;
int homelen;
char *home = home_dir ();
if (!home)
for (++val; ISSEP (*val); val++)
;
- result = xmalloc (homelen + 1 + strlen (val) + 1);
- memcpy (result, home, homelen);
- result[homelen] = '/';
- strcpy (result + homelen + 1, val);
-
- *pstring = result;
+ *pstring = concat_strings (home, "/", val, (char *) 0);
}
#ifdef WINDOWS
/* Like cmd_file, but strips trailing '/' characters. */
static int
-cmd_directory (const char *com, const char *val, void *closure)
+cmd_directory (const char *com, const char *val, void *place)
{
char *s, *t;
/* Call cmd_file() for tilde expansion and separator
canonicalization (backslash -> slash under Windows). These
things should perhaps be in a separate function. */
- if (!cmd_file (com, val, closure))
+ if (!cmd_file (com, val, place))
return 0;
- s = *(char **)closure;
+ s = *(char **)place;
t = s + strlen (s);
while (t > s && *--t == '/')
*t = '\0';
}
/* 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. */
+ to vector pointed to by the PLACE argument. If VAL is empty, the
+ PLACE vector is cleared instead. */
static int
-cmd_vector (const char *com, const char *val, void *closure)
+cmd_vector (const char *com, const char *val, void *place)
{
- char ***pvec = (char ***)closure;
+ char ***pvec = (char ***)place;
if (*val)
*pvec = merge_vecs (*pvec, sepstring (val));
}
static int
-cmd_directory_vector (const char *com, const char *val, void *closure)
+cmd_directory_vector (const char *com, const char *val, void *place)
{
- char ***pvec = (char ***)closure;
+ char ***pvec = (char ***)place;
if (*val)
{
return 1;
}
-static int simple_atof PARAMS ((const char *, const char *, double *));
-
/* Engine for cmd_bytes and cmd_bytes_large: converts a string such as
"100k" or "2.5G" to a floating point number. */
if (val == end)
return 0;
- if (!simple_atof (val, end, &number))
+ if (!simple_atof (val, end, &number) || number < 0)
return 0;
*result = number * mult;
return 1;
}
-/* Parse VAL as a number and set its value to CLOSURE (which should
+/* Parse VAL as a number and set its value to PLACE (which should
point to a wgint).
By default, the value is assumed to be in bytes. If "K", "M", or
The string "inf" is returned as 0.
- In case of error, 0 is returned and memory pointed to by CLOSURE
+ In case of error, 0 is returned and memory pointed to by PLACE
remains unmodified. */
static int
-cmd_bytes (const char *com, const char *val, void *closure)
+cmd_bytes (const char *com, const char *val, void *place)
{
double byte_value;
if (!parse_bytes_helper (val, &byte_value))
exec_name, com, val);
return 0;
}
- *(wgint *)closure = (wgint)byte_value;
+ *(wgint *)place = (wgint)byte_value;
return 1;
}
-/* Like cmd_bytes, but CLOSURE is interpreted as a pointer to
+/* Like cmd_bytes, but PLACE 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. */
static int
-cmd_bytes_large (const char *com, const char *val, void *closure)
+cmd_bytes_large (const char *com, const char *val, void *place)
{
double byte_value;
if (!parse_bytes_helper (val, &byte_value))
exec_name, com, val);
return 0;
}
- *(LARGE_INT *)closure = (LARGE_INT)byte_value;
+ *(LARGE_INT *)place = (LARGE_INT)byte_value;
return 1;
}
"d", and "w" for minutes, hours, days, and weeks respectively. */
static int
-cmd_time (const char *com, const char *val, void *closure)
+cmd_time (const char *com, const char *val, void *place)
{
double number, mult;
const char *end = val + strlen (val);
break;
default:
/* Not a recognized suffix: assume it belongs to the number.
- (If not, atof simple_atof will raise an error.) */
+ (If not, simple_atof will raise an error.) */
mult = 1;
}
if (!simple_atof (val, end, &number))
goto err;
- *(double *)closure = number * mult;
+ *(double *)place = number * mult;
return 1;
}
+
+#ifdef HAVE_SSL
+static int
+cmd_cert_type (const char *com, const char *val, void *place)
+{
+ static const struct decode_item choices[] = {
+ { "pem", keyfile_pem },
+ { "der", keyfile_asn1 },
+ { "asn1", keyfile_asn1 },
+ };
+ int ok = decode_string (val, choices, countof (choices), place);
+ if (!ok)
+ fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
+ return ok;
+}
+#endif
\f
/* Specialized helper functions, used by `commands' to handle some
options specially. */
static int check_user_specified_header PARAMS ((const char *));
static int
-cmd_spec_dirstruct (const char *com, const char *val, void *closure)
+cmd_spec_dirstruct (const char *com, const char *val, void *place_ignored)
{
if (!cmd_boolean (com, val, &opt.dirstruct))
return 0;
}
static int
-cmd_spec_header (const char *com, const char *val, void *closure)
+cmd_spec_header (const char *com, const char *val, void *place)
{
if (!check_user_specified_header (val))
{
exec_name, com, val);
return 0;
}
- return cmd_vector (com, val, closure);
+ return cmd_vector (com, val, place);
}
static int
-cmd_spec_htmlify (const char *com, const char *val, void *closure)
+cmd_spec_htmlify (const char *com, const char *val, void *place_ignored)
{
int flag = cmd_boolean (com, val, &opt.htmlify);
if (flag && !opt.htmlify)
no limit on max. recursion depth, and don't remove listings. */
static int
-cmd_spec_mirror (const char *com, const char *val, void *closure)
+cmd_spec_mirror (const char *com, const char *val, void *place_ignored)
{
int mirror;
return 1;
}
+/* Validate --prefer-family and set the choice. Allowed values are
+ "IPv4", "IPv6", and "none". */
+
+static int
+cmd_spec_prefer_family (const char *com, const char *val, void *place_ignored)
+{
+ static const struct decode_item choices[] = {
+ { "IPv4", prefer_ipv4 },
+ { "IPv6", prefer_ipv6 },
+ { "none", prefer_none },
+ };
+ int ok = decode_string (val, choices, countof (choices),
+ (int *) &opt.prefer_family);
+ if (!ok)
+ fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
+ return ok;
+}
+
/* 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)
+cmd_spec_progress (const char *com, const char *val, void *place_ignored)
{
if (!valid_progress_implementation_p (val))
{
is specified. */
static int
-cmd_spec_recursive (const char *com, const char *val, void *closure)
+cmd_spec_recursive (const char *com, const char *val, void *place_ignored)
{
if (!cmd_boolean (com, val, &opt.recursive))
return 0;
}
static int
-cmd_spec_restrict_file_names (const char *com, const char *val, void *closure)
+cmd_spec_restrict_file_names (const char *com, const char *val, void *place_ignored)
{
int restrict_os = opt.restrict_files_os;
int restrict_ctrl = opt.restrict_files_ctrl;
return 1;
}
+#ifdef HAVE_SSL
+static int
+cmd_spec_secure_protocol (const char *com, const char *val, void *place)
+{
+ static const struct decode_item choices[] = {
+ { "auto", secure_protocol_auto },
+ { "sslv2", secure_protocol_sslv2 },
+ { "sslv3", secure_protocol_sslv3 },
+ { "tlsv1", secure_protocol_tlsv1 },
+ };
+ int ok = decode_string (val, choices, countof (choices), place);
+ if (!ok)
+ fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
+ return ok;
+}
+#endif
+
/* Set all three timeout values. */
static int
-cmd_spec_timeout (const char *com, const char *val, void *closure)
+cmd_spec_timeout (const char *com, const char *val, void *place_ignored)
{
double value;
if (!cmd_time (com, val, &value))
}
static int
-cmd_spec_useragent (const char *com, const char *val, void *closure)
+cmd_spec_useragent (const char *com, const char *val, void *place_ignored)
{
/* Just check for empty string and newline, so we don't throw total
junk to the server. */
\f
/* Miscellaneous useful routines. */
-/* 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. */
+/* A very simple atoi clone, more useful than atoi because it works on
+ delimited strings, and has error reportage. Returns 1 on success,
+ 0 on failure. If successful, stores result to *DEST. */
static int
simple_atoi (const char *beg, const char *end, int *dest)
{
int result = 0;
- const char *p;
+ int negative = 0;
+ const char *p = beg;
- if (beg == end)
+ while (p < end && ISSPACE (*p))
+ ++p;
+ if (p < end && (*p == '-' || *p == '+'))
+ {
+ negative = (*p == '-');
+ ++p;
+ }
+ if (p == end)
return 0;
- for (p = beg; p < end && ISDIGIT (*p); p++)
- result = (10 * result) + (*p - '0');
+ /* Read negative numbers in a separate loop because the most
+ negative integer cannot be represented as a positive number. */
+
+ if (!negative)
+ for (; p < end && ISDIGIT (*p); p++)
+ {
+ int next = (10 * result) + (*p - '0');
+ if (next < result)
+ return 0; /* overflow */
+ result = next;
+ }
+ else
+ for (; p < end && ISDIGIT (*p); p++)
+ {
+ int next = (10 * result) - (*p - '0');
+ if (next > result)
+ return 0; /* underflow */
+ result = next;
+ }
if (p != end)
return 0;
{
double result = 0;
+ int negative = 0;
int seen_dot = 0;
int seen_digit = 0;
double divider = 1;
- const char *p;
+ const char *p = beg;
+
+ while (p < end && ISSPACE (*p))
+ ++p;
+ if (p < end && (*p == '-' || *p == '+'))
+ {
+ negative = (*p == '-');
+ ++p;
+ }
- for (p = beg; p < end; p++)
+ for (; p < end; p++)
{
char ch = *p;
if (ISDIGIT (ch))
}
if (!seen_digit)
return 0;
+ if (negative)
+ result = -result;
*dest = result;
return 1;
}
+/* Verify that the user-specified header in S is valid. It must
+ contain a colon preceded by non-white-space characters and must not
+ contain newlines. */
+
static int
check_user_specified_header (const char *s)
{
return 0;
return 1;
}
+
+/* Decode VAL into a number, according to ITEMS. */
+
+static int
+decode_string (const char *val, const struct decode_item *items, int itemcount,
+ int *place)
+{
+ int i;
+ for (i = 0; i < itemcount; i++)
+ if (0 == strcasecmp (val, items[i].name))
+ {
+ *place = items[i].code;
+ return 1;
+ }
+ return 0;
+}
+
\f
void cleanup_html_url PARAMS ((void));
-void res_cleanup PARAMS ((void));
-void downloaded_files_free PARAMS ((void));
void http_cleanup PARAMS ((void));
res_cleanup ();
http_cleanup ();
cleanup_html_url ();
- downloaded_files_free ();
host_cleanup ();
- if (wget_cookie_jar)
- cookie_jar_delete (wget_cookie_jar);
+ log_cleanup ();
{
extern acc_t *netrc_list;
xfree_null (opt.referer);
xfree_null (opt.http_user);
xfree_null (opt.http_passwd);
- xfree_null (opt.user_header);
-#ifdef HAVE_SSL
- xfree_null (opt.sslcertkey);
- xfree_null (opt.sslcertfile);
-#endif /* HAVE_SSL */
+ free_vec (opt.user_headers);
+# ifdef HAVE_SSL
+ xfree_null (opt.cert_file);
+ xfree_null (opt.private_key);
+# endif
xfree_null (opt.bind_address);
xfree_null (opt.cookies_input);
xfree_null (opt.cookies_output);
-#endif
+#endif /* DEBUG_MALLOC */
}
projects / wget / blobdiff