/* Reading/parsing the initialization file.
- Copyright (C) 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001
+ Free Software Foundation, Inc.
-This file is part of Wget.
+This file is part of GNU Wget.
-This program is free software; you can redistribute it and/or modify
+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
(at your option) any later version.
-This program is distributed in the hope that it will be useful,
+GNU Wget is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
+along with Wget; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <config.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>
#include "recur.h"
#include "netrc.h"
#include "cookies.h" /* for cookies_cleanup */
+#include "progress.h"
#ifndef errno
extern int errno;
CMD_DECLARE (cmd_number_inf);
CMD_DECLARE (cmd_string);
CMD_DECLARE (cmd_file);
+CMD_DECLARE (cmd_directory);
CMD_DECLARE (cmd_time);
CMD_DECLARE (cmd_vector);
CMD_DECLARE (cmd_spec_dirstruct);
-CMD_DECLARE (cmd_spec_dotstyle);
CMD_DECLARE (cmd_spec_header);
CMD_DECLARE (cmd_spec_htmlify);
CMD_DECLARE (cmd_spec_mirror);
+CMD_DECLARE (cmd_spec_progress);
CMD_DECLARE (cmd_spec_recursive);
CMD_DECLARE (cmd_spec_useragent);
{ "debug", &opt.debug, cmd_boolean },
#endif
{ "deleteafter", &opt.delete_after, cmd_boolean },
- { "dirprefix", &opt.dir_prefix, cmd_file },
+ { "dirprefix", &opt.dir_prefix, cmd_directory },
{ "dirstruct", NULL, cmd_spec_dirstruct },
{ "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", NULL, cmd_spec_dotstyle },
+ { "dotstyle", &opt.dot_style, cmd_string },
{ "excludedirectories", &opt.excludes, cmd_directory_vector },
{ "excludedomains", &opt.exclude_domains, cmd_vector },
{ "followftp", &opt.follow_ftp, cmd_boolean },
{ "includedirectories", &opt.includes, cmd_directory_vector },
{ "input", &opt.input_filename, cmd_file },
{ "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_acc, cmd_string },
{ "pagerequisites", &opt.page_requisites, cmd_boolean },
{ "passiveftp", &opt.ftp_pasv, cmd_lockable_boolean },
{ "passwd", &opt.ftp_pass, cmd_string },
+ { "progress", &opt.progress_type, cmd_spec_progress },
{ "proxypasswd", &opt.proxy_passwd, cmd_string },
{ "proxyuser", &opt.proxy_user, cmd_string },
{ "quiet", &opt.quiet, cmd_boolean },
{ "quota", &opt.quota, cmd_bytes },
+ { "randomwait", &opt.random_wait, cmd_boolean },
{ "reclevel", &opt.reclevel, cmd_number_inf },
{ "recursive", NULL, cmd_spec_recursive },
{ "referer", &opt.referer, cmd_string },
{ "savecookies", &opt.cookies_output, cmd_file },
{ "saveheaders", &opt.save_headers, cmd_boolean },
{ "serverresponse", &opt.server_response, cmd_boolean },
- { "simplehostcheck", &opt.simple_check, cmd_boolean },
{ "spanhosts", &opt.spanhost, cmd_boolean },
{ "spider", &opt.spider, cmd_boolean },
#ifdef HAVE_SSL
{ "sslcertfile", &opt.sslcertfile, cmd_file },
{ "sslcertkey", &opt.sslcertkey, cmd_file },
+ { "egdfile", &opt.sslegdsock, cmd_file },
#endif /* HAVE_SSL */
{ "timeout", &opt.timeout, cmd_time },
{ "timestamping", &opt.timestamping, cmd_boolean },
{
if (!file_exists_p (env))
{
- fprintf (stderr, "%s: %s: %s.\n", exec_name, file, strerror (errno));
+ fprintf (stderr, "%s: %s: %s.\n", exec_name, env, strerror (errno));
exit (1);
}
return xstrdup (env);
static int
cmd_address (const char *com, const char *val, void *closure)
{
- struct sockaddr_in sin;
- struct sockaddr_in **target = (struct sockaddr_in **)closure;
+ struct address_list *al;
+ wget_sockaddr sa;
+ wget_sockaddr **target = (wget_sockaddr **)closure;
+
+ memset (&sa, '\0', sizeof (sa));
- if (!store_hostaddress ((unsigned char *)&sin.sin_addr, val))
+ al = lookup_host (val, 1);
+ if (!al)
{
fprintf (stderr, _("%s: %s: Cannot convert `%s' to an IP address.\n"),
exec_name, com, val);
return 0;
}
-
- sin.sin_family = AF_INET;
- sin.sin_port = 0;
+ sa.sa.sa_family = ip_default_family;
+ wget_sockaddr_set_port (&sa, 0);
+ address_list_copy_one (al, 0, wget_sockaddr_get_addr (&sa));
+ address_list_release (al);
FREE_MAYBE (*target);
- *target = xmalloc (sizeof (sin));
- memcpy (*target, &sin, sizeof (sin));
+ *target = xmalloc (sizeof (sa));
+ memcpy (*target, &sa, sizeof (sa));
return 1;
}
char **pstring = (char **)closure;
FREE_MAYBE (*pstring);
- if (!enable_tilde_expansion || !(*val == '~' && *(val + 1) == '/'))
+
+ /* #### If VAL is empty, perhaps should set *CLOSURE to NULL. */
+
+ if (!enable_tilde_expansion || !(*val == '~' && (*(val + 1) == '/'
+#ifdef WINDOWS
+ || *(val + 1) == '\\'
+#endif
+ )))
{
noexpand:
*pstring = xstrdup (val);
goto noexpand;
homelen = strlen (home);
- while (homelen && home[homelen - 1] == '/')
+ while (homelen && (home[homelen - 1] == '/'
+#ifdef WINDOWS
+ || home[homelen - 1] == '\\'
+#endif
+ ))
home[--homelen] = '\0';
/* Skip the leading "~/". */
+#ifdef WINDOWS
+ for (++val; *val == '/' || *val == '\\'; val++)
+ ;
+#else
for (++val; *val == '/'; val++)
;
+#endif
result = xmalloc (homelen + 1 + strlen (val));
memcpy (result, home, homelen);
*pstring = result;
}
+#ifdef WINDOWS
+ /* Convert "\" to "/". */
+ {
+ char *s;
+ for (s = *pstring; *s; s++)
+ if (*s == '\\')
+ *s = '/';
+ }
+#endif
+ return 1;
+}
+
+/* Like cmd_file, but strips trailing '/' characters. */
+static int
+cmd_directory (const char *com, const char *val, void *closure)
+{
+ 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))
+ return 0;
+
+ s = *(char **)closure;
+ t = s + strlen (s);
+ while (t > s && *--t == '/')
+ *t = '\0';
+
return 1;
}
return 1;
}
-static int
-cmd_spec_dotstyle (const char *com, const char *val, void *closure)
-{
- /* Retrieval styles. */
- if (!strcasecmp (val, "default"))
- {
- /* Default style: 1K dots, 10 dots in a cluster, 50 dots in a
- line. */
- opt.dot_bytes = 1024;
- opt.dot_spacing = 10;
- opt.dots_in_line = 50;
- }
- else if (!strcasecmp (val, "binary"))
- {
- /* "Binary" retrieval: 8K dots, 16 dots in a cluster, 48 dots
- (384K) in a line. */
- opt.dot_bytes = 8192;
- opt.dot_spacing = 16;
- opt.dots_in_line = 48;
- }
- else if (!strcasecmp (val, "mega"))
- {
- /* "Mega" retrieval, for retrieving very long files; each dot is
- 64K, 8 dots in a cluster, 6 clusters (3M) in a line. */
- opt.dot_bytes = 65536L;
- opt.dot_spacing = 8;
- opt.dots_in_line = 48;
- }
- else if (!strcasecmp (val, "giga"))
- {
- /* "Giga" retrieval, for retrieving very very *very* long files;
- each dot is 1M, 8 dots in a cluster, 4 clusters (32M) in a
- line. */
- opt.dot_bytes = (1L << 20);
- opt.dot_spacing = 8;
- opt.dots_in_line = 32;
- }
- else if (!strcasecmp (val, "micro"))
- {
- /* "Micro" retrieval, for retrieving very small files (and/or
- slow connections); each dot is 128 bytes, 8 dots in a
- cluster, 6 clusters (6K) in a line. */
- opt.dot_bytes = 128;
- opt.dot_spacing = 8;
- opt.dots_in_line = 48;
- }
- else
- {
- fprintf (stderr, _("%s: %s: Invalid specification `%s'.\n"),
- exec_name, com, val);
- return 0;
- }
- return 1;
-}
-
static int
cmd_spec_header (const char *com, const char *val, void *closure)
{
return 1;
}
+static int
+cmd_spec_progress (const char *com, const char *val, void *closure)
+{
+ if (!valid_progress_implementation_p (val))
+ {
+ fprintf (stderr, _("%s: %s: Invalid progress type `%s'.\n"),
+ exec_name, com, val);
+ return 0;
+ }
+ FREE_MAYBE (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. */
+ opt.progress_type = xstrdup (val);
+ return 1;
+}
+
static int
cmd_spec_recursive (const char *com, const char *val, void *closure)
{
}
\f
void cleanup_html_url PARAMS ((void));
+void res_cleanup PARAMS ((void));
void downloaded_files_free PARAMS ((void));
+void http_cleanup PARAMS ((void));
/* Free the memory allocated by global variables. */
void
cleanup (void)
{
- extern acc_t *netrc_list;
+ /* Free external resources, close files, etc. */
- recursive_cleanup ();
- clean_hosts ();
- free_netrc (netrc_list);
if (opt.dfp)
fclose (opt.dfp);
+
+ /* We're exiting anyway so there's no real need to call free()
+ hundreds of times. Skipping the frees will make Wget exit
+ faster.
+
+ However, when detecting leaks, it's crucial to free() everything
+ because then you can find the real leaks, i.e. the allocated
+ memory which grows with the size of the program. */
+
+#ifdef DEBUG_MALLOC
+ recursive_cleanup ();
+ res_cleanup ();
+ http_cleanup ();
cleanup_html_url ();
downloaded_files_free ();
cookies_cleanup ();
+ host_cleanup ();
+
+ {
+ extern acc_t *netrc_list;
+ free_netrc (netrc_list);
+ }
FREE_MAYBE (opt.lfilename);
xfree (opt.dir_prefix);
FREE_MAYBE (opt.input_filename);
free_vec (opt.domains);
free_vec (opt.follow_tags);
free_vec (opt.ignore_tags);
+ FREE_MAYBE (opt.progress_type);
xfree (opt.ftp_acc);
FREE_MAYBE (opt.ftp_pass);
FREE_MAYBE (opt.ftp_proxy);
FREE_MAYBE (opt.bind_address);
FREE_MAYBE (opt.cookies_input);
FREE_MAYBE (opt.cookies_output);
+#endif
}
projects / wget / blobdiff