/* See the comment in gethttp() why this is needed. */
int global_download_count;
+/* Total size of downloaded files. Used to enforce quota. */
+LARGE_INT total_downloaded_bytes;
+
\f
static struct {
long chunk_bytes;
}
/* Limit the bandwidth by pausing the download for an amount of time.
- BYTES is the number of bytes received from the network, and DELTA
- is the number of milliseconds it took to receive them. */
+ BYTES is the number of bytes received from the network, and TIMER
+ is the timer that started at the beginning of download. */
static void
-limit_bandwidth (long bytes, double *dltime, struct wget_timer *timer)
+limit_bandwidth (long bytes, struct wget_timer *timer)
{
- double delta_t = *dltime - limit_data.chunk_start;
+ double delta_t = wtimer_read (timer) - limit_data.chunk_start;
double expected;
limit_data.chunk_bytes += bytes;
DEBUGP (("\nsleeping %.2f ms for %ld bytes, adjust %.2f ms\n",
slp, limit_data.chunk_bytes, limit_data.sleep_adjust));
- t0 = *dltime;
- usleep ((unsigned long) (1000 * slp));
- t1 = wtimer_elapsed (timer);
+ t0 = wtimer_read (timer);
+ xsleep (slp / 1000);
+ wtimer_update (timer);
+ t1 = wtimer_read (timer);
/* Due to scheduling, we probably slept slightly longer (or
shorter) than desired. Calculate the difference between the
desired and the actual sleep, and adjust the next sleep by
that amount. */
limit_data.sleep_adjust = slp - (t1 - t0);
-
- /* Since we've called wtimer_elapsed, we might as well update
- the caller's dltime. */
- *dltime = t1;
}
limit_data.chunk_bytes = 0;
- limit_data.chunk_start = *dltime;
+ limit_data.chunk_start = wtimer_read (timer);
}
#define MIN(i, j) ((i) <= (j) ? (i) : (j))
void *progress = NULL;
struct wget_timer *timer = wtimer_allocate ();
- double dltime = 0;
*len = restval;
{
int amount_to_read = (use_expected
? MIN (expected - *len, dlbufsize) : dlbufsize);
-#ifdef HAVE_SSL
- if (rbuf->ssl!=NULL)
- res = ssl_iread (rbuf->ssl, dlbuf, amount_to_read);
- else
-#endif /* HAVE_SSL */
- res = iread (fd, dlbuf, amount_to_read);
+ res = xread (fd, dlbuf, amount_to_read, -1);
if (res <= 0)
break;
/* Always flush the contents of the network packet. This should
not hinder performance: fast downloads will be received in
16K chunks (which stdio would write out anyway), and slow
- downloads won't be limited with disk performance. */
+ downloads won't be limited by disk performance. */
fflush (fp);
if (ferror (fp))
{
goto out;
}
- dltime = wtimer_elapsed (timer);
+ wtimer_update (timer);
if (opt.limit_rate)
- limit_bandwidth (res, &dltime, timer);
+ limit_bandwidth (res, timer);
*len += res;
if (progress)
- progress_update (progress, res, dltime);
+ progress_update (progress, res, wtimer_read (timer));
#ifdef WINDOWS
if (use_expected && expected > 0)
ws_percenttitle (100.0 * (double)(*len) / (double)expected);
out:
if (progress)
- progress_finish (progress, dltime);
+ progress_finish (progress, wtimer_read (timer));
if (elapsed)
- *elapsed = dltime;
+ *elapsed = wtimer_read (timer);
wtimer_delete (timer);
return res;
char *saved_post_data = NULL;
char *saved_post_file_name = NULL;
- /* If dt is NULL, just ignore it. */
+ /* If dt is NULL, use local storage. */
if (!dt)
- dt = &dummy;
+ {
+ dt = &dummy;
+ dummy = 0;
+ }
url = xstrdup (origurl);
if (newloc)
*newloc = NULL;
if (file)
*file = local_file ? local_file : NULL;
else
- FREE_MAYBE (local_file);
+ xfree_null (local_file);
url_free (u);
them. If HTML is non-zero, treat the file as HTML, and construct
the URLs accordingly.
- If opt.recursive is set, call recursive_retrieve() for each file. */
+ If opt.recursive is set, call retrieve_tree() for each file. */
+
uerr_t
retrieve_from_file (const char *file, int html, int *count)
{
if (cur_url->ignore_when_downloading)
continue;
- if (downloaded_exceeds_quota ())
+ if (opt.quota && total_downloaded_bytes > opt.quota)
{
status = QUOTEXC;
break;
}
- if (opt.recursive && cur_url->url->scheme != SCHEME_FTP)
+ if ((opt.recursive || opt.page_requisites)
+ && 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);
dt &= ~RETROKF;
}
- FREE_MAYBE (new_file);
- FREE_MAYBE (filename);
+ xfree_null (new_file);
+ xfree_null (filename);
}
/* Free the linked list of URL-s. */
logputs (LOG_VERBOSE, (n1 == n2) ? _("Giving up.\n\n") : _("Retrying.\n\n"));
}
-/* Increment opt.downloaded by BY_HOW_MUCH. If an overflow occurs,
- set opt.downloaded_overflow to 1. */
-void
-downloaded_increase (unsigned long by_how_much)
-{
- VERY_LONG_TYPE old;
- if (opt.downloaded_overflow)
- return;
- old = opt.downloaded;
- opt.downloaded += by_how_much;
- if (opt.downloaded < old) /* carry flag, where are you when I
- need you? */
- {
- /* Overflow. */
- opt.downloaded_overflow = 1;
- opt.downloaded = ~((VERY_LONG_TYPE)0);
- }
-}
-
-/* Return non-zero if the downloaded amount of bytes exceeds the
- desired quota. If quota is not set or if the amount overflowed, 0
- is returned. */
-int
-downloaded_exceeds_quota (void)
-{
- if (!opt.quota)
- return 0;
- if (opt.downloaded_overflow)
- /* We don't really know. (Wildly) assume not. */
- return 0;
-
- 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.
/* 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);
+ xsleep (count - 1);
else
- usleep (1000000L * opt.waitretry);
+ xsleep (opt.waitretry);
}
else if (opt.wait)
{
/* If random-wait is not specified, or if we are sleeping
between retries of the same download, sleep the fixed
interval. */
- usleep (1000000L * opt.wait);
+ xsleep (opt.wait);
else
{
/* Sleep a random amount of time averaging in opt.wait
double waitsecs = 2 * opt.wait * random_float ();
DEBUGP (("sleep_between_retrievals: avg=%f,sleep=%f\n",
opt.wait, waitsecs));
- usleep (1000000L * waitsecs);
+ xsleep (waitsecs);
}
}
}
struct urlpos *next = l->next;
if (l->url)
url_free (l->url);
- FREE_MAYBE (l->local_name);
+ xfree_null (l->local_name);
xfree (l);
l = next;
}
projects / wget / blobdiff