/* Reading/parsing the initialization file.
- Copyright (C) 1996-2005 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
+ 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GNU Wget.
GNU Wget is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
GNU Wget is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with Wget; if not, write to the Free Software Foundation, Inc.,
-51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+along with Wget. If not, see <http://www.gnu.org/licenses/>.
-In addition, as a special exception, the Free Software Foundation
-gives permission to link the code of its release of Wget with the
-OpenSSL project's "OpenSSL" library (or with modified versions of it
-that use the same license as the "OpenSSL" library), and distribute
-the linked executables. You must obey the GNU General Public License
-in all respects for all of the code used other than "OpenSSL". If you
-modify this file, you may extend this exception to your version of the
-file, but you are not obligated to do so. If you do not wish to do
-so, delete this exception statement from your version. */
+Additional permission under GNU GPL version 3 section 7
-#include <config.h>
+If you modify this program, or any covered work, by linking or
+combining it with the OpenSSL project's OpenSSL library (or a
+modified version of that library), containing parts covered by the
+terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
+grants you additional permission to convey the resulting work.
+Corresponding Source for a non-source form of such a combination
+shall include the source code for the parts of OpenSSL used as well
+as that of the covered work. */
+
+#include "wget.h"
#include <stdio.h>
#include <stdlib.h>
#endif
#include <assert.h>
-#include "wget.h"
#include "utils.h"
#include "init.h"
#include "host.h"
#include "netrc.h"
#include "progress.h"
-#include "recur.h" /* for INFINITE_RECURSION */
-#include "convert.h" /* for convert_cleanup */
-#include "res.h" /* for res_cleanup */
-#include "http.h" /* for http_cleanup */
-#include "retr.h" /* for output_stream */
-
-/* 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. */
+#include "recur.h" /* for INFINITE_RECURSION */
+#include "convert.h" /* for convert_cleanup */
+#include "res.h" /* for res_cleanup */
+#include "http.h" /* for http_cleanup */
+#include "retr.h" /* for output_stream */
+
+#ifdef TESTING
+#include "test.h"
+#endif
-static bool enable_tilde_expansion;
#define CMD_DECLARE(func) static bool func (const char *, const char *, void *)
/* 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
- that allocate memory (e.g. cmd_string and cmd_vector) to the
- cleanup() function below. */
+ command_by_name's binary search depends on it. Also, be sure to
+ add any entries that allocate memory (e.g. cmd_string and
+ cmd_vector) to the cleanup() function below. */
-static struct {
+static const struct {
const char *name;
void *place;
bool (*action) (const char *, const char *, void *);
} commands[] = {
- { "accept", &opt.accepts, cmd_vector },
- { "addhostdir", &opt.add_hostdir, cmd_boolean },
- { "alwaysrest", &opt.always_rest, cmd_boolean }, /* deprecated */
- { "background", &opt.background, cmd_boolean },
- { "backupconverted", &opt.backup_converted, cmd_boolean },
- { "backups", &opt.backups, cmd_number },
- { "base", &opt.base_href, cmd_string },
- { "bindaddress", &opt.bind_address, cmd_string },
+ /* KEEP THIS LIST ALPHABETICALLY SORTED */
+ { "accept", &opt.accepts, cmd_vector },
+ { "addhostdir", &opt.add_hostdir, cmd_boolean },
+ { "alwaysrest", &opt.always_rest, cmd_boolean }, /* deprecated */
+ { "askpassword", &opt.ask_passwd, cmd_boolean },
+ { "authnochallenge", &opt.auth_without_challenge,
+ cmd_boolean },
+ { "background", &opt.background, cmd_boolean },
+ { "backupconverted", &opt.backup_converted, cmd_boolean },
+ { "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 },
+ { "cacertificate", &opt.ca_cert, cmd_file },
#endif
- { "cache", &opt.allow_cache, cmd_boolean },
+ { "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 },
+ { "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 },
- { "cookies", &opt.cookies, cmd_boolean },
- { "cutdirs", &opt.cut_dirs, cmd_number },
+ { "connecttimeout", &opt.connect_timeout, cmd_time },
+ { "contentdisposition", &opt.content_disposition, cmd_boolean },
+ { "continue", &opt.always_rest, cmd_boolean },
+ { "convertlinks", &opt.convert_links, cmd_boolean },
+ { "cookies", &opt.cookies, cmd_boolean },
+ { "cutdirs", &opt.cut_dirs, cmd_number },
#ifdef ENABLE_DEBUG
- { "debug", &opt.debug, cmd_boolean },
+ { "debug", &opt.debug, cmd_boolean },
#endif
- { "deleteafter", &opt.delete_after, 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 },
- { "dotspacing", &opt.dot_spacing, cmd_number },
- { "dotstyle", &opt.dot_style, cmd_string },
+ { "defaultpage", &opt.default_page, cmd_string},
+ { "deleteafter", &opt.delete_after, 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 },
+ { "dotspacing", &opt.dot_spacing, cmd_number },
+ { "dotstyle", &opt.dot_style, cmd_string },
#ifdef HAVE_SSL
- { "egdfile", &opt.egd_file, cmd_file },
+ { "egdfile", &opt.egd_file, cmd_file },
#endif
- { "excludedirectories", &opt.excludes, cmd_directory_vector },
- { "excludedomains", &opt.exclude_domains, cmd_vector },
- { "followftp", &opt.follow_ftp, cmd_boolean },
- { "followtags", &opt.follow_tags, cmd_vector },
- { "forcehtml", &opt.force_html, cmd_boolean },
- { "ftppasswd", &opt.ftp_passwd, cmd_string }, /* deprecated */
- { "ftppassword", &opt.ftp_passwd, cmd_string },
- { "ftpproxy", &opt.ftp_proxy, cmd_string },
- { "ftpuser", &opt.ftp_user, cmd_string },
- { "glob", &opt.ftp_glob, cmd_boolean },
- { "header", NULL, cmd_spec_header },
- { "htmlextension", &opt.html_extension, cmd_boolean },
- { "htmlify", NULL, cmd_spec_htmlify },
- { "httpkeepalive", &opt.http_keep_alive, cmd_boolean },
- { "httppasswd", &opt.http_passwd, cmd_string }, /* deprecated */
- { "httppassword", &opt.http_passwd, cmd_string },
- { "httpproxy", &opt.http_proxy, cmd_string },
- { "httpsproxy", &opt.https_proxy, cmd_string },
- { "httpuser", &opt.http_user, cmd_string },
- { "ignorecase", &opt.ignore_case, cmd_boolean },
- { "ignorelength", &opt.ignore_length, cmd_boolean },
- { "ignoretags", &opt.ignore_tags, cmd_vector },
- { "includedirectories", &opt.includes, cmd_directory_vector },
+ { "excludedirectories", &opt.excludes, cmd_directory_vector },
+ { "excludedomains", &opt.exclude_domains, cmd_vector },
+ { "followftp", &opt.follow_ftp, cmd_boolean },
+ { "followtags", &opt.follow_tags, cmd_vector },
+ { "forcehtml", &opt.force_html, cmd_boolean },
+ { "ftppasswd", &opt.ftp_passwd, cmd_string }, /* deprecated */
+ { "ftppassword", &opt.ftp_passwd, cmd_string },
+ { "ftpproxy", &opt.ftp_proxy, cmd_string },
+#ifdef __VMS
+ { "ftpstmlf", &opt.ftp_stmlf, cmd_boolean },
+#endif /* def __VMS */
+ { "ftpuser", &opt.ftp_user, cmd_string },
+ { "glob", &opt.ftp_glob, cmd_boolean },
+ { "header", NULL, cmd_spec_header },
+ { "htmlextension", &opt.html_extension, cmd_boolean },
+ { "htmlify", NULL, cmd_spec_htmlify },
+ { "httpkeepalive", &opt.http_keep_alive, cmd_boolean },
+ { "httppasswd", &opt.http_passwd, cmd_string }, /* deprecated */
+ { "httppassword", &opt.http_passwd, cmd_string },
+ { "httpproxy", &opt.http_proxy, cmd_string },
+ { "httpsproxy", &opt.https_proxy, cmd_string },
+ { "httpuser", &opt.http_user, cmd_string },
+ { "ignorecase", &opt.ignore_case, 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 },
+ { "inet4only", &opt.ipv4_only, cmd_boolean },
+ { "inet6only", &opt.ipv6_only, cmd_boolean },
#endif
- { "input", &opt.input_filename, cmd_file },
+ { "input", &opt.input_filename, cmd_file },
+ { "iri", &opt.enable_iri, cmd_boolean },
{ "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 },
- { "logfile", &opt.lfilename, cmd_file },
- { "login", &opt.ftp_user, cmd_string },/* deprecated*/
- { "mirror", NULL, cmd_spec_mirror },
- { "netrc", &opt.netrc, cmd_boolean },
- { "noclobber", &opt.noclobber, cmd_boolean },
- { "noparent", &opt.no_parent, cmd_boolean },
- { "noproxy", &opt.no_proxy, cmd_vector },
- { "numtries", &opt.ntry, cmd_number_inf },/* deprecated*/
- { "outputdocument", &opt.output_document, cmd_file },
- { "pagerequisites", &opt.page_requisites, cmd_boolean },
- { "passiveftp", &opt.ftp_pasv, cmd_boolean },
- { "passwd", &opt.ftp_passwd, cmd_string },/* deprecated*/
- { "password", &opt.passwd, cmd_string },
- { "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 },
+ { "limitrate", &opt.limit_rate, cmd_bytes },
+ { "loadcookies", &opt.cookies_input, cmd_file },
+ { "locale", &opt.locale, cmd_string },
+ { "logfile", &opt.lfilename, cmd_file },
+ { "login", &opt.ftp_user, cmd_string },/* deprecated*/
+ { "maxredirect", &opt.max_redirect, cmd_number },
+ { "mirror", NULL, cmd_spec_mirror },
+ { "netrc", &opt.netrc, cmd_boolean },
+ { "noclobber", &opt.noclobber, cmd_boolean },
+ { "noparent", &opt.no_parent, cmd_boolean },
+ { "noproxy", &opt.no_proxy, cmd_vector },
+ { "numtries", &opt.ntry, cmd_number_inf },/* deprecated*/
+ { "outputdocument", &opt.output_document, cmd_file },
+ { "pagerequisites", &opt.page_requisites, cmd_boolean },
+ { "passiveftp", &opt.ftp_pasv, cmd_boolean },
+ { "passwd", &opt.ftp_passwd, cmd_string },/* deprecated*/
+ { "password", &opt.passwd, cmd_string },
+ { "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 },
+ { "privatekey", &opt.private_key, cmd_file },
+ { "privatekeytype", &opt.private_key_type, cmd_cert_type },
#endif
- { "progress", &opt.progress_type, cmd_spec_progress },
+ { "progress", &opt.progress_type, cmd_spec_progress },
{ "protocoldirectories", &opt.protocol_directories, cmd_boolean },
- { "proxypasswd", &opt.proxy_passwd, cmd_string }, /* deprecated */
- { "proxypassword", &opt.proxy_passwd, cmd_string },
- { "proxyuser", &opt.proxy_user, cmd_string },
- { "quiet", &opt.quiet, cmd_boolean },
- { "quota", &opt.quota, cmd_bytes_sum },
+ { "proxypasswd", &opt.proxy_passwd, cmd_string }, /* deprecated */
+ { "proxypassword", &opt.proxy_passwd, cmd_string },
+ { "proxyuser", &opt.proxy_user, cmd_string },
+ { "quiet", &opt.quiet, cmd_boolean },
+ { "quota", &opt.quota, cmd_bytes_sum },
#ifdef HAVE_SSL
- { "randomfile", &opt.random_file, cmd_file },
+ { "randomfile", &opt.random_file, cmd_file },
#endif
- { "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 },
- { "reject", &opt.rejects, cmd_vector },
- { "relativeonly", &opt.relative_only, cmd_boolean },
- { "removelisting", &opt.remove_listing, cmd_boolean },
- { "restrictfilenames", NULL, cmd_spec_restrict_file_names },
- { "retrsymlinks", &opt.retr_symlinks, cmd_boolean },
- { "retryconnrefused", &opt.retry_connrefused, cmd_boolean },
- { "robots", &opt.use_robots, cmd_boolean },
- { "savecookies", &opt.cookies_output, cmd_file },
- { "saveheaders", &opt.save_headers, cmd_boolean },
+ { "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 },
+ { "reject", &opt.rejects, cmd_vector },
+ { "relativeonly", &opt.relative_only, cmd_boolean },
+ { "remoteencoding", &opt.encoding_remote, cmd_string },
+ { "removelisting", &opt.remove_listing, cmd_boolean },
+ { "restrictfilenames", NULL, cmd_spec_restrict_file_names },
+ { "retrsymlinks", &opt.retr_symlinks, cmd_boolean },
+ { "retryconnrefused", &opt.retry_connrefused, cmd_boolean },
+ { "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 },
+ { "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 },
+ { "strictcomments", &opt.strict_comments, cmd_boolean },
+ { "timeout", NULL, cmd_spec_timeout },
+ { "timestamping", &opt.timestamping, cmd_boolean },
+ { "tries", &opt.ntry, cmd_number_inf },
+ { "useproxy", &opt.use_proxy, cmd_boolean },
+ { "user", &opt.user, cmd_string },
+ { "useragent", NULL, cmd_spec_useragent },
+ { "verbose", NULL, cmd_spec_verbose },
+ { "wait", &opt.wait, cmd_time },
+ { "waitretry", &opt.waitretry, cmd_time },
+#ifdef MSDOS
+ { "wdebug", &opt.wdebug, cmd_boolean },
#endif
- { "serverresponse", &opt.server_response, cmd_boolean },
- { "spanhosts", &opt.spanhost, cmd_boolean },
- { "spider", &opt.spider, cmd_boolean },
- { "strictcomments", &opt.strict_comments, cmd_boolean },
- { "timeout", NULL, cmd_spec_timeout },
- { "timestamping", &opt.timestamping, cmd_boolean },
- { "tries", &opt.ntry, cmd_number_inf },
- { "useproxy", &opt.use_proxy, cmd_boolean },
- { "user", &opt.user, cmd_string },
- { "useragent", NULL, cmd_spec_useragent },
- { "verbose", NULL, cmd_spec_verbose },
- { "wait", &opt.wait, cmd_time },
- { "waitretry", &opt.waitretry, cmd_time }
};
/* Look up CMDNAME in the commands[] and return its position in the
int mid = (lo + hi) >> 1;
int cmp = strcasecmp (cmdname, commands[mid].name);
if (cmp < 0)
- hi = mid - 1;
+ hi = mid - 1;
else if (cmp > 0)
- lo = mid + 1;
+ lo = mid + 1;
else
- return mid;
+ return mid;
}
return -1;
}
tmp = getenv ("no_proxy");
if (tmp)
opt.no_proxy = sepstring (tmp);
+ opt.prefer_family = prefer_none;
opt.allow_cache = true;
opt.read_timeout = 900;
#endif
/* The default for file name restriction defaults to the OS type. */
-#if !defined(WINDOWS) && !defined(__CYGWIN__)
- opt.restrict_files_os = restrict_unix;
-#else
+#if defined(WINDOWS) || defined(MSDOS) || defined(__CYGWIN__)
opt.restrict_files_os = restrict_windows;
+#else
+ opt.restrict_files_os = restrict_unix;
#endif
opt.restrict_files_ctrl = true;
+ opt.restrict_files_case = restrict_no_case_restriction;
+
+ opt.max_redirect = 20;
+
+ opt.waitretry = 10;
+
+#ifdef ENABLE_IRI
+ opt.enable_iri = true;
+#else
+ opt.enable_iri = false;
+#endif
+ opt.locale = NULL;
+ opt.encoding_remote = NULL;
}
\f
/* Return the user's home directory (strdup-ed), or NULL if none is
char *
home_dir (void)
{
- char *home = getenv ("HOME");
+ static char buf[PATH_MAX];
+ static char *home;
if (!home)
{
-#ifndef WINDOWS
- /* If HOME is not defined, try getting it from the password
- file. */
- struct passwd *pwd = getpwuid (getuid ());
- if (!pwd || !pwd->pw_dir)
- return NULL;
- home = pwd->pw_dir;
-#else /* WINDOWS */
- /* Under Windows, if $HOME isn't defined, use the directory where
- `wget.exe' resides. */
- home = ws_mypath ();
+ home = getenv ("HOME");
+ if (!home)
+ {
+#if defined(MSDOS)
+ /* Under MSDOS, if $HOME isn't defined, use the directory where
+ `wget.exe' resides. */
+ const char *_w32_get_argv0 (void); /* in libwatt.a/pcconfig.c */
+ char *p;
+
+ strcpy (buf, _w32_get_argv0 ());
+ p = strrchr (buf, '/'); /* djgpp */
+ if (!p)
+ p = strrchr (buf, '\\'); /* others */
+ assert (p);
+ *p = '\0';
+ home = buf;
+#elif !defined(WINDOWS)
+ /* If HOME is not defined, try getting it from the password
+ file. */
+ struct passwd *pwd = getpwuid (getuid ());
+ if (!pwd || !pwd->pw_dir)
+ return NULL;
+ strcpy (buf, pwd->pw_dir);
+ home = buf;
+#else /* !WINDOWS */
+ /* Under Windows, if $HOME isn't defined, use the directory where
+ `wget.exe' resides. */
+ home = ws_mypath ();
#endif /* WINDOWS */
+ }
}
return home ? xstrdup (home) : NULL;
}
-/* Return the path to the user's .wgetrc. This is either the value of
- `WGETRC' environment variable, or `$HOME/.wgetrc'.
-
+/* Check the 'WGETRC' environment variable and return the file name
+ if 'WGETRC' is set and is a valid file.
If the `WGETRC' variable exists but the file does not exist, the
function will exit(). */
-static char *
-wgetrc_file_name (void)
+char *
+wgetrc_env_file_name (void)
{
- char *env, *home;
- char *file = NULL;
-
- /* Try the environment. */
- env = getenv ("WGETRC");
+ char *env = getenv ("WGETRC");
if (env && *env)
{
if (!file_exists_p (env))
- {
- fprintf (stderr, _("%s: WGETRC points to %s, which doesn't exist.\n"),
- exec_name, env);
- exit (1);
- }
+ {
+ fprintf (stderr, _("%s: WGETRC points to %s, which doesn't exist.\n"),
+ exec_name, env);
+ exit (1);
+ }
return xstrdup (env);
}
+ return NULL;
+}
+
+/* Check for the existance of '$HOME/.wgetrc' and return it's path
+ if it exists and is set. */
+char *
+wgetrc_user_file_name (void)
+{
+ char *home = home_dir ();
+ char *file = NULL;
+ /* If that failed, try $HOME/.wgetrc (or equivalent). */
- /* If that failed, try $HOME/.wgetrc. */
+#ifdef __VMS
+ file = "SYS$LOGIN:.wgetrc";
+#else /* def __VMS */
home = home_dir ();
if (home)
file = aprintf ("%s/.wgetrc", home);
xfree_null (home);
+#endif /* def __VMS [else] */
+
+ if (!file)
+ return NULL;
+ if (!file_exists_p (file))
+ {
+ xfree (file);
+ return NULL;
+ }
+ return file;
+}
+
+/* Return the path to the user's .wgetrc. This is either the value of
+ `WGETRC' environment variable, or `$HOME/.wgetrc'.
+
+ Additionally, for windows, look in the directory where wget.exe
+ resides. */
+char *
+wgetrc_file_name (void)
+{
+ char *file = wgetrc_env_file_name ();
+ if (file && *file)
+ return file;
+
+ file = wgetrc_user_file_name ();
#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))
+ if (!file)
{
+ char *home = home_dir ();
xfree_null (file);
file = NULL;
home = ws_mypath ();
if (home)
- file = aprintf ("%s/wget.ini", home);
+ {
+ file = aprintf ("%s/wget.ini", home);
+ if (!file_exists_p (file))
+ {
+ xfree (file);
+ file = NULL;
+ }
+ xfree (home);
+ }
}
#endif /* WINDOWS */
- if (!file)
- return NULL;
- if (!file_exists_p (file))
- {
- xfree (file);
- return NULL;
- }
return file;
}
static enum parse_line parse_line (const char *, char **, char **, int *);
static bool setval_internal (int, const char *, const char *);
+static bool setval_internal_tilde (int, const char *, const char *);
/* Initialize variables from a wgetrc file. Returns zero (failure) if
there were errors in the file. */
int ln;
int errcnt = 0;
- fp = fopen (file, "rb");
+ fp = fopen (file, "r");
if (!fp)
{
fprintf (stderr, _("%s: Cannot read %s (%s).\n"), exec_name,
- file, strerror (errno));
- return true; /* not a fatal error */
+ file, strerror (errno));
+ return true; /* not a fatal error */
}
- enable_tilde_expansion = true;
ln = 1;
while ((line = read_whole_line (fp)) != NULL)
{
/* Parse the line. */
switch (parse_line (line, &com, &val, &comind))
- {
- case line_ok:
- /* If everything is OK, set the value. */
- if (!setval_internal (comind, com, val))
- {
- fprintf (stderr, _("%s: Error in %s at line %d.\n"),
- exec_name, file, ln);
- ++errcnt;
- }
- break;
- case line_syntax_error:
- fprintf (stderr, _("%s: Syntax error in %s at line %d.\n"),
- exec_name, file, ln);
- ++errcnt;
- break;
- case line_unknown_command:
- fprintf (stderr, _("%s: Unknown command `%s' in %s at line %d.\n"),
- exec_name, com, file, ln);
- ++errcnt;
- break;
- case line_empty:
- break;
- default:
- abort ();
- }
+ {
+ case line_ok:
+ /* If everything is OK, set the value. */
+ if (!setval_internal_tilde (comind, com, val))
+ {
+ fprintf (stderr, _("%s: Error in %s at line %d.\n"),
+ exec_name, file, ln);
+ ++errcnt;
+ }
+ break;
+ case line_syntax_error:
+ fprintf (stderr, _("%s: Syntax error in %s at line %d.\n"),
+ exec_name, file, ln);
+ ++errcnt;
+ break;
+ case line_unknown_command:
+ fprintf (stderr, _("%s: Unknown command %s in %s at line %d.\n"),
+ exec_name, quote (com), file, ln);
+ ++errcnt;
+ break;
+ case line_empty:
+ break;
+ default:
+ abort ();
+ }
xfree_null (com);
xfree_null (val);
xfree (line);
++ln;
}
- enable_tilde_expansion = false;
fclose (fp);
return errcnt == 0;
void
initialize (void)
{
- char *file;
+ char *file, *env_sysrc;
int ok = true;
/* Load the hard-coded defaults. */
defaults ();
-
- /* If SYSTEM_WGETRC is defined, use it. */
+
+ /* Run a non-standard system rc file when the according environment
+ variable has been set. For internal testing purposes only! */
+ env_sysrc = getenv ("SYSTEM_WGETRC");
+ if (env_sysrc && file_exists_p (env_sysrc))
+ ok &= run_wgetrc (env_sysrc);
+ /* Otherwise, if SYSTEM_WGETRC is defined, use it. */
#ifdef SYSTEM_WGETRC
- if (file_exists_p (SYSTEM_WGETRC))
+ else if (file_exists_p (SYSTEM_WGETRC))
ok &= run_wgetrc (SYSTEM_WGETRC);
#endif
/* Override it with your own, if one exists. */
if (!strcmp (file, SYSTEM_WGETRC))
{
fprintf (stderr, _("\
-%s: Warning: Both system and user wgetrc point to `%s'.\n"),
- exec_name, file);
+%s: Warning: Both system and user wgetrc point to %s.\n"),
+ exec_name, quote (file));
}
else
#endif
xfree (file);
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 */
+ char *t = s; /* t - tortoise */
+ char *h = s; /* h - hare */
while (*h)
if (*h == '_' || *h == '-')
++h;
int ind;
/* Skip leading and trailing whitespace. */
- while (*line && ISSPACE (*line))
+ while (*line && c_isspace (*line))
++line;
- while (end > line && ISSPACE (end[-1]))
+ while (end > line && c_isspace (end[-1]))
--end;
/* Skip empty lines and comments. */
p = line;
cmdstart = p;
- while (p < end && (ISALNUM (*p) || *p == '_' || *p == '-'))
+ while (p < end && (c_isalnum (*p) || *p == '_' || *p == '-'))
++p;
cmdend = p;
/* Skip '=', as well as any space before or after it. */
- while (p < end && ISSPACE (*p))
+ while (p < end && c_isspace (*p))
++p;
if (p == end || *p != '=')
return line_syntax_error;
++p;
- while (p < end && ISSPACE (*p))
+ while (p < end && c_isspace (*p))
++p;
valstart = p;
return line_ok;
}
+#if defined(WINDOWS) || defined(MSDOS)
+# define ISSEP(c) ((c) == '/' || (c) == '\\')
+#else
+# define ISSEP(c) ((c) == '/')
+#endif
+
/* Run commands[comind].action. */
static bool
setval_internal (int comind, const char *com, const char *val)
{
- assert (0 <= comind && comind < countof (commands));
+ assert (0 <= comind && ((size_t) comind) < countof (commands));
DEBUGP (("Setting %s (%s) to %s\n", com, commands[comind].name, val));
return commands[comind].action (com, val, commands[comind].place);
}
+static bool
+setval_internal_tilde (int comind, const char *com, const char *val)
+{
+ bool ret;
+ int homelen;
+ char *home;
+ char **pstring;
+ ret = setval_internal (comind, com, val);
+
+ /* We make tilde expansion for cmd_file and cmd_directory */
+ if (((commands[comind].action == cmd_file) ||
+ (commands[comind].action == cmd_directory))
+ && ret && (*val == '~' && ISSEP (val[1])))
+ {
+ pstring = commands[comind].place;
+ home = home_dir ();
+ if (home)
+ {
+ homelen = strlen (home);
+ while (homelen && ISSEP (home[homelen - 1]))
+ home[--homelen] = '\0';
+
+ /* Skip the leading "~/". */
+ for (++val; ISSEP (*val); val++)
+ ;
+ *pstring = concat_strings (home, "/", val, (char *)0);
+ }
+ }
+ return ret;
+}
+
/* Run command COM with value VAL. If running the command produces an
error, report the error and exit.
{
case line_ok:
if (!setval_internal (comind, com, val))
- exit (2);
+ exit (2);
xfree (com);
xfree (val);
break;
default:
- fprintf (stderr, _("%s: Invalid --execute command `%s'\n"),
- exec_name, opt);
+ fprintf (stderr, _("%s: Invalid --execute command %s\n"),
+ exec_name, quote (opt));
exit (2);
}
}
static bool simple_atoi (const char *, const char *, int *);
static bool simple_atof (const char *, const char *, double *);
-#define CMP1(p, c0) (TOLOWER((p)[0]) == (c0) && (p)[1] == '\0')
+#define CMP1(p, c0) (c_tolower((p)[0]) == (c0) && (p)[1] == '\0')
-#define CMP2(p, c0, c1) (TOLOWER((p)[0]) == (c0) \
- && TOLOWER((p)[1]) == (c1) \
- && (p)[2] == '\0')
+#define CMP2(p, c0, c1) (c_tolower((p)[0]) == (c0) \
+ && c_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')
+#define CMP3(p, c0, c1, c2) (c_tolower((p)[0]) == (c0) \
+ && c_tolower((p)[1]) == (c1) \
+ && c_tolower((p)[2]) == (c2) \
+ && (p)[3] == '\0')
/* Store the boolean value from VAL to PLACE. COM is ignored,
else
{
fprintf (stderr,
- _("%s: %s: Invalid boolean `%s'; use `on' or `off'.\n"),
- exec_name, com, val);
+ _("%s: %s: Invalid boolean %s; use `on' or `off'.\n"),
+ exec_name, com, quote (val));
return false;
}
if (!simple_atoi (val, val + strlen (val), place)
|| *(int *) place < 0)
{
- fprintf (stderr, _("%s: %s: Invalid number `%s'.\n"),
- exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid number %s.\n"),
+ exec_name, com, quote (val));
return false;
}
return true;
return true;
}
-#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
/* #### If VAL is empty, perhaps should set *PLACE to NULL. */
- if (!enable_tilde_expansion || !(*val == '~' && ISSEP (val[1])))
- {
- noexpand:
- *pstring = xstrdup (val);
- }
- else
- {
- int homelen;
- char *home = home_dir ();
- if (!home)
- goto noexpand;
-
- homelen = strlen (home);
- while (homelen && ISSEP (home[homelen - 1]))
- home[--homelen] = '\0';
-
- /* Skip the leading "~/". */
- for (++val; ISSEP (*val); val++)
- ;
-
- *pstring = concat_strings (home, "/", val, (char *) 0);
- }
+ *pstring = xstrdup (val);
-#ifdef WINDOWS
+#if defined(WINDOWS) || defined(MSDOS)
/* Convert "\" to "/". */
{
char *s;
for (s = *pstring; *s; s++)
if (*s == '\\')
- *s = '/';
+ *s = '/';
}
#endif
return true;
seps = sepstring (val);
for (t = seps; t && *t; t++)
- {
- int len = strlen (*t);
- /* Skip degenerate case of root directory. */
- if (len > 1)
- {
- if ((*t)[len - 1] == '/')
- (*t)[len - 1] = '\0';
- }
- }
+ {
+ int len = strlen (*t);
+ /* Skip degenerate case of root directory. */
+ if (len > 1)
+ {
+ if ((*t)[len - 1] == '/')
+ (*t)[len - 1] = '\0';
+ }
+ }
*pvec = merge_vecs (*pvec, seps);
}
else
}
/* Strip trailing whitespace. */
- while (val < end && ISSPACE (end[-1]))
+ while (val < end && c_isspace (end[-1]))
--end;
if (val == end)
return false;
- switch (TOLOWER (end[-1]))
+ switch (c_tolower (end[-1]))
{
case 'k':
--end, mult = 1024.0;
break;
default:
/* Not a recognized suffix: assume it's a digit. (If not,
- simple_atof will raise an error.) */
+ simple_atof will raise an error.) */
mult = 1;
}
/* Skip leading and trailing whitespace. */
- while (val < end && ISSPACE (*val))
+ while (val < end && c_isspace (*val))
++val;
- while (val < end && ISSPACE (end[-1]))
+ while (val < end && c_isspace (end[-1]))
--end;
if (val == end)
return false;
double byte_value;
if (!parse_bytes_helper (val, &byte_value))
{
- fprintf (stderr, _("%s: %s: Invalid byte value `%s'\n"),
- exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid byte value %s\n"),
+ exec_name, com, quote (val));
return false;
}
*(wgint *)place = (wgint)byte_value;
double byte_value;
if (!parse_bytes_helper (val, &byte_value))
{
- fprintf (stderr, _("%s: %s: Invalid byte value `%s'\n"),
- exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid byte value %s\n"),
+ exec_name, com, quote (val));
return false;
}
*(SUM_SIZE_INT *) place = (SUM_SIZE_INT) byte_value;
const char *end = val + strlen (val);
/* Strip trailing whitespace. */
- while (val < end && ISSPACE (end[-1]))
+ while (val < end && c_isspace (end[-1]))
--end;
if (val == end)
{
err:
- fprintf (stderr, _("%s: %s: Invalid time period `%s'\n"),
- exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid time period %s\n"),
+ exec_name, com, quote (val));
return false;
}
- switch (TOLOWER (end[-1]))
+ switch (c_tolower (end[-1]))
{
case 's':
- --end, mult = 1; /* seconds */
+ --end, mult = 1; /* seconds */
break;
case 'm':
- --end, mult = 60; /* minutes */
+ --end, mult = 60; /* minutes */
break;
case 'h':
- --end, mult = 3600; /* hours */
+ --end, mult = 3600; /* hours */
break;
case 'd':
- --end, mult = 86400.0; /* days */
+ --end, mult = 86400.0; /* days */
break;
case 'w':
- --end, mult = 604800.0; /* weeks */
+ --end, mult = 604800.0; /* weeks */
break;
default:
/* Not a recognized suffix: assume it belongs to the number.
- (If not, simple_atof will raise an error.) */
+ (If not, simple_atof will raise an error.) */
mult = 1;
}
/* Skip leading and trailing whitespace. */
- while (val < end && ISSPACE (*val))
+ while (val < end && c_isspace (*val))
++val;
- while (val < end && ISSPACE (end[-1]))
+ while (val < end && c_isspace (end[-1]))
--end;
if (val == end)
goto err;
};
int ok = decode_string (val, choices, countof (choices), place);
if (!ok)
- fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid value %s.\n"), exec_name, com, quote (val));
return ok;
}
#endif
if (!check_user_specified_header (val))
{
- fprintf (stderr, _("%s: %s: Invalid header `%s'.\n"),
- exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid header %s.\n"),
+ exec_name, com, quote (val));
return false;
}
opt.user_headers = vec_append (opt.user_headers, val);
{
opt.recursive = true;
if (!opt.no_dirstruct)
- opt.dirstruct = true;
+ opt.dirstruct = true;
opt.timestamping = true;
opt.reclevel = INFINITE_RECURSION;
opt.remove_listing = false;
{ "IPv6", prefer_ipv6 },
{ "none", prefer_none },
};
- int ok = decode_string (val, choices, countof (choices),
- (int *) &opt.prefer_family);
+ int prefer_family = prefer_none;
+ int ok = decode_string (val, choices, countof (choices), &prefer_family);
if (!ok)
- fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid value %s.\n"), exec_name, com, quote (val));
+ opt.prefer_family = prefer_family;
return ok;
}
{
if (!valid_progress_implementation_p (val))
{
- fprintf (stderr, _("%s: %s: Invalid progress type `%s'.\n"),
- exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid progress type %s.\n"),
+ exec_name, com, quote (val));
return false;
}
xfree_null (opt.progress_type);
else
{
if (opt.recursive && !opt.no_dirstruct)
- opt.dirstruct = true;
+ opt.dirstruct = true;
}
return true;
}
{
int restrict_os = opt.restrict_files_os;
int restrict_ctrl = opt.restrict_files_ctrl;
+ int restrict_case = opt.restrict_files_case;
- const char *end = strchr (val, ',');
- if (!end)
- end = val + strlen (val);
+ const char *end;
#define VAL_IS(string_literal) BOUNDED_EQUAL (val, end, string_literal)
- if (VAL_IS ("unix"))
- restrict_os = restrict_unix;
- else if (VAL_IS ("windows"))
- restrict_os = restrict_windows;
- else if (VAL_IS ("nocontrol"))
- restrict_ctrl = 0;
- else
+ do
{
- err:
- fprintf (stderr,
- _("%s: %s: Invalid restriction `%s', use `unix' or `windows'.\n"),
- exec_name, com, val);
- return false;
+ end = strchr (val, ',');
+ if (!end)
+ end = val + strlen (val);
+
+ if (VAL_IS ("unix"))
+ restrict_os = restrict_unix;
+ else if (VAL_IS ("windows"))
+ restrict_os = restrict_windows;
+ else if (VAL_IS ("lowercase"))
+ restrict_case = restrict_lowercase;
+ else if (VAL_IS ("uppercase"))
+ restrict_case = restrict_uppercase;
+ else if (VAL_IS ("nocontrol"))
+ restrict_ctrl = false;
+ else
+ {
+ fprintf (stderr,
+ _("%s: %s: Invalid restriction %s, use [unix|windows],[lowercase|uppercase],[nocontrol].\n"),
+ exec_name, com, quote (val));
+ return false;
+ }
+
+ if (*end)
+ val = end + 1;
}
+ while (*val && *end);
#undef VAL_IS
- if (*end)
- {
- if (!strcmp (end + 1, "nocontrol"))
- restrict_ctrl = false;
- else
- goto err;
- }
-
opt.restrict_files_os = restrict_os;
opt.restrict_files_ctrl = restrict_ctrl;
+ opt.restrict_files_case = restrict_case;
+
return true;
}
};
int ok = decode_string (val, choices, countof (choices), place);
if (!ok)
- fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid value %s.\n"), exec_name, com, quote (val));
return ok;
}
#endif
/* Disallow embedded newlines. */
if (strchr (val, '\n'))
{
- fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"),
- exec_name, com, val);
+ fprintf (stderr, _("%s: %s: Invalid value %s.\n"),
+ exec_name, com, quote (val));
return false;
}
xfree_null (opt.useragent);
bool negative = false;
const char *p = beg;
- while (p < end && ISSPACE (*p))
+ while (p < end && c_isspace (*p))
++p;
if (p < end && (*p == '-' || *p == '+'))
{
negative integer cannot be represented as a positive number. */
if (!negative)
- for (; p < end && ISDIGIT (*p); p++)
+ for (; p < end && c_isdigit (*p); p++)
{
- int next = (10 * result) + (*p - '0');
- if (next < result)
- return false; /* overflow */
- result = next;
+ int next = (10 * result) + (*p - '0');
+ if (next < result)
+ return false; /* overflow */
+ result = next;
}
else
- for (; p < end && ISDIGIT (*p); p++)
+ for (; p < end && c_isdigit (*p); p++)
{
- int next = (10 * result) - (*p - '0');
- if (next > result)
- return false; /* underflow */
- result = next;
+ int next = (10 * result) - (*p - '0');
+ if (next > result)
+ return false; /* underflow */
+ result = next;
}
if (p != end)
const char *p = beg;
- while (p < end && ISSPACE (*p))
+ while (p < end && c_isspace (*p))
++p;
if (p < end && (*p == '-' || *p == '+'))
{
for (; 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 = true;
- }
+ if (c_isdigit (ch))
+ {
+ if (!seen_dot)
+ result = (10 * result) + (ch - '0');
+ else
+ result += (ch - '0') / (divider *= 10);
+ seen_digit = true;
+ }
else if (ch == '.')
- {
- if (!seen_dot)
- seen_dot = true;
- else
- return false;
- }
+ {
+ if (!seen_dot)
+ seen_dot = true;
+ else
+ return false;
+ }
else
- return false;
+ return false;
}
if (!seen_digit)
return false;
{
const char *p;
- for (p = s; *p && *p != ':' && !ISSPACE (*p); p++)
+ for (p = s; *p && *p != ':' && !c_isspace (*p); p++)
;
/* The header MUST contain `:' preceded by at least one
non-whitespace character. */
static bool
decode_string (const char *val, const struct decode_item *items, int itemcount,
- int *place)
+ int *place)
{
int i;
for (i = 0; i < itemcount; i++)
if (0 == strcasecmp (val, items[i].name))
{
- *place = items[i].code;
- return true;
+ *place = items[i].code;
+ return true;
}
return false;
}
xfree_null (opt.cookies_output);
xfree_null (opt.user);
xfree_null (opt.passwd);
+ xfree_null (opt.base_href);
+
#endif /* DEBUG_MALLOC */
}
+\f
+/* Unit testing routines. */
+
+#ifdef TESTING
+
+const char *
+test_commands_sorted()
+{
+ int prev_idx = 0, next_idx = 1;
+ int command_count = countof (commands) - 1;
+ int cmp = 0;
+ while (next_idx <= command_count)
+ {
+ cmp = strcasecmp (commands[prev_idx].name, commands[next_idx].name);
+ if (cmp > 0)
+ {
+ mu_assert ("FAILED", false);
+ break;
+ }
+ else
+ {
+ prev_idx ++;
+ next_idx ++;
+ }
+ }
+ return NULL;
+}
+
+const char *
+test_cmd_spec_restrict_file_names()
+{
+ int i;
+ struct {
+ char *val;
+ int expected_restrict_files_os;
+ int expected_restrict_files_ctrl;
+ int expected_restrict_files_case;
+ bool result;
+ } test_array[] = {
+ { "windows", restrict_windows, true, restrict_no_case_restriction, true },
+ { "windows,", restrict_windows, true, restrict_no_case_restriction, true },
+ { "windows,lowercase", restrict_windows, true, restrict_lowercase, true },
+ { "unix,nocontrol,lowercase,", restrict_unix, false, restrict_lowercase, true },
+ };
+
+ for (i = 0; i < sizeof(test_array)/sizeof(test_array[0]); ++i)
+ {
+ bool res;
+
+ defaults();
+ res = cmd_spec_restrict_file_names ("dummy", test_array[i].val, NULL);
+
+ /*
+ fprintf (stderr, "test_cmd_spec_restrict_file_names: TEST %d\n", i); fflush (stderr);
+ fprintf (stderr, "opt.restrict_files_os: %d\n", opt.restrict_files_os); fflush (stderr);
+ fprintf (stderr, "opt.restrict_files_ctrl: %d\n", opt.restrict_files_ctrl); fflush (stderr);
+ fprintf (stderr, "opt.restrict_files_case: %d\n", opt.restrict_files_case); fflush (stderr);
+ */
+ mu_assert ("test_cmd_spec_restrict_file_names: wrong result",
+ res == test_array[i].result
+ && opt.restrict_files_os == test_array[i].expected_restrict_files_os
+ && opt.restrict_files_ctrl == test_array[i].expected_restrict_files_ctrl
+ && opt.restrict_files_case == test_array[i].expected_restrict_files_case);
+ }
+
+ return NULL;
+}
+
+#endif /* TESTING */
+