/* Reading/parsing the initialization file.
- Copyright (C) 2005 Free Software Foundation, Inc.
+ Copyright (C) 1996-2006 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., 675 Mass Ave, Cambridge, MA 02139, 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
#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
/* We want tilde expansion enabled only when reading `.wgetrc' lines;
otherwise, it will be performed by the shell. This variable will
CMD_DECLARE (cmd_boolean);
CMD_DECLARE (cmd_bytes);
-CMD_DECLARE (cmd_bytes_large);
+CMD_DECLARE (cmd_bytes_sum);
#ifdef HAVE_SSL
CMD_DECLARE (cmd_cert_type);
#endif
/* 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 {
const char *name;
void *place;
bool (*action) (const char *, const char *, void *);
} commands[] = {
+ /* KEEP THIS LIST ALPHABETICALLY SORTED */
{ "accept", &opt.accepts, cmd_vector },
{ "addhostdir", &opt.add_hostdir, cmd_boolean },
{ "alwaysrest", &opt.always_rest, cmd_boolean }, /* deprecated */
{ "checkcertificate", &opt.check_cert, cmd_boolean },
#endif
{ "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 },
{ "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 },
#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 },
{ "logfile", &opt.lfilename, cmd_file },
{ "proxypassword", &opt.proxy_passwd, cmd_string },
{ "proxyuser", &opt.proxy_user, cmd_string },
{ "quiet", &opt.quiet, cmd_boolean },
- { "quota", &opt.quota, cmd_bytes_large },
+ { "quota", &opt.quota, cmd_bytes_sum },
#ifdef HAVE_SSL
{ "randomfile", &opt.random_file, cmd_file },
#endif
opt.restrict_files_os = restrict_windows;
#endif
opt.restrict_files_ctrl = true;
+ opt.restrict_files_case = restrict_no_case_restriction;
+
+ opt.content_disposition = true;
}
\f
/* Return the user's home directory (strdup-ed), or NULL if none is
p = line;
cmdstart = p;
- while (p < end && (ISALPHA (*p) || *p == '_' || *p == '-'))
+ while (p < end && (ISALNUM (*p) || *p == '_' || *p == '-'))
++p;
cmdend = p;
return true;
}
-/* Engine for cmd_bytes and cmd_bytes_large: converts a string such as
+/* Engine for cmd_bytes and cmd_bytes_sum: converts a string such as
"100k" or "2.5G" to a floating point number. */
static bool
}
/* Like cmd_bytes, but PLACE is interpreted as a pointer to
- LARGE_INT. It works by converting the string to double, therefore
+ SIZE_SUM. 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 bool
-cmd_bytes_large (const char *com, const char *val, void *place)
+cmd_bytes_sum (const char *com, const char *val, void *place)
{
double byte_value;
if (!parse_bytes_helper (val, &byte_value))
exec_name, com, val);
return false;
}
- *(LARGE_INT *)place = (LARGE_INT)byte_value;
+ *(SUM_SIZE_INT *) place = (SUM_SIZE_INT) byte_value;
return true;
}
{ "IPv6", prefer_ipv6 },
{ "none", prefer_none },
};
- int ok = decode_string (val, choices, countof (choices),
- (int *) &opt.prefer_family);
+ int prefer_family = prefer_ipv4;
+ int ok = decode_string (val, choices, countof (choices), &prefer_family);
if (!ok)
fprintf (stderr, _("%s: %s: Invalid value `%s'.\n"), exec_name, com, val);
+ opt.prefer_family = prefer_family;
return ok;
}
{
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, 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;
}
{
const char *p;
- for (p = s; *p && *p != ':' && !ISSPACE (*p); p++);
+ for (p = s; *p && *p != ':' && !ISSPACE (*p); p++)
+ ;
/* The header MUST contain `:' preceded by at least one
non-whitespace character. */
if (*p != ':' || p == s)
\f
void cleanup_html_url (void);
-void http_cleanup (void);
/* Free the memory allocated by global variables. */
{
/* Free external resources, close files, etc. */
- {
- 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. */
- }
+ 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
xfree_null (opt.passwd);
#endif /* DEBUG_MALLOC */
}
+\f
+/* Unit testing routines. */
+
+#ifdef TESTING
+
+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 */
+
projects / wget / blobdiff