X-Git-Url: http://sjero.net/git/?a=blobdiff_plain;f=src%2Fretr.c;h=e619f1cbb74b9ef5b1d50131d8d4ad957c5a6684;hb=9228f0bf53d3b42459daeb28372196a007de3014;hp=9b8ddc214ad74f429ccd45cca6fdbfe1478bf38d;hpb=cdcf67a5bdae9c56d263ebf7608b52701851cf22;p=wget diff --git a/src/retr.c b/src/retr.c index 9b8ddc21..e619f1cb 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 @@ -44,6 +54,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "connect.h" #include "hash.h" +#ifdef HAVE_SSL +# include "gen_sslfunc.h" /* for ssl_iread */ +#endif + #ifndef errno extern int errno; #endif @@ -52,6 +66,50 @@ extern int errno; int global_download_count; +static struct { + long bytes; + double dltime; +} limit_data; + +static void +limit_bandwidth_reset (void) +{ + limit_data.bytes = 0; + limit_data.dltime = 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. */ + +static void +limit_bandwidth (long bytes, double delta) +{ + double expected; + + limit_data.bytes += bytes; + limit_data.dltime += delta; + + expected = 1000.0 * limit_data.bytes / opt.limit_rate; + + if (expected > limit_data.dltime) + { + double slp = expected - limit_data.dltime; + if (slp < 200) + { + DEBUGP (("deferring a %.2f ms sleep (%ld/%.2f).\n", + slp, limit_data.bytes, limit_data.dltime)); + return; + } + DEBUGP (("sleeping %.2f ms\n", slp)); + usleep ((unsigned long) (1000 * slp)); + } + + limit_data.bytes = 0; + limit_data.dltime = 0; +} + #define MIN(i, j) ((i) <= (j) ? (i) : (j)) /* Reads the contents of file descriptor FD, until it is closed, or a @@ -77,33 +135,43 @@ int global_download_count; 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) + struct rbuf *rbuf, int use_expected, double *elapsed) { int res = 0; - static char c[8192]; + static char c[16384]; void *progress = NULL; + struct wget_timer *timer = wtimer_allocate (); + double dltime = 0, last_dltime = 0; *len = restval; + if (opt.verbose) progress = progress_create (restval, expected); if (rbuf && RBUF_FD (rbuf) == fd) { - int need_flush = 0; + int sz = 0; while ((res = rbuf_flush (rbuf, c, sizeof (c))) != 0) { - if (fwrite (c, sizeof (char), res, fp) < res) - return -2; - if (opt.verbose) - progress_update (progress, res); + fwrite (c, sizeof (char), res, fp); *len += res; - need_flush = 1; + sz += res; } - if (need_flush) + if (sz) fflush (fp); if (ferror (fp)) - return -2; + { + res = -2; + goto out; + } + if (progress) + progress_update (progress, sz, 0); } + + if (opt.limit_rate) + limit_bandwidth_reset (); + wtimer_reset (timer); + /* Read from fd while there is available data. Normally, if expected is 0, it means that it is not known how @@ -115,14 +183,12 @@ get_contents (int fd, FILE *fp, long *len, long restval, long 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 - } + if (rbuf->ssl!=NULL) + res = ssl_iread (rbuf->ssl, c, amount_to_read); + else #endif /* HAVE_SSL */ + res = iread (fd, c, amount_to_read); + if (res > 0) { fwrite (c, sizeof (char), res, fp); @@ -131,9 +197,23 @@ get_contents (int fd, FILE *fp, long *len, long restval, long expected, packets typically won't be too tiny anyway. */ fflush (fp); if (ferror (fp)) - return -2; - if (opt.verbose) - progress_update (progress, res); + { + res = -2; + goto out; + } + + /* 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 (progress) + progress_update (progress, res, dltime); *len += res; } else @@ -141,56 +221,99 @@ get_contents (int fd, FILE *fp, long *len, long restval, long expected, } if (res < -1) res = -1; - if (opt.verbose) - progress_finish (progress); + + out: + if (progress) + progress_finish (progress, dltime); + if (elapsed) + *elapsed = dltime; + wtimer_delete (timer); + return res; } /* Return a printed representation of the download rate, 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. - - If PAD is non-zero, strings will be padded to the width of 7 - characters (xxxx.xx). */ + 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 K/s" : "%.2f K/s", dlrate / 1024.0); + *units = 1, dlrate /= 1024.0; else if (dlrate < 1024.0 * 1024.0 * 1024.0) - sprintf (res, pad ? "%7.2f M/s" : "%.2f M/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)); + *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) + +/* 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) @@ -198,12 +321,15 @@ 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) @@ -218,8 +344,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; } @@ -232,55 +356,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) { @@ -288,29 +395,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); @@ -326,53 +437,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); + mynewloc = xstrdup (newloc_parsed->url); - if (!redirections) + /* Check for max. number of redirections. */ + if (++redirection_count > MAX_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); - } - - /* The new location is OK. Check for redirection cycle by - peeking through the history of redirections. */ - if (string_set_contains (redirections, newloc_struct->url)) - { - 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; } @@ -380,9 +488,11 @@ 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); } } @@ -392,15 +502,23 @@ retrieve_url (const char *origurl, char **file, char **newloc, FREE_MAYBE (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; } @@ -414,27 +532,30 @@ 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 (cur_url->ignore_when_downloading) + continue; + if (downloaded_exceeds_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 && 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)) { @@ -509,22 +630,41 @@ sleep_between_retrievals (int count) { static int first_retrieval = 1; - if (!first_retrieval && (opt.wait || opt.waitretry)) + 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) + sleep (count - 1); + else + sleep (opt.waitretry); + } + else if (opt.wait) { - if (opt.waitretry && count > 1) + 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. */ + sleep (opt.wait); + else { - /* 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); + /* 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); + + DEBUGP (("sleep_between_retrievals: norm=%ld,fuzz=%ld,sleep=%d\n", + opt.wait, waitsecs - opt.wait, waitsecs)); + + if (waitsecs) + sleep (waitsecs); } - else if (opt.wait) - /* Otherwise, check if opt.wait is specified. If so, sleep. */ - sleep (opt.wait); } - if (first_retrieval) - first_retrieval = 0; }