X-Git-Url: http://sjero.net/git/?p=wget;a=blobdiff_plain;f=src%2Fretr.c;h=a5198b7e591171792bf8b11360003d01c8dc4fed;hp=5d9795ad67ac7177163f96d1dff28f2eaa6bb9c7;hb=2219d47ba301c3ea47b36291dda8eabead0fc75d;hpb=d9fea91a0a319e348adb504bd3edff148ff3d8a0 diff --git a/src/retr.c b/src/retr.c index 5d9795ad..a5198b7e 100644 --- a/src/retr.c +++ b/src/retr.c @@ -54,6 +54,7 @@ so, delete this exception statement from your version. */ #include "connect.h" #include "hash.h" #include "convert.h" +#include "ptimer.h" #ifdef HAVE_SSL # include "gen_sslfunc.h" /* for ssl_iread */ @@ -63,15 +64,19 @@ so, delete this exception statement from your version. */ extern int errno; #endif -/* 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; +/* If non-NULL, the stream to which output should be written. This + stream is initialized when `-O' is used. */ +FILE *output_stream; + +/* Whether output_document is a regular file we can manipulate, + i.e. not `-' or a device file. */ +int output_stream_regular; static struct { - long chunk_bytes; + wgint chunk_bytes; double chunk_start; double sleep_adjust; } limit_data; @@ -88,9 +93,9 @@ limit_bandwidth_reset (void) is the timer that started at the beginning of download. */ static void -limit_bandwidth (long bytes, struct wget_timer *timer) +limit_bandwidth (wgint bytes, struct ptimer *timer) { - double delta_t = wtimer_read (timer) - limit_data.chunk_start; + double delta_t = ptimer_read (timer) - limit_data.chunk_start; double expected; limit_data.chunk_bytes += bytes; @@ -106,17 +111,18 @@ limit_bandwidth (long bytes, struct wget_timer *timer) double t0, t1; if (slp < 200) { - DEBUGP (("deferring a %.2f ms sleep (%ld/%.2f).\n", - slp, limit_data.chunk_bytes, delta_t)); + DEBUGP (("deferring a %.2f ms sleep (%s/%.2f).\n", + slp, number_to_static_string (limit_data.chunk_bytes), + delta_t)); return; } - DEBUGP (("\nsleeping %.2f ms for %ld bytes, adjust %.2f ms\n", - slp, limit_data.chunk_bytes, limit_data.sleep_adjust)); + DEBUGP (("\nsleeping %.2f ms for %s bytes, adjust %.2f ms\n", + slp, number_to_static_string (limit_data.chunk_bytes), + limit_data.sleep_adjust)); - t0 = wtimer_read (timer); + t0 = ptimer_read (timer); xsleep (slp / 1000); - wtimer_update (timer); - t1 = wtimer_read (timer); + t1 = ptimer_measure (timer); /* Due to scheduling, we probably slept slightly longer (or shorter) than desired. Calculate the difference between the @@ -126,38 +132,78 @@ limit_bandwidth (long bytes, struct wget_timer *timer) } limit_data.chunk_bytes = 0; - limit_data.chunk_start = wtimer_read (timer); + limit_data.chunk_start = ptimer_read (timer); } -#define MIN(i, j) ((i) <= (j) ? (i) : (j)) +#ifndef MIN +# define MIN(i, j) ((i) <= (j) ? (i) : (j)) +#endif -/* 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. +/* Write data in BUF to OUT. However, if *SKIP is non-zero, skip that + amount of data and decrease SKIP. Increment *TOTAL by the amount + of data written. */ - The EXPECTED argument is passed to show_progress() unchanged, but - otherwise ignored. +static int +write_data (FILE *out, const char *buf, int bufsize, wgint *skip, + wgint *written) +{ + if (!out) + return 1; + if (*skip > bufsize) + { + *skip -= bufsize; + return 1; + } + if (*skip) + { + buf += *skip; + bufsize -= *skip; + *skip = 0; + if (bufsize == 0) + return 1; + } - If opt.verbose is set, the progress is also shown. RESTVAL - represents a value from which to start downloading (which will be - shown accordingly). If RESTVAL is non-zero, the stream should have - been open for appending. + fwrite (buf, 1, bufsize, out); + *written += bufsize; - 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. */ + /* Immediately flush the downloaded data. This should not hinder + performance: fast downloads will arrive in large 16K chunks + (which stdio would write out immediately anyway), and slow + downloads wouldn't be limited by disk speed. */ + fflush (out); + return !ferror (out); +} + +/* Read the contents of file descriptor FD until it the connection + terminates or a read error occurs. The data is read in portions of + up to 16K and written to OUT as it arrives. If opt.verbose is set, + the progress is shown. + + TOREAD is the amount of data expected to arrive, normally only used + by the progress gauge. + + STARTPOS is the position from which the download starts, used by + the progress gauge. If QTYREAD is non-NULL, the value it points to + is incremented by the amount of data read from the network. If + QTYWRITTEN is non-NULL, the value it points to is incremented by + the amount of data written to disk. The time it took to download + the data (in milliseconds) is stored to ELAPSED. + + The function exits and returns the amount of data read. In case of + error while reading data, -1 is returned. In case of error while + writing data, -2 is returned. */ int -fd_read_body (int fd, FILE *out, long *len, long restval, long expected, - int use_expected, double *elapsed) +fd_read_body (int fd, FILE *out, wgint toread, wgint startpos, + wgint *qtyread, wgint *qtywritten, double *elapsed, int flags) { - int res = 0; + int ret = 0; static char dlbuf[16384]; int dlbufsize = sizeof (dlbuf); - struct wget_timer *timer = wtimer_allocate (); - double last_successful_read_tm; + struct ptimer *timer = NULL; + double last_successful_read_tm = 0; /* The progress gauge, set according to the user preferences. */ void *progress = NULL; @@ -168,18 +214,36 @@ fd_read_body (int fd, FILE *out, long *len, long restval, long expected, data arrives slowly. */ int progress_interactive = 0; - *len = restval; + int exact = flags & rb_read_exactly; + wgint skip = 0; + + /* How much data we've read/written. */ + wgint sum_read = 0; + wgint sum_written = 0; + + if (flags & rb_skip_startpos) + skip = startpos; if (opt.verbose) { - progress = progress_create (restval, expected); + /* If we're skipping STARTPOS bytes, pass 0 as the INITIAL + argument to progress_create because the indicator doesn't + (yet) know about "skipping" data. */ + progress = progress_create (skip ? 0 : startpos, startpos + toread); progress_interactive = progress_interactive_p (progress); } if (opt.limit_rate) limit_bandwidth_reset (); - wtimer_reset (timer); - last_successful_read_tm = 0; + + /* A timer is needed for tracking progress, for throttling, and for + tracking elapsed time. If either of these are requested, start + the timer. */ + if (progress || opt.limit_rate || elapsed) + { + timer = ptimer_new (); + last_successful_read_tm = 0; + } /* Use a smaller buffer for low requested bandwidths. For example, with --limit-rate=2k, it doesn't make sense to slurp in 16K of @@ -188,97 +252,138 @@ fd_read_body (int fd, FILE *out, long *len, long restval, long expected, if (opt.limit_rate && opt.limit_rate < dlbufsize) dlbufsize = opt.limit_rate; - /* Read from fd while there is available data. - - Normally, if expected is 0, it means that it is not known how - much data is expected. However, if use_expected is specified, - then expected being zero means exactly that. */ - while (!use_expected || (*len < expected)) + /* Read from FD while there is data to read. Normally toread==0 + means that it is unknown how much data is to arrive. However, if + EXACT is set, then toread==0 means what it says: that no data + should be read. */ + while (!exact || (sum_read < toread)) { - int amount_to_read = (use_expected - ? MIN (expected - *len, dlbufsize) : dlbufsize); + int rdsize = exact ? MIN (toread - sum_read, dlbufsize) : dlbufsize; 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) + if (opt.read_timeout) { - /* Don't allow waiting time to exceed read timeout. */ - tmout = opt.read_timeout - waittm; - if (tmout < 0) + double waittm; + waittm = (ptimer_read (timer) - last_successful_read_tm) / 1000; + if (waittm + tmout > opt.read_timeout) { - /* We've already exceeded the timeout. */ - res = -1, errno = ETIMEDOUT; - break; + /* Don't let total idle time exceed read timeout. */ + tmout = opt.read_timeout - waittm; + if (tmout < 0) + { + /* We've already exceeded the timeout. */ + ret = -1, errno = ETIMEDOUT; + break; + } } } } - res = fd_read (fd, dlbuf, amount_to_read, tmout); + ret = fd_read (fd, dlbuf, rdsize, tmout); + + if (ret == 0 || (ret < 0 && errno != ETIMEDOUT)) + break; /* read error */ + else if (ret < 0) + ret = 0; /* read timeout */ - if (res == 0 || (res < 0 && errno != ETIMEDOUT)) - break; - else if (res < 0) - res = 0; /* timeout */ + if (progress || opt.limit_rate) + { + ptimer_measure (timer); + if (ret > 0) + last_successful_read_tm = ptimer_read (timer); + } - wtimer_update (timer); - if (res > 0) + if (ret > 0) { - fwrite (dlbuf, 1, res, out); - /* 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 by disk - performance. */ - fflush (out); - if (ferror (out)) + sum_read += ret; + if (!write_data (out, dlbuf, ret, &skip, &sum_written)) { - res = -2; + ret = -2; goto out; } - last_successful_read_tm = wtimer_read (timer); } if (opt.limit_rate) - limit_bandwidth (res, timer); + limit_bandwidth (ret, timer); - *len += res; if (progress) - progress_update (progress, res, wtimer_read (timer)); + progress_update (progress, ret, ptimer_read (timer)); #ifdef WINDOWS - if (use_expected && expected > 0) - ws_percenttitle (100.0 * (double)(*len) / (double)expected); + if (toread > 0 && !opt.quiet) + ws_percenttitle (100.0 * + (startpos + sum_read) / (startpos + toread)); #endif } - if (res < -1) - res = -1; + if (ret < -1) + ret = -1; out: if (progress) - progress_finish (progress, wtimer_read (timer)); + progress_finish (progress, ptimer_read (timer)); + if (elapsed) - *elapsed = wtimer_read (timer); - wtimer_delete (timer); + *elapsed = ptimer_read (timer); + if (timer) + ptimer_destroy (timer); - return res; + if (qtyread) + *qtyread += sum_read; + if (qtywritten) + *qtywritten += sum_written; + + return ret; } -typedef const char *(*finder_t) PARAMS ((const char *, int, int)); +/* Read a hunk of data from FD, up until a terminator. The terminator + is whatever the TERMINATOR function determines it to be; for + example, it can be a line of data, or the head of an HTTP response. + The function returns the data read allocated with malloc. -/* 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. */ + In case of error, NULL is returned. In case of EOF and no data + read, NULL is returned and errno set to 0. In case of EOF with + data having been read, the data is returned, but it will + (obviously) not contain the terminator. -static char * -fd_read_until (int fd, finder_t finder, int bufsize) + The idea is to be able to read a line of input, or otherwise a hunk + of text, such as the head of an HTTP request, without crossing the + boundary, so that the next call to fd_read etc. reads the data + after the hunk. To achieve that, this function does the following: + + 1. Peek at available data. + + 2. Determine whether the peeked data, along with the previously + read data, includes the terminator. + + 2a. If yes, read the data until the end of the terminator, and + exit. + + 2b. If no, read the peeked data and goto 1. + + The function is careful to assume as little as possible about the + implementation of peeking. For example, every peek is followed by + a read. If the read returns a different amount of data, the + process is retried until all data arrives safely. + + SIZEHINT is the buffer size sufficient to hold all the data in the + typical case (it is used as the initial buffer size). MAXSIZE is + the maximum amount of memory this function is allowed to allocate, + or 0 if no upper limit is to be enforced. + + This function should be used as a building block for other + functions -- see fd_read_line as a simple example. */ + +char * +fd_read_hunk (int fd, hunk_terminator_t terminator, long sizehint, long maxsize) { - int size = bufsize, tail = 0; - char *buf = xmalloc (size); + long bufsize = sizehint; + char *hunk = xmalloc (bufsize); + int tail = 0; /* tail position in HUNK */ + + assert (maxsize >= bufsize); while (1) { @@ -287,23 +392,28 @@ fd_read_until (int fd, finder_t finder, int bufsize) /* First, peek at the available data. */ - pklen = fd_peek (fd, buf + tail, size - tail, -1); + pklen = fd_peek (fd, hunk + tail, bufsize - 1 - tail, -1); if (pklen < 0) { - xfree (buf); + xfree (hunk); return NULL; } - end = finder (buf, tail, pklen); + end = terminator (hunk, tail, pklen); if (end) { - /* The data contains the terminator: we'll read the data up + /* The data contains the terminator: we'll drain the data up to the end of the terminator. */ - remain = end - (buf + tail); - /* Note +1 for trailing \0. */ - if (size < tail + remain + 1) + remain = end - (hunk + tail); + if (remain == 0) { - size = tail + remain + 1; - buf = xrealloc (buf, size); + /* No more data needs to be read. */ + hunk[tail] = '\0'; + return hunk; + } + if (bufsize - 1 < tail + remain) + { + bufsize = tail + remain + 1; + hunk = xrealloc (hunk, bufsize); } } else @@ -315,62 +425,71 @@ fd_read_until (int fd, finder_t finder, int bufsize) 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); + rdlen = fd_read (fd, hunk + tail, remain, 0); if (rdlen < 0) { - xfree_null (buf); + xfree_null (hunk); return NULL; } + tail += rdlen; + hunk[tail] = '\0'; + if (rdlen == 0) { if (tail == 0) { /* EOF without anything having been read */ - xfree (buf); + xfree (hunk); 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; + else + /* EOF seen: return the data we've read. */ + return hunk; } - 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; - } + /* The terminator was seen and the remaining data drained -- + we got what we came for. */ + return hunk; /* Keep looping until all the data arrives. */ - if (tail == size) + if (tail == bufsize - 1) { - size <<= 1; - buf = xrealloc (buf, size); + /* Double the buffer size, but refuse to allocate more than + MAXSIZE bytes. */ + if (maxsize && bufsize >= maxsize) + { + xfree (hunk); + errno = ENOMEM; + return NULL; + } + bufsize <<= 1; + if (maxsize && bufsize > maxsize) + bufsize = maxsize; + hunk = xrealloc (hunk, bufsize); } } } static const char * -line_terminator (const char *buf, int tail, int peeklen) +line_terminator (const char *hunk, int oldlen, int peeklen) { - const char *p = memchr (buf + tail, '\n', peeklen); + const char *p = memchr (hunk + oldlen, '\n', peeklen); if (p) /* p+1 because we want the line to include '\n' */ return p + 1; return NULL; } +/* The maximum size of the single line we agree to accept. This is + not meant to impose an arbitrary limit, but to protect the user + from Wget slurping up available memory upon encountering malicious + or buggy server output. Define it to 0 to remove the limit. */ +#define FD_READ_LINE_MAX 4096 + /* Read one line from FD and return it. The line is allocated using - malloc. + malloc, but is never larger than FD_READ_LINE_MAX. 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 @@ -379,53 +498,17 @@ line_terminator (const char *buf, int tail, int peeklen) 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 fd_read_hunk (fd, line_terminator, 128, FD_READ_LINE_MAX); } /* 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, double msecs, int pad) +retr_rate (wgint bytes, double msecs, int pad) { static char res[20]; - static char *rate_names[] = {"B/s", "KB/s", "MB/s", "GB/s" }; + static const char *rate_names[] = {"B/s", "KB/s", "MB/s", "GB/s" }; int units = 0; double dlrate = calc_rate (bytes, msecs, &units); @@ -442,7 +525,7 @@ retr_rate (long bytes, double msecs, int pad) UNITS is zero for B/s, one for KB/s, two for MB/s, and three for GB/s. */ double -calc_rate (long bytes, double msecs, int *units) +calc_rate (wgint bytes, double msecs, int *units) { double dlrate; @@ -451,11 +534,12 @@ calc_rate (long bytes, double msecs, int *units) if (msecs == 0) /* If elapsed time is exactly zero, it means we're under the - granularity of the timer. This often happens on systems that - use time() for the timer. */ - msecs = wtimer_granularity (); + granularity of the timer. This can easily happen on systems + that use time() for the timer. Since the interval lies between + 0 and the timer's granularity, assume half the granularity. */ + msecs = ptimer_granularity () / 2.0; - dlrate = (double)1000 * bytes / msecs; + dlrate = 1000.0 * bytes / msecs; if (dlrate < 1024.0) *units = 0; else if (dlrate < 1024.0 * 1024.0) @@ -630,7 +714,7 @@ retrieve_url (const char *origurl, char **file, char **newloc, newloc_parsed = url_parse (mynewloc, &up_error_code); if (!newloc_parsed) { - logprintf (LOG_NOTQUIET, "%s: %s.\n", mynewloc, + logprintf (LOG_NOTQUIET, "%s: %s.\n", escnonprint_uri (mynewloc), url_error (up_error_code)); url_free (u); xfree (url); @@ -707,7 +791,6 @@ retrieve_url (const char *origurl, char **file, char **newloc, xfree (url); } - ++global_download_count; RESTORE_POST_DATA; return result; @@ -846,7 +929,7 @@ 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; + struct_stat sb; int i; if (stat (fname, &sb) == 0) @@ -904,7 +987,7 @@ getproxy (struct url *u) rewritten_url = rewrite_shorthand_url (proxy); if (rewritten_url) { - strncpy (rewritten_storage, rewritten_url, sizeof(rewritten_storage)); + strncpy (rewritten_storage, rewritten_url, sizeof (rewritten_storage)); rewritten_storage[sizeof (rewritten_storage) - 1] = '\0'; proxy = rewritten_storage; }