X-Git-Url: http://sjero.net/git/?a=blobdiff_plain;f=src%2Fretr.c;h=5d9795ad67ac7177163f96d1dff28f2eaa6bb9c7;hb=d9fea91a0a319e348adb504bd3edff148ff3d8a0;hp=398bc52cb0f79e503a56290a853b80abed88cf50;hpb=d5be8ecca466601bda9b81c28a79077fbda6ccde;p=wget diff --git a/src/retr.c b/src/retr.c index 398bc52c..5d9795ad 100644 --- a/src/retr.c +++ b/src/retr.c @@ -5,8 +5,8 @@ This file is part of GNU Wget. GNU Wget is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. +the Free Software Foundation; either version 2 of the License, or (at +your option) any later version. GNU Wget is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -15,7 +15,17 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Wget; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +In addition, as a special exception, the Free Software Foundation +gives permission to link the code of its release of Wget with the +OpenSSL project's "OpenSSL" library (or with modified versions of it +that use the same license as the "OpenSSL" library), and distribute +the linked executables. You must obey the GNU General Public License +in all respects for all of the code used other than "OpenSSL". If you +modify this file, you may extend this exception to your version of the +file, but you are not obligated to do so. If you do not wish to do +so, delete this exception statement from your version. */ #include @@ -36,12 +46,18 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "wget.h" #include "utils.h" #include "retr.h" +#include "progress.h" #include "url.h" #include "recur.h" #include "ftp.h" #include "host.h" #include "connect.h" #include "hash.h" +#include "convert.h" + +#ifdef HAVE_SSL +# include "gen_sslfunc.h" /* for ssl_iread */ +#endif #ifndef errno extern int errno; @@ -50,20 +66,74 @@ extern int errno; /* See the comment in gethttp() why this is needed. */ int global_download_count; -void logflush PARAMS ((void)); +/* Total size of downloaded files. Used to enforce quota. */ +LARGE_INT total_downloaded_bytes; + -/* Flags for show_progress(). */ -enum spflags { SP_NONE, SP_INIT, SP_FINISH }; +static struct { + long chunk_bytes; + double chunk_start; + double sleep_adjust; +} limit_data; + +static void +limit_bandwidth_reset (void) +{ + 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, and TIMER + is the timer that started at the beginning of download. */ + +static void +limit_bandwidth (long bytes, struct wget_timer *timer) +{ + double delta_t = wtimer_read (timer) - limit_data.chunk_start; + double expected; + + limit_data.chunk_bytes += bytes; -static int show_progress PARAMS ((long, long, enum spflags)); + /* 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 > delta_t) + { + 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.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)); + + 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.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. @@ -75,35 +145,49 @@ static int show_progress PARAMS ((long, long, enum spflags)); 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) +fd_read_body (int fd, FILE *out, long *len, long restval, long expected, + int use_expected, double *elapsed) { int res = 0; - static char c[8192]; + + static char dlbuf[16384]; + int dlbufsize = sizeof (dlbuf); + + struct wget_timer *timer = wtimer_allocate (); + 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) - show_progress (restval, expected, SP_INIT); - if (rbuf && RBUF_FD (rbuf) == fd) { - 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); - } - *len += res; - } + 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; + + /* 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; + /* Read from fd while there is available data. Normally, if expected is 0, it means that it is not known how @@ -112,198 +196,311 @@ get_contents (int fd, FILE *fp, long *len, long restval, long expected, while (!use_expected || (*len < expected)) { int amount_to_read = (use_expected - ? MIN (expected - *len, sizeof (c)) - : sizeof (c)); -#ifdef HAVE_SSL - if (rbuf->ssl!=NULL) { - res = ssl_iread (rbuf->ssl, c, amount_to_read); - } else { -#endif /* HAVE_SSL */ - res = iread (fd, c, amount_to_read); -#ifdef HAVE_SSL + ? MIN (expected - *len, 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) + { + /* 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; } -#endif /* HAVE_SSL */ + } + } + 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) { - if (fwrite (c, sizeof (char), res, fp) < res) - return -2; - if (opt.verbose) + 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)) { - if (show_progress (res, expected, SP_NONE)) - fflush (fp); + res = -2; + goto out; } - *len += res; + last_successful_read_tm = wtimer_read (timer); } - else - break; + + if (opt.limit_rate) + limit_bandwidth (res, timer); + + *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; - if (opt.verbose) - show_progress (0, expected, SP_FINISH); + + out: + if (progress) + progress_finish (progress, wtimer_read (timer)); + if (elapsed) + *elapsed = wtimer_read (timer); + wtimer_delete (timer); + return res; } + +typedef const char *(*finder_t) PARAMS ((const char *, int, int)); -static void -print_percentage (long bytes, long expected) -{ - int percentage = (int)(100.0 * bytes / expected); - logprintf (LOG_VERBOSE, "%3d%%", percentage); -} +/* 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. */ -/* 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 * +fd_read_until (int fd, finder_t finder, int bufsize) +{ + int size = bufsize, tail = 0; + char *buf = xmalloc (size); - Return value: 1 or 0, designating whether any dots have been drawn. + while (1) + { + const char *end; + int pklen, rdlen, remain; - If the init argument is set, the routine will initialize. + /* First, peek at the available data. */ - 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++) + pklen = fd_peek (fd, buf + tail, size - tail, -1); + if (pklen < 0) { - if (!(dot % opt.dot_spacing)) - *tmpp++ = ' '; - *tmpp++ = ' '; + xfree (buf); + return NULL; } - *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; - } + 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; - /* 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) + /* 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) { - if (res >= line_bytes) + 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) { - nrow = res / line_bytes; - res %= line_bytes; - logprintf (LOG_VERBOSE, - _("\n [ skipping %dK ]"), - (int) ((nrow * line_bytes) / 1024)); - ndot = 0; + size = tail + 1; /* expand the buffer to receive the + terminating \0 */ + buf = xrealloc (buf, size); } + buf[tail] = '\0'; + return buf; } - 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) + tail += rdlen; + if (end && rdlen == remain) { - 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); + /* 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); } } - /* Reenable flushing. */ - opt.no_flush = 0; - if (any_output) - /* Force flush. */ - logflush (); - return any_output; } - -/* 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). */ +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). */ char * -rate (long bytes, long msecs, int pad) +retr_rate (long bytes, double msecs, int pad) +{ + static char res[20]; + static char *rate_names[] = {"B/s", "KB/s", "MB/s", "GB/s" }; + int units = 0; + + double dlrate = calc_rate (bytes, msecs, &units); + sprintf (res, pad ? "%7.2f %s" : "%.2f %s", dlrate, rate_names[units]); + + return res; +} + +/* 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, double 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 - the timer. */ + /* 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 (); 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)); + /* Maybe someone will need this, one day. */ + *units = 3, dlrate /= (1024.0 * 1024.0 * 1024.0); - return res; + return dlrate; } -#define USE_PROXY_P(u) (opt.use_proxy && getproxy((u)->scheme) \ - && no_proxy_match((u)->host, \ - (const char **)opt.no_proxy)) +/* Maximum number of allowed redirections. 20 was chosen as a + "reasonable" value, which is low enough to not cause havoc, yet + high enough to guarantee that normal retrievals will not be hurt by + the check. */ + +#define MAX_REDIRECTIONS 20 + +#define SUSPEND_POST_DATA do { \ + post_data_suspended = 1; \ + saved_post_data = opt.post_data; \ + saved_post_file_name = opt.post_file_name; \ + opt.post_data = NULL; \ + opt.post_file_name = NULL; \ +} while (0) + +#define RESTORE_POST_DATA do { \ + if (post_data_suspended) \ + { \ + opt.post_data = saved_post_data; \ + opt.post_file_name = saved_post_file_name; \ + post_data_suspended = 0; \ + } \ +} while (0) + +static char *getproxy PARAMS ((struct url *)); + +/* Retrieve the given URL. Decides which loop to call -- HTTP, FTP, + FTP, proxy, etc. */ + +/* #### This function should be rewritten so it doesn't return from + multiple points. */ -/* Retrieve the given URL. Decides which loop to call -- HTTP(S), FTP, - or simply copy it with file:// (#### the latter not yet - implemented!). */ uerr_t retrieve_url (const char *origurl, char **file, char **newloc, const char *refurl, int *dt) @@ -311,16 +508,22 @@ retrieve_url (const char *origurl, char **file, char **newloc, uerr_t result; char *url; int location_changed, dummy; - int use_proxy; char *mynewloc, *proxy; - struct url *u; + struct url *u, *proxy_url; int up_error_code; /* url parse error code */ char *local_file; - struct hash_table *redirections = NULL; + int redirection_count = 0; + + int post_data_suspended = 0; + 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; @@ -331,8 +534,6 @@ retrieve_url (const char *origurl, char **file, char **newloc, if (!u) { logprintf (LOG_NOTQUIET, "%s: %s.\n", url, url_error (up_error_code)); - if (redirections) - string_set_free (redirections); xfree (url); return URLERROR; } @@ -345,55 +546,38 @@ retrieve_url (const char *origurl, char **file, char **newloc, result = NOCONERROR; mynewloc = NULL; local_file = NULL; + proxy_url = NULL; - use_proxy = USE_PROXY_P (u); - if (use_proxy) + proxy = getproxy (u); + if (proxy) { - struct url *proxy_url; - - /* Get the proxy server for the current scheme. */ - proxy = getproxy (u->scheme); - if (!proxy) - { - logputs (LOG_NOTQUIET, _("Could not find proxy host.\n")); - url_free (u); - if (redirections) - string_set_free (redirections); - xfree (url); - return PROXERR; - } - /* Parse the proxy URL. */ 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); xfree (url); + RESTORE_POST_DATA; return PROXERR; } - if (proxy_url->scheme != SCHEME_HTTP) + if (proxy_url->scheme != SCHEME_HTTP && proxy_url->scheme != u->scheme) { logprintf (LOG_NOTQUIET, _("Error in proxy URL %s: Must be HTTP.\n"), proxy); url_free (proxy_url); - if (redirections) - string_set_free (redirections); xfree (url); + RESTORE_POST_DATA; return PROXERR; } - - result = http_loop (u, &mynewloc, &local_file, refurl, dt, proxy_url); - url_free (proxy_url); } - else if (u->scheme == SCHEME_HTTP + + if (u->scheme == SCHEME_HTTP #ifdef HAVE_SSL || u->scheme == SCHEME_HTTPS #endif - ) + || (proxy_url && proxy_url->scheme == SCHEME_HTTP)) { - result = http_loop (u, &mynewloc, &local_file, refurl, dt, NULL); + result = http_loop (u, &mynewloc, &local_file, refurl, dt, proxy_url); } else if (u->scheme == SCHEME_FTP) { @@ -401,29 +585,33 @@ retrieve_url (const char *origurl, char **file, char **newloc, retrieval, so we save recursion to oldrec, and restore it later. */ int oldrec = opt.recursive; - if (redirections) + if (redirection_count) opt.recursive = 0; - result = ftp_loop (u, dt); + result = ftp_loop (u, dt, proxy_url); opt.recursive = oldrec; -#if 0 + /* There is a possibility of having HTTP being redirected to FTP. In these cases we must decide whether the text is HTML - according to the suffix. The HTML suffixes are `.html' and - `.htm', case-insensitive. */ - if (redirections && u->local && (u->scheme == SCHEME_FTP)) + according to the suffix. The HTML suffixes are `.html', + `.htm' and a few others, case-insensitive. */ + if (redirection_count && local_file && u->scheme == SCHEME_FTP) { - char *suf = suffix (u->local); - if (suf && (!strcasecmp (suf, "html") || !strcasecmp (suf, "htm"))) + if (has_html_suffix_p (local_file)) *dt |= TEXTHTML; - FREE_MAYBE (suf); } -#endif } + + if (proxy_url) + { + url_free (proxy_url); + proxy_url = NULL; + } + location_changed = (result == NEWLOCATION); if (location_changed) { char *construced_newloc; - struct url *newloc_struct; + struct url *newloc_parsed; assert (mynewloc != NULL); @@ -439,53 +627,50 @@ retrieve_url (const char *origurl, char **file, char **newloc, 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); xfree (url); xfree (mynewloc); + RESTORE_POST_DATA; 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); - - if (!redirections) - { - redirections = make_string_hash_table (0); - /* Add current URL immediately so we can detect it as soon - as possible in case of a cycle. */ - string_set_add (redirections, u->url); - } + mynewloc = xstrdup (newloc_parsed->url); - /* The new location is OK. Check for redirection cycle by - peeking through the history of redirections. */ - if (string_set_contains (redirections, newloc_struct->url)) + /* Check for max. number of redirections. */ + if (++redirection_count > MAX_REDIRECTIONS) { - logprintf (LOG_NOTQUIET, _("%s: Redirection cycle detected.\n"), - mynewloc); - url_free (newloc_struct); + logprintf (LOG_NOTQUIET, _("%d redirections exceeded.\n"), + MAX_REDIRECTIONS); + url_free (newloc_parsed); url_free (u); - if (redirections) - string_set_free (redirections); xfree (url); xfree (mynewloc); + RESTORE_POST_DATA; return WRONGCODE; } - string_set_add (redirections, newloc_struct->url); xfree (url); url = mynewloc; url_free (u); - u = newloc_struct; + u = newloc_parsed; + + /* If we're being redirected from POST, we don't want to POST + again. Many requests answer POST with a redirection to an + index page; that redirection is clearly a GET. We "suspend" + POST data for the duration of the redirections, and restore + it when we're done. */ + if (!post_data_suspended) + SUSPEND_POST_DATA; + goto redirected; } @@ -493,27 +678,37 @@ retrieve_url (const char *origurl, char **file, char **newloc, { if (*dt & RETROKF) { - register_download (url, local_file); + register_download (u->url, local_file); + if (redirection_count && 0 != strcmp (origurl, u->url)) + register_redirection (origurl, u->url); if (*dt & TEXTHTML) - register_html (url, local_file); + register_html (u->url, local_file); } } if (file) *file = local_file ? local_file : NULL; else - FREE_MAYBE (local_file); + xfree_null (local_file); url_free (u); - if (redirections) - string_set_free (redirections); - if (newloc) - *newloc = url; + if (redirection_count) + { + if (newloc) + *newloc = url; + else + xfree (url); + } else - xfree (url); + { + if (newloc) + *newloc = NULL; + xfree (url); + } ++global_download_count; + RESTORE_POST_DATA; return result; } @@ -522,32 +717,37 @@ 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) { uerr_t status; - urlpos *url_list, *cur_url; + struct urlpos *url_list, *cur_url; - url_list = (html ? get_urls_html (file, NULL, FALSE, NULL) + url_list = (html ? get_urls_html (file, NULL, 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 = NULL; int dt; - if (downloaded_exceeds_quota ()) + if (cur_url->ignore_when_downloading) + continue; + + if (opt.quota && total_downloaded_bytes > opt.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 || 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); if (filename && opt.delete_after && file_exists_p (filename)) { @@ -559,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. */ @@ -577,67 +777,147 @@ 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. */ +/* 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) + { + /* Don't sleep before the very first retrieval. */ + first_retrieval = 0; + return; + } + + 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) + xsleep (count - 1); + else + xsleep (opt.waitretry); + } + else if (opt.wait) + { + if (!opt.random_wait || count > 1) + /* If random-wait is not specified, or if we are sleeping + between retries of the same download, sleep the fixed + interval. */ + 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. */ + double waitsecs = 2 * opt.wait * random_float (); + DEBUGP (("sleep_between_retrievals: avg=%f,sleep=%f\n", + opt.wait, waitsecs)); + xsleep (waitsecs); + } + } +} + +/* Free the linked list of urlpos. */ void -downloaded_increase (unsigned long by_how_much) +free_urlpos (struct urlpos *l) { - 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? */ + while (l) { - /* Overflow. */ - opt.downloaded_overflow = 1; - opt.downloaded = ~((VERY_LONG_TYPE)0); + struct urlpos *next = l->next; + if (l->url) + url_free (l->url); + xfree_null (l->local_name); + xfree (l); + l = next; } } -/* 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) +/* Rotate FNAME opt.backups times */ +void +rotate_backups(const char *fname) { - if (!opt.quota) - return 0; - if (opt.downloaded_overflow) - /* We don't really know. (Wildly) assume not. */ - return 0; + 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); + } - return opt.downloaded > opt.quota; + sprintf (to, "%s.%d", fname, 1); + rename(fname, to); } -/* 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. +static int no_proxy_match PARAMS ((const char *, const char **)); - COUNT is the count of current retrieval, beginning with 1. */ +/* Return the URL of the proxy appropriate for url U. */ -void -sleep_between_retrievals (int count) +static char * +getproxy (struct url *u) { - static int first_retrieval = 1; + char *proxy = NULL; + char *rewritten_url; + static char rewritten_storage[1024]; - if (!first_retrieval && (opt.wait || opt.waitretry)) + if (!opt.use_proxy) + return NULL; + if (!no_proxy_match (u->host, (const char **)opt.no_proxy)) + return NULL; + + switch (u->scheme) { - 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); + 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 (first_retrieval) - first_retrieval = 0; + 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); }