#include "wget.h"
#include "utils.h"
#include "retr.h"
+#include "progress.h"
#include "url.h"
#include "recur.h"
#include "ftp.h"
/* See the comment in gethttp() why this is needed. */
int global_download_count;
-void logflush PARAMS ((void));
\f
-/* Flags for show_progress(). */
-enum spflags { SP_NONE, SP_INIT, SP_FINISH };
-
-static int show_progress PARAMS ((long, long, enum spflags));
-
#define MIN(i, j) ((i) <= (j) ? (i) : (j))
/* Reads the contents of file descriptor FD, until it is closed, or a
{
int res = 0;
static char c[8192];
+ void *progress = NULL;
*len = restval;
if (opt.verbose)
- show_progress (restval, expected, SP_INIT);
+ progress = progress_create (restval, expected);
+
if (rbuf && RBUF_FD (rbuf) == fd)
{
+ int need_flush = 0;
while ((res = rbuf_flush (rbuf, c, sizeof (c))) != 0)
{
if (fwrite (c, sizeof (char), res, fp) < res)
return -2;
if (opt.verbose)
- {
- if (show_progress (res, expected, SP_NONE))
- fflush (fp);
- }
+ progress_update (progress, res);
*len += res;
+ need_flush = 1;
}
+ if (need_flush)
+ fflush (fp);
+ if (ferror (fp))
+ return -2;
}
/* Read from fd while there is available data.
#endif /* HAVE_SSL */
if (res > 0)
{
- if (fwrite (c, sizeof (char), res, fp) < res)
+ fwrite (c, sizeof (char), res, fp);
+ /* Always flush the contents of the network packet. This
+ should not be adverse to performance, as the network
+ packets typically won't be too tiny anyway. */
+ fflush (fp);
+ if (ferror (fp))
return -2;
if (opt.verbose)
- {
- if (show_progress (res, expected, SP_NONE))
- fflush (fp);
- }
+ progress_update (progress, res);
*len += res;
}
else
if (res < -1)
res = -1;
if (opt.verbose)
- show_progress (0, expected, SP_FINISH);
+ progress_finish (progress);
return res;
}
-
-static void
-print_percentage (long bytes, long expected)
+\f
+/* Return a printed representation of the download rate, as
+ appropriate for the speed. If PAD is non-zero, strings will be
+ padded to the width of 7 characters (xxxx.xx). */
+char *
+retr_rate (long bytes, long msecs, int pad)
{
- int percentage = (int)(100.0 * bytes / expected);
- logprintf (LOG_VERBOSE, "%3d%%", percentage);
-}
-
-/* Show the dotted progress report of file loading. Called with
- length and a flag to tell it whether to reset or not. It keeps the
- offset information in static local variables.
+ static char res[20];
+ static char *rate_names[] = {"B/s", "KB/s", "MB/s", "GB/s" };
+ int units = 0;
- Return value: 1 or 0, designating whether any dots have been drawn.
+ double dlrate = calc_rate (bytes, msecs, &units);
+ sprintf (res, pad ? "%7.2f %s" : "%.2f %s", dlrate, rate_names[units]);
- If the init argument is set, the routine will initialize.
-
- If the res is non-zero, res/line_bytes lines are skipped
- (meaning the appropriate number ok kilobytes), and the number of
- "dots" fitting on the first line are drawn as ','. */
-static int
-show_progress (long res, long expected, enum spflags flags)
-{
- static struct wget_timer *timer;
- static long line_bytes;
- static long offs, initial_skip;
- static int ndot, nrow;
- static long last_timer_value, time_offset;
- int any_output = 0;
-
- if (flags == SP_FINISH)
- {
- int dot = ndot;
- char *tmpstr = (char *)alloca (2 * opt.dots_in_line + 1);
- char *tmpp = tmpstr;
- time_offset = wtimer_elapsed (timer) - last_timer_value;
- for (; dot < opt.dots_in_line; dot++)
- {
- if (!(dot % opt.dot_spacing))
- *tmpp++ = ' ';
- *tmpp++ = ' ';
- }
- *tmpp = '\0';
- logputs (LOG_VERBOSE, tmpstr);
- if (expected)
- print_percentage (nrow * line_bytes + ndot * opt.dot_bytes + offs,
- expected);
- logprintf (LOG_VERBOSE, " @%s",
- rate (ndot * opt.dot_bytes
- + offs - (initial_skip % line_bytes),
- time_offset, 1));
- logputs (LOG_VERBOSE, "\n\n");
- return 0;
- }
-
- /* Temporarily disable flushing. */
- opt.no_flush = 1;
- /* init set means initialization. If res is set, it also means that
- the retrieval is *not* done from the beginning. The part that
- was already retrieved is not shown again. */
- if (flags == SP_INIT)
- {
- /* Generic initialization of static variables. */
- offs = 0L;
- ndot = nrow = 0;
- line_bytes = (long)opt.dots_in_line * opt.dot_bytes;
- if (!timer)
- timer = wtimer_allocate ();
- wtimer_reset (timer);
- last_timer_value = 0;
- time_offset = 0;
- initial_skip = res;
- if (res)
- {
- if (res >= line_bytes)
- {
- nrow = res / line_bytes;
- res %= line_bytes;
- logprintf (LOG_VERBOSE,
- _("\n [ skipping %dK ]"),
- (int) ((nrow * line_bytes) / 1024));
- ndot = 0;
- }
- }
- logprintf (LOG_VERBOSE, "\n%5ldK", nrow * line_bytes / 1024);
- }
- /* Offset gets incremented by current value. */
- offs += res;
- /* While offset is >= opt.dot_bytes, print dots, taking care to
- precede every 50th dot with a status message. */
- for (; offs >= opt.dot_bytes; offs -= opt.dot_bytes)
- {
- if (!(ndot % opt.dot_spacing))
- logputs (LOG_VERBOSE, " ");
- any_output = 1;
- logputs (LOG_VERBOSE, flags == SP_INIT ? "," : ".");
- ++ndot;
- if (ndot == opt.dots_in_line)
- {
- time_offset = wtimer_elapsed (timer) - last_timer_value;
- last_timer_value += time_offset;
-
- ndot = 0;
- ++nrow;
- if (expected)
- print_percentage (nrow * line_bytes, expected);
- logprintf (LOG_VERBOSE, " @%s",
- rate (line_bytes - (initial_skip % line_bytes),
- time_offset, 1));
- initial_skip = 0;
- logprintf (LOG_VERBOSE, "\n%5ldK", nrow * line_bytes / 1024);
- }
- }
- /* Reenable flushing. */
- opt.no_flush = 0;
- if (any_output)
- /* Force flush. */
- logflush ();
- return any_output;
+ return res;
}
-\f
-/* Print out the appropriate download rate. Appropriate means that if
- rate is > 1024 bytes per second, kilobytes are used, and if rate >
- 1024 * 1024 bps, megabytes are used.
- If PAD is non-zero, strings will be padded to the width of 7
- characters (xxxx.xx). */
-char *
-rate (long bytes, long msecs, int pad)
+/* Calculate the download rate and trim it as appropriate for the
+ speed. Appropriate means that if rate is greater than 1K/s,
+ kilobytes are used, and if rate is greater than 1MB/s, megabytes
+ are used.
+
+ UNITS is zero for B/s, one for KB/s, two for MB/s, and three for
+ GB/s. */
+double
+calc_rate (long bytes, long msecs, int *units)
{
- static char res[15];
double dlrate;
+ assert (msecs >= 0);
+ assert (bytes >= 0);
+
if (msecs == 0)
/* If elapsed time is 0, it means we're under the granularity of
the timer. This often happens on systems that use time() for
dlrate = (double)1000 * bytes / msecs;
if (dlrate < 1024.0)
- sprintf (res, pad ? "%7.2f B/s" : "%.2f B/s", dlrate);
+ *units = 0;
else if (dlrate < 1024.0 * 1024.0)
- sprintf (res, pad ? "%7.2f KB/s" : "%.2f KB/s", dlrate / 1024.0);
+ *units = 1, dlrate /= 1024.0;
else if (dlrate < 1024.0 * 1024.0 * 1024.0)
- sprintf (res, pad ? "%7.2f MB/s" : "%.2f MB/s", dlrate / (1024.0 * 1024.0));
+ *units = 2, dlrate /= (1024.0 * 1024.0);
else
/* Maybe someone will need this one day. More realistically, it
will get tickled by buggy timers. */
- sprintf (res, pad ? "%7.2f GB/s" : "%.2f GB/s",
- dlrate / (1024.0 * 1024.0 * 1024.0));
+ *units = 3, dlrate /= (1024.0 * 1024.0 * 1024.0);
- return res;
+ return dlrate;
}
\f
+static int
+register_redirections_mapper (void *key, void *value, void *arg)
+{
+ const char *redirected_from = (const char *)key;
+ const char *redirected_to = (const char *)arg;
+ if (0 != strcmp (redirected_from, redirected_to))
+ register_redirection (redirected_from, redirected_to);
+ return 0;
+}
+
+/* Register the redirections that lead to the successful download of
+ this URL. This is necessary so that the link converter can convert
+ redirected URLs to the local file. */
+
+static void
+register_all_redirections (struct hash_table *redirections, const char *final)
+{
+ hash_table_map (redirections, register_redirections_mapper, (void *)final);
+}
+
#define USE_PROXY_P(u) (opt.use_proxy && getproxy((u)->scheme) \
&& no_proxy_match((u)->host, \
(const char **)opt.no_proxy))
proxy_url = url_parse (proxy, &up_error_code);
if (!proxy_url)
{
- logprintf (LOG_NOTQUIET, "Error parsing proxy URL %s: %s.\n",
+ logprintf (LOG_NOTQUIET, _("Error parsing proxy URL %s: %s.\n"),
proxy, url_error (up_error_code));
if (redirections)
string_set_free (redirections);
char *suf = suffix (u->local);
if (suf && (!strcasecmp (suf, "html") || !strcasecmp (suf, "htm")))
*dt |= TEXTHTML;
- FREE_MAYBE (suf);
}
#endif
}
if (location_changed)
{
char *construced_newloc;
- struct url *newloc_struct;
+ struct url *newloc_parsed;
assert (mynewloc != NULL);
mynewloc = construced_newloc;
/* Now, see if this new location makes sense. */
- newloc_struct = url_parse (mynewloc, NULL);
- if (!newloc_struct)
+ newloc_parsed = url_parse (mynewloc, &up_error_code);
+ if (!newloc_parsed)
{
- logprintf (LOG_NOTQUIET, "%s: %s.\n", mynewloc, "UNKNOWN");
- url_free (newloc_struct);
+ logprintf (LOG_NOTQUIET, "%s: %s.\n", mynewloc,
+ url_error (up_error_code));
url_free (u);
if (redirections)
string_set_free (redirections);
return result;
}
- /* Now mynewloc will become newloc_struct->url, because if the
+ /* Now mynewloc will become newloc_parsed->url, because if the
Location contained relative paths like .././something, we
don't want that propagating as url. */
xfree (mynewloc);
- mynewloc = xstrdup (newloc_struct->url);
+ mynewloc = xstrdup (newloc_parsed->url);
if (!redirections)
{
/* The new location is OK. Check for redirection cycle by
peeking through the history of redirections. */
- if (string_set_contains (redirections, newloc_struct->url))
+ if (string_set_contains (redirections, newloc_parsed->url))
{
logprintf (LOG_NOTQUIET, _("%s: Redirection cycle detected.\n"),
mynewloc);
- url_free (newloc_struct);
+ url_free (newloc_parsed);
url_free (u);
if (redirections)
string_set_free (redirections);
xfree (mynewloc);
return WRONGCODE;
}
- string_set_add (redirections, newloc_struct->url);
+ string_set_add (redirections, newloc_parsed->url);
xfree (url);
url = mynewloc;
url_free (u);
- u = newloc_struct;
+ u = newloc_parsed;
goto redirected;
}
if (*dt & RETROKF)
{
register_download (url, local_file);
+ if (redirections)
+ register_all_redirections (redirections, url);
if (*dt & TEXTHTML)
register_html (url, local_file);
}
retrieve_from_file (const char *file, int html, int *count)
{
uerr_t status;
- urlpos *url_list, *cur_url;
+ struct urlpos *url_list, *cur_url;
url_list = (html ? get_urls_html (file, NULL, FALSE, NULL)
: get_urls_file (file));
status = RETROK; /* Suppose everything is OK. */
*count = 0; /* Reset the URL count. */
- recursive_reset ();
+
for (cur_url = url_list; cur_url; cur_url = cur_url->next, ++*count)
{
- char *filename, *new_file;
+ char *filename = NULL, *new_file;
int dt;
+ if (cur_url->ignore_when_downloading)
+ continue;
+
if (downloaded_exceeds_quota ())
{
status = QUOTEXC;
break;
}
- status = retrieve_url (cur_url->url, &filename, &new_file, NULL, &dt);
- if (opt.recursive && status == RETROK && (dt & TEXTHTML))
- status = recursive_retrieve (filename, new_file ? new_file
- : cur_url->url);
+ if (opt.recursive && cur_url->url->scheme != SCHEME_FTP)
+ status = retrieve_tree (cur_url->url->url);
+ else
+ status = retrieve_url (cur_url->url->url, &filename, &new_file, NULL, &dt);
if (filename && opt.delete_after && file_exists_p (filename))
{
sleep (opt.waitretry);
}
else if (opt.wait)
- /* Otherwise, check if opt.wait is specified. If so, sleep. */
- sleep (opt.wait);
+ {
+ /* Otherwise, check if opt.wait is specified. If so, sleep. */
+ if (count > 1 || !opt.random_wait)
+ sleep (opt.wait);
+ else
+ {
+ int waitsecs = random() % (opt.wait * 2 + 1);
+ DEBUGP(("sleep_between_retrievals: norm=%ld,random=%ld,sleep=%d\n",
+ opt.wait, waitsecs - opt.wait, waitsecs));
+ sleep(waitsecs);
+ }
+ }
}
if (first_retrieval)
first_retrieval = 0;
projects / wget / blobdiff