X-Git-Url: http://sjero.net/git/?a=blobdiff_plain;f=src%2Fretr.c;h=5d9795ad67ac7177163f96d1dff28f2eaa6bb9c7;hb=d9fea91a0a319e348adb504bd3edff148ff3d8a0;hp=4328aad661f024f3321db1d7af6a8fa860150029;hpb=d54b2a086d4b2a8dcd61727d3e37a7241ce22d1b;p=wget diff --git a/src/retr.c b/src/retr.c index 4328aad6..5d9795ad 100644 --- a/src/retr.c +++ b/src/retr.c @@ -53,6 +53,7 @@ so, delete this exception statement from your version. */ #include "host.h" #include "connect.h" #include "hash.h" +#include "convert.h" #ifdef HAVE_SSL # include "gen_sslfunc.h" /* for ssl_iread */ @@ -65,58 +66,74 @@ extern int errno; /* 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; + static struct { - long bytes; - double dltime; + long chunk_bytes; + double chunk_start; + double sleep_adjust; } limit_data; static void limit_bandwidth_reset (void) { - limit_data.bytes = 0; - limit_data.dltime = 0; + limit_data.chunk_bytes = 0; + limit_data.chunk_start = 0; } /* Limit the bandwidth by pausing the download for an amount of time. - BYTES is the number of bytes received from the network, DELTA is - how long it took to receive them, DLTIME the current download time, - TIMER the timer, and ADJUSTMENT the previous. */ + 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 delta) +limit_bandwidth (long bytes, struct wget_timer *timer) { + double delta_t = wtimer_read (timer) - limit_data.chunk_start; double expected; - limit_data.bytes += bytes; - limit_data.dltime += delta; + limit_data.chunk_bytes += bytes; - expected = 1000.0 * limit_data.bytes / opt.limit_rate; + /* Calculate the amount of time we expect downloading the chunk + should take. If in reality it took less time, sleep to + compensate for the difference. */ + expected = 1000.0 * limit_data.chunk_bytes / opt.limit_rate; - if (expected > limit_data.dltime) + if (expected > delta_t) { - double slp = expected - limit_data.dltime; + double slp = expected - delta_t + limit_data.sleep_adjust; + double t0, t1; if (slp < 200) { DEBUGP (("deferring a %.2f ms sleep (%ld/%.2f).\n", - slp, limit_data.bytes, limit_data.dltime)); + slp, limit_data.chunk_bytes, delta_t)); return; } - DEBUGP (("sleeping %.2f ms\n", slp)); - usleep ((unsigned long) (1000 * slp)); + DEBUGP (("\nsleeping %.2f ms for %ld bytes, adjust %.2f ms\n", + slp, limit_data.chunk_bytes, limit_data.sleep_adjust)); + + 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); } - limit_data.bytes = 0; - limit_data.dltime = 0; + limit_data.chunk_bytes = 0; + limit_data.chunk_start = wtimer_read (timer); } #define MIN(i, j) ((i) <= (j) ? (i) : (j)) /* Reads the contents of file descriptor FD, until it is closed, or a read error occurs. The data is read in 8K chunks, and stored to - stream fp, which should have been open for writing. If BUF is - non-NULL and its file descriptor is equal to FD, flush RBUF first. - This function will *not* use the rbuf_* functions! + stream fp, which should have been open for writing. The EXPECTED argument is passed to show_progress() unchanged, but otherwise ignored. @@ -128,55 +145,46 @@ limit_bandwidth (long bytes, double delta) The function exits and returns codes of 0, -1 and -2 if the connection was closed, there was a read error, or if it could not - write to the output stream, respectively. + write to the output stream, respectively. */ - IMPORTANT: The function flushes the contents of the buffer in - rbuf_flush() before actually reading from fd. If you wish to read - from fd immediately, flush or discard the buffer. */ int -get_contents (int fd, FILE *fp, long *len, long restval, long expected, - struct rbuf *rbuf, int use_expected, double *elapsed) +fd_read_body (int fd, FILE *out, long *len, long restval, long expected, + int use_expected, double *elapsed) { int res = 0; static char dlbuf[16384]; int dlbufsize = sizeof (dlbuf); - void *progress = NULL; struct wget_timer *timer = wtimer_allocate (); - double dltime = 0, last_dltime = 0; + double last_successful_read_tm; + + /* The progress gauge, set according to the user preferences. */ + void *progress = NULL; + + /* Non-zero if the progress gauge is interactive, i.e. if it can + continually update the display. When true, smaller timeout + values are used so that the gauge can update the display when + data arrives slowly. */ + int progress_interactive = 0; *len = restval; if (opt.verbose) - progress = progress_create (restval, expected); - - if (rbuf && RBUF_FD (rbuf) == fd) { - int sz = 0; - while ((res = rbuf_flush (rbuf, dlbuf, sizeof (dlbuf))) != 0) - { - fwrite (dlbuf, 1, res, fp); - *len += res; - sz += res; - } - if (sz) - fflush (fp); - if (ferror (fp)) - { - res = -2; - goto out; - } - if (progress) - progress_update (progress, sz, 0); + progress = progress_create (restval, expected); + progress_interactive = progress_interactive_p (progress); } if (opt.limit_rate) limit_bandwidth_reset (); wtimer_reset (timer); + last_successful_read_tm = 0; - /* If we're limiting the download, set our buffer size to the - limit. */ + /* Use a smaller buffer for low requested bandwidths. For example, + with --limit-rate=2k, it doesn't make sense to slurp in 16K of + data and then sleep for 8s. With buffer size equal to the limit, + we never have to sleep for more than one second. */ if (opt.limit_rate && opt.limit_rate < dlbufsize) dlbufsize = opt.limit_rate; @@ -189,56 +197,227 @@ get_contents (int fd, FILE *fp, long *len, long restval, long expected, { int amount_to_read = (use_expected ? MIN (expected - *len, dlbufsize) : dlbufsize); -#ifdef HAVE_SSL - if (rbuf->ssl!=NULL) - res = ssl_iread (rbuf->ssl, dlbufsize, amount_to_read); - else -#endif /* HAVE_SSL */ - res = iread (fd, dlbuf, amount_to_read); + double tmout = opt.read_timeout; + if (progress_interactive) + { + double waittm; + /* For interactive progress gauges, always specify a ~1s + timeout, so that the gauge can be updated regularly even + when the data arrives very slowly or stalls. */ + tmout = 0.95; + waittm = (wtimer_read (timer) - last_successful_read_tm) / 1000; + if (waittm + tmout > opt.read_timeout) + { + /* Don't allow waiting time to exceed read timeout. */ + tmout = opt.read_timeout - waittm; + if (tmout < 0) + { + /* We've already exceeded the timeout. */ + res = -1, errno = ETIMEDOUT; + break; + } + } + } + res = fd_read (fd, dlbuf, amount_to_read, tmout); + if (res == 0 || (res < 0 && errno != ETIMEDOUT)) + break; + else if (res < 0) + res = 0; /* timeout */ + + wtimer_update (timer); if (res > 0) { - fwrite (dlbuf, 1, res, fp); + fwrite (dlbuf, 1, res, out); /* 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)) + 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 by disk + performance. */ + fflush (out); + if (ferror (out)) { res = -2; goto out; } + last_successful_read_tm = wtimer_read (timer); + } - /* If bandwidth is not limited, one call to wtimer_elapsed - is sufficient. */ - dltime = wtimer_elapsed (timer); - if (opt.limit_rate) - { - limit_bandwidth (res, dltime - last_dltime); - dltime = wtimer_elapsed (timer); - last_dltime = dltime; - } + if (opt.limit_rate) + limit_bandwidth (res, timer); - if (progress) - progress_update (progress, res, dltime); - *len += res; - } - else - break; + *len += res; + if (progress) + progress_update (progress, res, wtimer_read (timer)); +#ifdef WINDOWS + if (use_expected && expected > 0) + ws_percenttitle (100.0 * (double)(*len) / (double)expected); +#endif } if (res < -1) res = -1; 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; } +typedef const char *(*finder_t) PARAMS ((const char *, int, int)); + +/* Driver for fd_read_line and fd_read_head: keeps reading data until + a terminator (as decided by FINDER) occurs in the data. The trick + is that the data is first peeked at, and only then actually read. + That way the data after the terminator is never read. */ + +static char * +fd_read_until (int fd, finder_t finder, int bufsize) +{ + int size = bufsize, tail = 0; + char *buf = xmalloc (size); + + while (1) + { + const char *end; + int pklen, rdlen, remain; + + /* First, peek at the available data. */ + + pklen = fd_peek (fd, buf + tail, size - tail, -1); + if (pklen < 0) + { + xfree (buf); + return NULL; + } + end = finder (buf, tail, pklen); + if (end) + { + /* The data contains the terminator: we'll read the data up + to the end of the terminator. */ + remain = end - (buf + tail); + /* Note +1 for trailing \0. */ + if (size < tail + remain + 1) + { + size = tail + remain + 1; + buf = xrealloc (buf, size); + } + } + else + /* No terminator: simply read the data we know is (or should + be) available. */ + remain = pklen; + + /* Now, read the data. Note that we make no assumptions about + how much data we'll get. (Some TCP stacks are notorious for + read returning less data than the previous MSG_PEEK.) */ + + rdlen = fd_read (fd, buf + tail, remain, 0); + if (rdlen < 0) + { + xfree_null (buf); + return NULL; + } + if (rdlen == 0) + { + if (tail == 0) + { + /* EOF without anything having been read */ + xfree (buf); + errno = 0; + return NULL; + } + /* Return what we received so far. */ + if (size < tail + 1) + { + size = tail + 1; /* expand the buffer to receive the + terminating \0 */ + buf = xrealloc (buf, size); + } + buf[tail] = '\0'; + return buf; + } + tail += rdlen; + if (end && rdlen == remain) + { + /* The end was seen and the data read -- we got what we came + for. */ + buf[tail] = '\0'; + return buf; + } + + /* Keep looping until all the data arrives. */ + + if (tail == size) + { + size <<= 1; + buf = xrealloc (buf, size); + } + } +} + +static const char * +line_terminator (const char *buf, int tail, int peeklen) +{ + const char *p = memchr (buf + tail, '\n', peeklen); + if (p) + /* p+1 because we want the line to include '\n' */ + return p + 1; + return NULL; +} + +/* Read one line from FD and return it. The line is allocated using + malloc. + + If an error occurs, or if no data can be read, NULL is returned. + In the former case errno indicates the error condition, and in the + latter case, errno is NULL. */ + +char * +fd_read_line (int fd) +{ + return fd_read_until (fd, line_terminator, 128); +} + +static const char * +head_terminator (const char *buf, int tail, int peeklen) +{ + const char *start, *end; + if (tail < 4) + start = buf; + else + start = buf + tail - 4; + end = buf + tail + peeklen; + + for (; start < end - 1; start++) + if (*start == '\n') + { + if (start < end - 2 + && start[1] == '\r' + && start[2] == '\n') + return start + 3; + if (start[1] == '\n') + return start + 2; + } + return NULL; +} + +/* Read the request head from FD and return it. The chunk of data is + allocated using malloc. + + If an error occurs, or if no data can be read, NULL is returned. + In the former case errno indicates the error condition, and in the + latter case, errno is NULL. */ + +char * +fd_read_head (int fd) +{ + return fd_read_until (fd, head_terminator, 512); +} + /* 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). */ @@ -284,8 +463,7 @@ calc_rate (long bytes, double msecs, int *units) else if (dlrate < 1024.0 * 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. */ + /* Maybe someone will need this, one day. */ *units = 3, dlrate /= (1024.0 * 1024.0 * 1024.0); return dlrate; @@ -315,6 +493,8 @@ calc_rate (long bytes, double msecs, int *units) } \ } while (0) +static char *getproxy PARAMS ((struct url *)); + /* Retrieve the given URL. Decides which loop to call -- HTTP, FTP, FTP, proxy, etc. */ @@ -338,9 +518,12 @@ retrieve_url (const char *origurl, char **file, char **newloc, 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; @@ -506,7 +689,7 @@ retrieve_url (const char *origurl, char **file, char **newloc, if (file) *file = local_file ? local_file : NULL; else - FREE_MAYBE (local_file); + xfree_null (local_file); url_free (u); @@ -534,7 +717,8 @@ retrieve_url (const char *origurl, char **file, char **newloc, 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) { @@ -554,12 +738,13 @@ 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); @@ -574,8 +759,8 @@ retrieve_from_file (const char *file, int html, int *count) dt &= ~RETROKF; } - FREE_MAYBE (new_file); - FREE_MAYBE (filename); + xfree_null (new_file); + xfree_null (filename); } /* Free the linked list of URL-s. */ @@ -592,40 +777,6 @@ printwhat (int n1, int n2) 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. @@ -649,9 +800,9 @@ sleep_between_retrievals (int count) /* 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 - sleep (opt.waitretry); + xsleep (opt.waitretry); } else if (opt.wait) { @@ -659,19 +810,114 @@ sleep_between_retrievals (int count) /* If random-wait is not specified, or if we are sleeping between retries of the same download, sleep the fixed interval. */ - sleep (opt.wait); + xsleep (opt.wait); else { /* Sleep a random amount of time averaging in opt.wait seconds. The sleeping amount ranges from 0 to opt.wait*2, inclusive. */ - int waitsecs = random_number (opt.wait * 2 + 1); + double waitsecs = 2 * opt.wait * random_float (); + DEBUGP (("sleep_between_retrievals: avg=%f,sleep=%f\n", + opt.wait, waitsecs)); + xsleep (waitsecs); + } + } +} - DEBUGP (("sleep_between_retrievals: norm=%ld,fuzz=%ld,sleep=%d\n", - opt.wait, waitsecs - opt.wait, waitsecs)); +/* Free the linked list of urlpos. */ +void +free_urlpos (struct urlpos *l) +{ + while (l) + { + struct urlpos *next = l->next; + if (l->url) + url_free (l->url); + xfree_null (l->local_name); + xfree (l); + l = next; + } +} - if (waitsecs) - sleep (waitsecs); - } +/* Rotate FNAME opt.backups times */ +void +rotate_backups(const char *fname) +{ + int maxlen = strlen (fname) + 1 + numdigit (opt.backups) + 1; + char *from = (char *)alloca (maxlen); + char *to = (char *)alloca (maxlen); + struct stat sb; + int i; + + if (stat (fname, &sb) == 0) + if (S_ISREG (sb.st_mode) == 0) + return; + + for (i = opt.backups; i > 1; i--) + { + sprintf (from, "%s.%d", fname, i - 1); + sprintf (to, "%s.%d", fname, i); + rename (from, to); + } + + sprintf (to, "%s.%d", fname, 1); + rename(fname, to); +} + +static int no_proxy_match PARAMS ((const char *, const char **)); + +/* Return the URL of the proxy appropriate for url U. */ + +static char * +getproxy (struct url *u) +{ + char *proxy = NULL; + char *rewritten_url; + static char rewritten_storage[1024]; + + if (!opt.use_proxy) + return NULL; + if (!no_proxy_match (u->host, (const char **)opt.no_proxy)) + return NULL; + + switch (u->scheme) + { + case SCHEME_HTTP: + proxy = opt.http_proxy ? opt.http_proxy : getenv ("http_proxy"); + break; +#ifdef HAVE_SSL + case SCHEME_HTTPS: + proxy = opt.https_proxy ? opt.https_proxy : getenv ("https_proxy"); + break; +#endif + case SCHEME_FTP: + proxy = opt.ftp_proxy ? opt.ftp_proxy : getenv ("ftp_proxy"); + break; + case SCHEME_INVALID: + break; + } + if (!proxy || !*proxy) + return NULL; + + /* Handle shorthands. `rewritten_storage' is a kludge to allow + getproxy() to return static storage. */ + rewritten_url = rewrite_shorthand_url (proxy); + if (rewritten_url) + { + strncpy (rewritten_storage, rewritten_url, sizeof(rewritten_storage)); + rewritten_storage[sizeof (rewritten_storage) - 1] = '\0'; + proxy = rewritten_storage; } + + return proxy; +} + +/* Should a host be accessed through proxy, concerning no_proxy? */ +int +no_proxy_match (const char *host, const char **no_proxy) +{ + if (!no_proxy) + return 1; + else + return !sufmatch (no_proxy, host); }