/* File retrieval.
- 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.
#else
# include <strings.h>
#endif /* HAVE_STRING_H */
-#include <ctype.h>
#include <assert.h>
#include "wget.h"
#include "connect.h"
#include "hash.h"
+#ifndef errno
+extern int errno;
+#endif
+
#ifdef WINDOWS
LARGE_INTEGER internal_time;
#else
static long internal_secs, internal_msecs;
#endif
+/* See the comment in gethttp() why this is needed. */
+int global_download_count;
+
void logflush PARAMS ((void));
/* From http.c. */
print_percentage (long bytes, long expected)
{
int percentage = (int)(100.0 * bytes / expected);
- logprintf (LOG_VERBOSE, " [%3d%%]", percentage);
+ logprintf (LOG_VERBOSE, "%3d%%", percentage);
}
/* Show the dotted progress report of file loading. Called with
show_progress (long res, long expected, enum spflags flags)
{
static long line_bytes;
- static long offs;
+ static long offs, initial_skip;
static int ndot, nrow;
+ static long last_timer, 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 = elapsed_time () - last_timer;
for (; dot < opt.dots_in_line; dot++)
{
if (!(dot % opt.dot_spacing))
logputs (LOG_VERBOSE, tmpstr);
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;
offs = 0L;
ndot = nrow = 0;
line_bytes = (long)opt.dots_in_line * opt.dot_bytes;
+ last_timer = elapsed_time ();
+ time_offset = 0;
+ initial_skip = res;
if (res)
{
if (res >= line_bytes)
ndot = 0;
}
}
- logprintf (LOG_VERBOSE, "\n%5ldK ->", nrow * line_bytes / 1024);
+ logprintf (LOG_VERBOSE, "\n%5ldK", nrow * line_bytes / 1024);
}
/* Offset gets incremented by current value. */
offs += res;
++ndot;
if (ndot == opt.dots_in_line)
{
+ time_offset = elapsed_time () - last_timer;
+ last_timer += time_offset;
+
ndot = 0;
++nrow;
if (expected)
- print_percentage (nrow * line_bytes, expected);
- logprintf (LOG_VERBOSE, "\n%5ldK ->", nrow * line_bytes / 1024);
+ {
+ 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. */
/* 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. */
+ 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)
+rate (long bytes, long msecs, int pad)
{
static char res[15];
double dlrate;
if (!msecs)
++msecs;
dlrate = (double)1000 * bytes / msecs;
- /* #### Should these strings be translatable? */
if (dlrate < 1024.0)
- sprintf (res, "%.2f B/s", dlrate);
+ sprintf (res, pad ? "%7.2f B/s" : "%.2f B/s", dlrate);
else if (dlrate < 1024.0 * 1024.0)
- sprintf (res, "%.2f KB/s", dlrate / 1024.0);
+ sprintf (res, pad ? "%7.2f KB/s" : "%.2f KB/s", dlrate / 1024.0);
else
- sprintf (res, "%.2f MB/s", dlrate / (1024.0 * 1024.0));
+ sprintf (res, pad ? "%7.2f MB/s" : "%.2f MB/s", dlrate / (1024.0 * 1024.0));
return res;
}
\f
assert (u->proto != URLFILE); /* #### Implement me! */
mynewloc = NULL;
+ if (u->proto == URLHTTP
#ifdef HAVE_SSL
- if (u->proto == URLHTTP || u->proto == URLHTTPS )
-#else
- if (u->proto == URLHTTP)
-#endif /* HAVE_SSL */
+ || u->proto == URLHTTPS
+#endif
+ )
result = http_loop (u, &mynewloc, dt);
else if (u->proto == URLFTP)
{
redirects, but a ton of boneheaded webservers and CGIs out
there break the rules and use relative URLs, and popular
browsers are lenient about this, so wget should be too. */
- construced_newloc = url_concat (url, mynewloc);
+ construced_newloc = uri_merge (url, mynewloc);
xfree (mynewloc);
mynewloc = construced_newloc;
goto redirected;
}
+ if (u->local)
+ {
+ if (*dt & RETROKF)
+ {
+ register_download (url, u->local);
+ if (*dt & TEXTHTML)
+ register_html (url, u->local);
+ }
+ }
+
if (file)
{
if (u->local)
else
xfree (url);
+ ++global_download_count;
+
return result;
}
return opt.downloaded > opt.quota;
}
+
+/* If opt.wait or opt.waitretry are specified, and if certain
+ conditions are met, sleep the appropriate number of seconds. See
+ the documentation of --wait and --waitretry for more information.
+
+ COUNT is the count of current retrieval, beginning with 1. */
+
+void
+sleep_between_retrievals (int count)
+{
+ static int first_retrieval = 1;
+
+ if (!first_retrieval && (opt.wait || opt.waitretry))
+ {
+ if (opt.waitretry && count > 1)
+ {
+ /* If opt.waitretry is specified and this is a retry, wait
+ for COUNT-1 number of seconds, or for opt.waitretry
+ seconds. */
+ if (count <= opt.waitretry)
+ sleep (count - 1);
+ else
+ sleep (opt.waitretry);
+ }
+ else if (opt.wait)
+ /* Otherwise, check if opt.wait is specified. If so, sleep. */
+ sleep (opt.wait);
+ }
+ if (first_retrieval)
+ first_retrieval = 0;
+}