diff options
Diffstat (limited to '')
| -rw-r--r-- | src/progress.c | 1462 |
1 files changed, 1462 insertions, 0 deletions
diff --git a/src/progress.c b/src/progress.c new file mode 100644 index 0000000..d8b57e3 --- /dev/null +++ b/src/progress.c @@ -0,0 +1,1462 @@ +/* Download progress. + Copyright (C) 2001-2011, 2015, 2018-2020 Free Software Foundation, + Inc. + +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 3 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 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with Wget. If not, see <http://www.gnu.org/licenses/>. + +Additional permission under GNU GPL version 3 section 7 + +If you modify this program, or any covered work, by linking or +combining it with the OpenSSL project's OpenSSL library (or a +modified version of that library), containing parts covered by the +terms of the OpenSSL or SSLeay licenses, the Free Software Foundation +grants you additional permission to convey the resulting work. +Corresponding Source for a non-source form of such a combination +shall include the source code for the parts of OpenSSL used as well +as that of the covered work. */ + +#include "wget.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <assert.h> +#include <unistd.h> +#include <signal.h> +#include <wchar.h> +#include <mbiter.h> + +#include "progress.h" +#include "utils.h" +#include "retr.h" +#include "c-strcase.h" + +struct progress_implementation { + const char *name; + bool interactive; + void *(*create) (const char *, wgint, wgint); + void (*update) (void *, wgint, double); + void (*draw) (void *); + void (*finish) (void *, double); + void (*set_params) (const char *); +}; + +/* Necessary forward declarations. */ + +static void *dot_create (const char *, wgint, wgint); +static void dot_update (void *, wgint, double); +static void dot_finish (void *, double); +static void dot_draw (void *); +static void dot_set_params (const char *); + +static void *bar_create (const char *, wgint, wgint); +static void bar_update (void *, wgint, double); +static void bar_draw (void *); +static void bar_finish (void *, double); +static void bar_set_params (const char *); + +static struct progress_implementation implementations[] = { + { "dot", 0, dot_create, dot_update, dot_draw, dot_finish, dot_set_params }, + { "bar", 1, bar_create, bar_update, bar_draw, bar_finish, bar_set_params } +}; +static struct progress_implementation *current_impl; +static int current_impl_locked; + +/* Progress implementation used by default. Can be overridden in + wgetrc or by the fallback one. */ + +#define DEFAULT_PROGRESS_IMPLEMENTATION "bar" + +/* Fallback progress implementation should be something that works + under all display types. If you put something other than "dot" + here, remember that bar_set_params tries to switch to this if we're + not running on a TTY. So changing this to "bar" could cause + infloop. */ + +#define FALLBACK_PROGRESS_IMPLEMENTATION "dot" + +/* Return true if NAME names a valid progress bar implementation. The + characters after the first : will be ignored. */ + +bool +valid_progress_implementation_p (const char *name) +{ + size_t i; + struct progress_implementation *pi = implementations; + char *colon = strchr (name, ':'); + size_t namelen = colon ? (size_t) (colon - name) : strlen (name); + + for (i = 0; i < countof (implementations); i++, pi++) + if (!strncmp (pi->name, name, namelen)) + return true; + return false; +} + +/* Set the progress implementation to NAME. */ + +void +set_progress_implementation (const char *name) +{ + size_t i, namelen; + struct progress_implementation *pi = implementations; + const char *colon; + + if (!name) + name = DEFAULT_PROGRESS_IMPLEMENTATION; + + colon = strchr (name, ':'); + namelen = colon ? (size_t) (colon - name) : strlen (name); + + for (i = 0; i < countof (implementations); i++, pi++) + if (!strncmp (pi->name, name, namelen)) + { + current_impl = pi; + current_impl_locked = 0; + + if (colon) + /* We call pi->set_params even if colon is NULL because we + want to give the implementation a chance to set up some + things it needs to run. */ + ++colon; + + if (pi->set_params) + pi->set_params (colon); + return; + } + abort (); +} + +static int output_redirected; + +void +progress_schedule_redirect (void) +{ + output_redirected = 1; +} + +/* Create a progress gauge. INITIAL is the number of bytes the + download starts from (zero if the download starts from scratch). + TOTAL is the expected total number of bytes in this download. If + TOTAL is zero, it means that the download size is not known in + advance. */ + +void * +progress_create (const char *f_download, wgint initial, wgint total) +{ + /* Check if the log status has changed under our feet. */ + if (output_redirected) + { + if (!current_impl_locked) + set_progress_implementation (FALLBACK_PROGRESS_IMPLEMENTATION); + output_redirected = 0; + } + + return current_impl->create (f_download, initial, total); +} + +/* Return true if the progress gauge is "interactive", i.e. if it can + profit from being called regularly even in absence of data. The + progress bar is interactive because it regularly updates the ETA + and current update. */ + +bool +progress_interactive_p (void *progress _GL_UNUSED) +{ + return current_impl->interactive; +} + +/* Inform the progress gauge of newly received bytes. DLTIME is the + time since the beginning of the download. */ + +void +progress_update (void *progress, wgint howmuch, double dltime) +{ + // sanitize input + if (dltime >= INT_MAX) + dltime = INT_MAX - 1; + else if (dltime < 0) + dltime = 0; + + if (howmuch < 0) + howmuch = 0; + + current_impl->update (progress, howmuch, dltime); + current_impl->draw (progress); +} + +/* Tell the progress gauge to clean up. Calling this will free the + PROGRESS object, the further use of which is not allowed. */ + +void +progress_finish (void *progress, double dltime) +{ + // sanitize input + if (dltime >= INT_MAX) + dltime = INT_MAX - 1; + else if (dltime < 0) + dltime = 0; + + current_impl->finish (progress, dltime); +} + +/* Dot-printing. */ + +struct dot_progress { + wgint initial_length; /* how many bytes have been downloaded + previously. */ + wgint total_length; /* expected total byte count when the + download finishes */ + + wgint accumulated; /* number of bytes accumulated after + the last printed dot */ + + double dltime; /* download time so far */ + wgint rows; /* number of rows printed so far */ + int dots; /* number of dots printed in this row */ + + double last_timer_value; +}; + +/* Dot-progress backend for progress_create. */ + +static void * +dot_create (const char *f_download _GL_UNUSED, wgint initial, wgint total) +{ + struct dot_progress *dp = xnew0 (struct dot_progress); + dp->initial_length = initial; + dp->total_length = total; + + if (dp->initial_length) + { + int dot_bytes = opt.dot_bytes; + const wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line; + + int remainder = dp->initial_length % ROW_BYTES; + wgint skipped = dp->initial_length - remainder; + + if (skipped) + { + wgint skipped_k = skipped / 1024; /* skipped amount in K */ + int skipped_k_len = numdigit (skipped_k); + if (skipped_k_len < 6) + skipped_k_len = 6; + + /* Align the [ skipping ... ] line with the dots. To do + that, insert the number of spaces equal to the number of + digits in the skipped amount in K. */ + logprintf (LOG_PROGRESS, _("\n%*s[ skipping %sK ]"), + 2 + skipped_k_len, "", + number_to_static_string (skipped_k)); + } + + logprintf (LOG_PROGRESS, "\n%6sK", + number_to_static_string (skipped / 1024)); + for (; remainder >= dot_bytes; remainder -= dot_bytes) + { + if (dp->dots % opt.dot_spacing == 0) + logputs (LOG_PROGRESS, " "); + logputs (LOG_PROGRESS, ","); + ++dp->dots; + } + assert (dp->dots < opt.dots_in_line); + + dp->accumulated = remainder; + dp->rows = skipped / ROW_BYTES; + } + + return dp; +} + +static const char *eta_to_human_short (int, bool); + +/* ADD_DOT_ROWS_THRS - minimal (1 << ADD_DOT_ROWS_THRS) ROWS to be added + to the current row if dp->accumulated too much. + Allows to reduce dot_draw io, times. + According to the way progress_update is currently has being called, this + should happens only when fuzzing, or (paranoia) if somehow buffer will + be too large. + Can be disabled by default if this is not fuzzing build. */ +#ifndef ADD_DOT_ROWS_THRS +#if FUZZING +#define ADD_DOT_ROWS_THRS 2 +#else +#define ADD_DOT_ROWS_THRS 2 +#endif +#endif /* ADD_DOT_ROWS_THRS */ + +/* Prints the stats (percentage of completion, speed, ETA) for current + row. DLTIME is the time spent downloading the data in current + row. + + #### This function is somewhat uglified by the fact that current + row and last row have somewhat different stats requirements. It + might be worthwhile to split it to two different functions. */ + +static void +#if ADD_DOT_ROWS_THRS +print_row_stats (struct dot_progress *dp, double dltime, bool last, wgint added_rows) +#else +print_row_stats (struct dot_progress *dp, double dltime, bool last) +#endif +{ + const wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line; + + /* bytes_displayed is the number of bytes indicated to the user by + dots printed so far, includes the initially "skipped" amount */ + wgint bytes_displayed = dp->rows * ROW_BYTES + dp->dots * opt.dot_bytes; + + if (last) + /* For last row also count bytes accumulated after last dot */ + bytes_displayed += dp->accumulated; + + if (bytes_displayed < 0) + bytes_displayed = 0; + + if (dp->total_length) + { + /* Round to floor value to provide gauge how much data *has* + been retrieved. 12.8% will round to 12% because the 13% mark + has not yet been reached. 100% is only shown when done. */ + int percentage = 100.0 * bytes_displayed / dp->total_length; + logprintf (LOG_PROGRESS, "%3d%%", percentage); + } + + { + static char names[] = {' ', 'K', 'M', 'G', 'T'}; + int units; + double rate; + wgint bytes_this_row; + if (!last) +#if ADD_DOT_ROWS_THRS + bytes_this_row = ROW_BYTES * added_rows; +#else + bytes_this_row = ROW_BYTES; +#endif + else + /* For last row also include bytes accumulated after last dot. */ + bytes_this_row = dp->dots * opt.dot_bytes + dp->accumulated; + /* Don't count the portion of the row belonging to initial_length */ + if (dp->rows == dp->initial_length / ROW_BYTES) + bytes_this_row -= dp->initial_length % ROW_BYTES; + rate = calc_rate (bytes_this_row, dltime - dp->last_timer_value, &units); + logprintf (LOG_PROGRESS, " %4.*f%c", + rate >= 99.95 ? 0 : rate >= 9.995 ? 1 : 2, + rate, names[units]); + dp->last_timer_value = dltime; + } + + if (!last) + { + /* Display ETA based on average speed. Inspired by Vladi + Belperchinov-Shabanski's "wget-new-percentage" patch. */ + if (dp->total_length) + { + wgint bytes_remaining = dp->total_length > bytes_displayed ? dp->total_length - bytes_displayed : 0; + /* The quantity downloaded in this download run. */ + wgint bytes_sofar = bytes_displayed > dp->initial_length ? bytes_displayed - dp->initial_length : 1; + double eta = dltime * bytes_remaining / bytes_sofar; + if (eta < 0) + eta = 0; + if (eta < INT_MAX - 1) + logprintf (LOG_PROGRESS, " %s", + eta_to_human_short ((int) (eta + 0.5), true)); + } + } + else + { + /* When done, print the total download time */ + if (dltime >= 10) + logprintf (LOG_PROGRESS, "=%s", + eta_to_human_short ((int) (dltime + 0.5), true)); + else + logprintf (LOG_PROGRESS, "=%ss", print_decimal (dltime)); + } +} + +/* Dot-progress backend for progress_update. */ + +static void +dot_update (void *progress, wgint howmuch, double dltime) +{ + // sanitize input + if (dltime >= INT_MAX) + dltime = INT_MAX - 1; + else if (dltime < 0) + dltime = 0; + + if (howmuch < 0) + howmuch = 0; + + struct dot_progress *dp = progress; + dp->accumulated += howmuch; + dp->dltime = dltime; +} + +static void +dot_draw (void *progress) +{ + struct dot_progress *dp = progress; + int dot_bytes = opt.dot_bytes; + wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line; + + log_set_flush (false); + + while (dp->accumulated >= dot_bytes) + { + dp->accumulated -= dot_bytes; + if (dp->dots == 0) + logprintf (LOG_PROGRESS, "\n%6sK", + number_to_static_string (dp->rows * ROW_BYTES / 1024)); + + if (dp->dots % opt.dot_spacing == 0) + logputs (LOG_PROGRESS, " "); + logputs (LOG_PROGRESS, "."); + + ++dp->dots; + if (dp->dots >= opt.dots_in_line) + { + dp->dots = 0; +#if ADD_DOT_ROWS_THRS + { + wgint added_rows = 1; + if (dp->accumulated >= (ROW_BYTES << ADD_DOT_ROWS_THRS)) + { + added_rows += dp->accumulated / ROW_BYTES; + dp->accumulated %= ROW_BYTES; + } + if (WGINT_MAX - dp->rows >= added_rows) + dp->rows += added_rows; + else + dp->rows = WGINT_MAX; + print_row_stats (dp, dp->dltime, false, added_rows); + } +#else + if (dp->rows < WGINT_MAX) + ++dp->rows; + print_row_stats (dp, dp->dltime, false); +#endif /* ADD_DOT_ROWS_THRS */ + } + } + + log_set_flush (true); +} + +/* Dot-progress backend for progress_finish. */ + +static void +dot_finish (void *progress, double dltime) +{ + struct dot_progress *dp = progress; + wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line; + int i; + + log_set_flush (false); + + if (dp->dots == 0) + logprintf (LOG_PROGRESS, "\n%6sK", + number_to_static_string (dp->rows * ROW_BYTES / 1024)); + for (i = dp->dots; i < opt.dots_in_line; i++) + { + if (i % opt.dot_spacing == 0) + logputs (LOG_PROGRESS, " "); + logputs (LOG_PROGRESS, " "); + } + + // sanitize input + if (dltime >= INT_MAX) + dltime = INT_MAX - 1; + else if (dltime < 0) + dltime = 0; +#if ADD_DOT_ROWS_THRS + print_row_stats (dp, dltime, true, 1); +#else + print_row_stats (dp, dltime, true); +#endif + logputs (LOG_VERBOSE, "\n\n"); + log_set_flush (false); + + xfree (dp); +} + +/* This function interprets the progress "parameters". For example, + if Wget is invoked with --progress=dot:mega, it will set the + "dot-style" to "mega". Valid styles are default, binary, mega, and + giga. */ + +static void +dot_set_params (const char *params) +{ + current_impl->interactive = false; + if (!params || !*params) + params = opt.dot_style; + + if (!params) + return; + + /* We use this to set the retrieval style. */ + if (!c_strcasecmp (params, "default")) + { + /* Default style: 1K dots, 10 dots in a cluster, 50 dots in a + line. */ + opt.dot_bytes = 1024; + opt.dot_spacing = 10; + opt.dots_in_line = 50; + } + else if (!c_strcasecmp (params, "binary")) + { + /* "Binary" retrieval: 8K dots, 16 dots in a cluster, 48 dots + (384K) in a line. */ + opt.dot_bytes = 8192; + opt.dot_spacing = 16; + opt.dots_in_line = 48; + } + else if (!c_strcasecmp (params, "mega")) + { + /* "Mega" retrieval, for retrieving very long files; each dot is + 64K, 8 dots in a cluster, 6 clusters (3M) in a line. */ + opt.dot_bytes = 65536L; + opt.dot_spacing = 8; + opt.dots_in_line = 48; + } + else if (!c_strcasecmp (params, "giga")) + { + /* "Giga" retrieval, for retrieving very very *very* long files; + each dot is 1M, 8 dots in a cluster, 4 clusters (32M) in a + line. */ + opt.dot_bytes = (1L << 20); + opt.dot_spacing = 8; + opt.dots_in_line = 32; + } + else + fprintf (stderr, + _("Invalid dot style specification %s; leaving unchanged.\n"), + quote (params)); +} + +/* "Thermometer" (bar) progress. */ + +/* Assumed screen width if we can't find the real value. */ +#define DEFAULT_SCREEN_WIDTH 80 + +/* Minimum screen width we'll try to work with. If this is too small, + create_image will overflow the buffer. + width = width/4 + 1 + PROGRESS_PERCENT_LEN + PROGRESS_FILESIZE_LEN + + PROGRESS_DWNLOAD_RATE + PROGRESS_ETA_LEN => widh = 38*4/3 (+1) */ +#define MINIMUM_SCREEN_WIDTH 51 + +/* The last known screen width. This can be updated by the code that + detects that SIGWINCH was received (but it's never updated from the + signal handler). */ +static int screen_width; + +/* A flag that, when set, means SIGWINCH was received. */ +static volatile sig_atomic_t received_sigwinch; + +/* Size of the download speed history ring. */ +#define DLSPEED_HISTORY_SIZE 20 + +/* The minimum time length of a history sample. By default, each + sample is at least 150ms long, which means that, over the course of + 20 samples, "current" download speed spans at least 3s into the + past. */ +#define DLSPEED_SAMPLE_MIN 0.15 + +/* The time after which the download starts to be considered + "stalled", i.e. the current bandwidth is not printed and the recent + download speeds are scratched. */ +#define STALL_START_TIME 5 + +/* Time between screen refreshes will not be shorter than this, so + that Wget doesn't swamp the TTY with output. */ +#define REFRESH_INTERVAL 0.2 + +/* Don't refresh the ETA too often to avoid jerkiness in predictions. + This allows ETA to change approximately once per second. */ +#define ETA_REFRESH_INTERVAL 0.99 + +struct bar_progress { + char *f_download; /* Filename of the downloaded file */ + wgint initial_length; /* how many bytes have been downloaded + previously. */ + wgint total_length; /* expected total byte count when the + download finishes */ + wgint count; /* bytes downloaded so far */ + + double last_screen_update; /* time of the last screen update, + measured since the beginning of + download. */ + + double dltime; /* download time so far */ + int width; /* screen width we're using at the + time the progress gauge was + created. this is different from + the screen_width global variable in + that the latter can be changed by a + signal. */ + char *buffer; /* buffer where the bar "image" is + stored. */ + int tick; /* counter used for drawing the + progress bar where the total size + is not known. */ + + /* The following variables (kept in a struct for namespace reasons) + keep track of recent download speeds. See bar_update() for + details. */ + struct bar_progress_hist { + int pos; + double times[DLSPEED_HISTORY_SIZE]; + wgint bytes[DLSPEED_HISTORY_SIZE]; + + /* The sum of times and bytes respectively, maintained for + efficiency. */ + double total_time; + wgint total_bytes; + } hist; + + double recent_start; /* timestamp of beginning of current + position. */ + wgint recent_bytes; /* bytes downloaded so far. */ + + bool stalled; /* set when no data arrives for longer + than STALL_START_TIME, then reset + when new data arrives. */ + + /* create_image() uses these to make sure that ETA information + doesn't flicker. */ + double last_eta_time; /* time of the last update to download + speed and ETA, measured since the + beginning of download. */ + int last_eta_value; +}; + +static void create_image (struct bar_progress *, double, bool); +static void display_image (char *); + +#if USE_NLS_PROGRESS_BAR +static size_t +prepare_filename (char *dest, const char *src) +{ + size_t ret = 1; + if (src) + { + mbi_iterator_t iter; + mbchar_t mbc; + mbi_init (iter, src, strlen (src)); + while (mbi_avail (iter)) + { + size_t i; + mbc = mbi_cur(iter); + /* replace invalid || unprintable || zero-width mbc ws hexdgt code */ + if (!mb_isprint (mbc) || !mb_width (mbc)) + for (i=0; i < mb_len (mbc); i++) + { + if (dest) + dest += sprintf (dest, "%%%02x", (unsigned char) *(mb_ptr(mbc) + i)); + ret += 3; + } + else + { + if (dest) + for (i=0; i < mb_len (mbc); i++) + *dest++ = *(mb_ptr (mbc) + i); + ret += mb_len (mbc); + } + mbi_advance (iter); + } + } + if (dest) + *dest = 0; + return ret; +} +#else +#include <ctype.h> +static size_t +prepare_filename (char *dest, const char *src) +{ + size_t ret = 1; + if (src) + while (*src) + { + /* isprint with some lang return false for some chars */ + if(!iscntrl (*src)) + { + if (dest) + *dest++ = *src; + ret++; + } + else + { + if (dest) + dest += sprintf (dest, "%%%02x", (unsigned char) *src ); + ret += 3; + } + src++; + } + if (dest) + *dest = 0; + return ret; +} +#endif /* USE_NLS_PROGRESS_BAR */ + +static void * +bar_create (const char *f_download, wgint initial, wgint total) +{ + struct bar_progress *bp = xnew0 (struct bar_progress); + + /* In theory, our callers should take care of this pathological + case, but it can sometimes happen. */ + if (initial > total) + total = initial; + + bp->initial_length = initial; + bp->total_length = total; + /* Zero-width mbc must be replaced to avoid buffer overflow. + Another way is to allocate a buffer that allows contain + full f_download, but in this case some escape sequences may break "bar" */ + bp->f_download = xmalloc (prepare_filename (NULL, f_download)); + prepare_filename (bp->f_download, f_download); + + /* Initialize screen_width if this hasn't been done or if it might + have changed, as indicated by receiving SIGWINCH. */ + if (!screen_width || received_sigwinch) + { + screen_width = determine_screen_width (); + if (!screen_width) + screen_width = DEFAULT_SCREEN_WIDTH; + else if (screen_width < MINIMUM_SCREEN_WIDTH) + screen_width = MINIMUM_SCREEN_WIDTH; + received_sigwinch = 0; + } + + /* - 1 because we don't want to use the last screen column. */ + bp->width = screen_width - 1; + /* + enough space for the terminating zero, and hopefully enough room + * for multibyte characters. */ +#define BUF_LEN (bp->width * 2 + 100) + bp->buffer = xcalloc (BUF_LEN, 1); + + logputs (LOG_VERBOSE, "\n"); + + create_image (bp, 0, false); + display_image (bp->buffer); + + return bp; +} + +static void update_speed_ring (struct bar_progress *, wgint, double); + +static void +bar_update (void *progress, wgint howmuch, double dltime) +{ + struct bar_progress *bp = progress; + + bp->dltime = dltime; + if (WGINT_MAX - (bp->count + bp->initial_length) >= howmuch) + bp->count += howmuch; + else + bp->count = WGINT_MAX - bp->initial_length; + if (bp->total_length > 0 + && bp->count + bp->initial_length > bp->total_length) + /* We could be downloading more than total_length, e.g. when the + server sends an incorrect Content-Length header. In that case, + adjust bp->total_length to the new reality, so that the code in + create_image() that depends on total size being smaller or + equal to the expected size doesn't abort. */ + bp->total_length = bp->initial_length + bp->count; + + update_speed_ring (bp, howmuch, dltime); +} + +static void +bar_draw (void *progress) +{ + bool force_screen_update = false; + struct bar_progress *bp = progress; + + /* If SIGWINCH (the window size change signal) been received, + determine the new screen size and update the screen. */ + if (received_sigwinch) + { + int old_width = screen_width; + screen_width = determine_screen_width (); + if (!screen_width) + screen_width = DEFAULT_SCREEN_WIDTH; + else if (screen_width < MINIMUM_SCREEN_WIDTH) + screen_width = MINIMUM_SCREEN_WIDTH; + if (screen_width != old_width) + { + bp->width = screen_width - 1; + bp->buffer = xrealloc (bp->buffer, BUF_LEN); + force_screen_update = true; + } + received_sigwinch = 0; + } + + if (bp->dltime - bp->last_screen_update < REFRESH_INTERVAL && !force_screen_update) + /* Don't update more often than five times per second. */ + return; + + create_image (bp, bp->dltime, false); + display_image (bp->buffer); + bp->last_screen_update = bp->dltime; +} + +static void +bar_finish (void *progress, double dltime) +{ + struct bar_progress *bp = progress; + + if (bp->total_length > 0 + && bp->count + bp->initial_length > bp->total_length) + /* See bar_update() for explanation. */ + bp->total_length = bp->initial_length + bp->count; + + create_image (bp, dltime, true); + display_image (bp->buffer); + + logputs (LOG_VERBOSE, "\n"); + logputs (LOG_PROGRESS, "\n"); + + xfree (bp->f_download); + xfree (bp->buffer); + xfree (bp); +} + +/* This code attempts to maintain the notion of a "current" download + speed, over the course of no less than 3s. (Shorter intervals + produce very erratic results.) + + To do so, it samples the speed in 150ms intervals and stores the + recorded samples in a FIFO history ring. The ring stores no more + than 20 intervals, hence the history covers the period of at least + three seconds and at most 20 reads into the past. This method + should produce reasonable results for downloads ranging from very + slow to very fast. + + The idea is that for fast downloads, we get the speed over exactly + the last three seconds. For slow downloads (where a network read + takes more than 150ms to complete), we get the speed over a larger + time period, as large as it takes to complete twenty reads. This + is good because slow downloads tend to fluctuate more and a + 3-second average would be too erratic. */ + +static void +update_speed_ring (struct bar_progress *bp, wgint howmuch, double dltime) +{ + struct bar_progress_hist *hist = &bp->hist; + double recent_age = dltime - bp->recent_start; + + /* Update the download count. */ + bp->recent_bytes += howmuch; + + /* For very small time intervals, we return after having updated the + "recent" download count. When its age reaches or exceeds minimum + sample time, it will be recorded in the history ring. */ + if (recent_age < DLSPEED_SAMPLE_MIN) + return; + + if (howmuch == 0) + { + /* If we're not downloading anything, we might be stalling, + i.e. not downloading anything for an extended period of time. + Since 0-reads do not enter the history ring, recent_age + effectively measures the time since last read. */ + if (recent_age >= STALL_START_TIME) + { + /* If we're stalling, reset the ring contents because it's + stale and because it will make bar_update stop printing + the (bogus) current bandwidth. */ + bp->stalled = true; + xzero (*hist); + bp->recent_bytes = 0; + } + return; + } + + /* We now have a non-zero amount of to store to the speed ring. */ + + /* If the stall status was acquired, reset it. */ + if (bp->stalled) + { + bp->stalled = false; + /* "recent_age" includes the entire stalled period, which + could be very long. Don't update the speed ring with that + value because the current bandwidth would start too small. + Start with an arbitrary (but more reasonable) time value and + let it level out. */ + recent_age = 1; + } + + /* Store "recent" bytes and download time to history ring at the + position POS. */ + + /* To correctly maintain the totals, first invalidate existing data + (least recent in time) at this position. */ + hist->total_time -= hist->times[hist->pos]; + hist->total_bytes -= hist->bytes[hist->pos]; + + /* Now store the new data and update the totals. */ + hist->times[hist->pos] = recent_age; + hist->bytes[hist->pos] = bp->recent_bytes; + hist->total_time += recent_age; + hist->total_bytes += bp->recent_bytes; + + /* Start a new "recent" period. */ + bp->recent_start = dltime; + bp->recent_bytes = 0; + + /* Advance the current ring position. */ + if (++hist->pos == DLSPEED_HISTORY_SIZE) + hist->pos = 0; + +#if 0 + /* Sledgehammer check to verify that the totals are accurate. */ + { + int i; + double sumt = 0, sumb = 0; + for (i = 0; i < DLSPEED_HISTORY_SIZE; i++) + { + sumt += hist->times[i]; + sumb += hist->bytes[i]; + } + assert (sumb == hist->total_bytes); + /* We can't use assert(sumt==hist->total_time) because some + precision is lost by adding and subtracting floating-point + numbers. But during a download this precision should not be + detectable, i.e. no larger than 1ns. */ + double diff = sumt - hist->total_time; + if (diff < 0) diff = -diff; + assert (diff < 1e-9); + } +#endif +} + +#if USE_NLS_PROGRESS_BAR +static int +count_cols (const char *mbs) +{ + mbchar_t mbc; + mbi_iterator_t iter; + int cols = 0; + mbi_init (iter, mbs, strlen(mbs)); + while (mbi_avail (iter)) + { + mbc = mbi_cur (iter); + cols += mb_width (mbc); + mbi_advance (iter); + } + return cols; +} + +static int +cols_to_bytes (const char *mbs, const int cols, int *ncols) +{ + int p_cols = 0, bytes = 0; + mbchar_t mbc; + mbi_iterator_t iter; + mbi_init (iter, mbs, strlen(mbs)); + while (p_cols < cols && mbi_avail (iter)) + { + mbc = mbi_cur (iter); + p_cols += mb_width (mbc); + /* The multibyte character has exceeded the total number of columns we + * have available. The remaining bytes will be padded with a space. */ + if (p_cols > cols) + { + p_cols -= mb_width (mbc); + break; + } + bytes += mb_len (mbc); + mbi_advance (iter); + } + *ncols = p_cols; + return bytes; +} +#else +static int count_cols (const char *mbs) { return (int) strlen(mbs); } + +static int +cols_to_bytes (const char *mbs, const int cols, int *ncols) +{ + int len = strlen(mbs); + int ret = len < cols ? len : cols; + *ncols = ret; + return ret; +} +#endif + +static const char * +get_eta (int *bcd) +{ + /* TRANSLATORS: "ETA" is English-centric, but this must + be short, ideally 3 chars. Abbreviate if necessary. */ + static const char eta_str[] = N_(" eta %s"); + static const char *eta_trans; + static int bytes_cols_diff; + if (eta_trans == NULL) + { + int nbytes; + int ncols; + +#if USE_NLS_PROGRESS_BAR + eta_trans = _(eta_str); +#else + eta_trans = eta_str; +#endif + + /* Determine the number of bytes used in the translated string, + * versus the number of columns used. This is to figure out how + * many spaces to add at the end to pad to the full line width. + * + * We'll store the difference between the number of bytes and + * number of columns, so that removing this from the string length + * will reveal the total number of columns in the progress bar. */ + nbytes = strlen (eta_trans); + ncols = count_cols (eta_trans); + bytes_cols_diff = nbytes - ncols; + } + + if (bcd != NULL) + *bcd = bytes_cols_diff; + + return eta_trans; +} + +#define APPEND_LITERAL(s) do { \ + memcpy (p, s, sizeof (s) - 1); \ + p += sizeof (s) - 1; \ +} while (0) + +static void +create_image (struct bar_progress *bp, double dl_total_time, bool done) +{ + const int MAX_FILENAME_COLS = bp->width / 4; + char *p = bp->buffer; + wgint size = bp->initial_length + bp->count; + + struct bar_progress_hist *hist = &bp->hist; + int orig_filename_cols = count_cols (bp->f_download); + + int padding; + + /* The progress bar should look like this: + file xx% [=======> ] nnn.nnK 12.34KB/s eta 36m 51s + + Calculate the geometry. The idea is to assign as much room as + possible to the progress bar. The other idea is to never let + things "jitter", i.e. pad elements that vary in size so that + their variance does not affect the placement of other elements. + It would be especially bad for the progress bar to be resized + randomly. + + "file " - Downloaded filename - MAX_FILENAME_COLS chars + 1 + "xx% " or "100%" - percentage - 4 chars + "[]" - progress bar decorations - 2 chars + " nnn.nnK" - downloaded bytes - 7 chars + 1 + " 12.5KB/s" - download rate - 8 chars + 1 + " eta 36m 51s" - ETA - 14 chars + + "=====>..." - progress bar - the rest + */ + + /* TODO: Ask the Turkish Translators to fix their translation for the "done" + * mode of progress bar. Use one less character. Once that is done, redice + * PROGRESS_ETA_LEN by 1. + */ +#define PROGRESS_FILENAME_LEN MAX_FILENAME_COLS + 1 +#define PROGRESS_PERCENT_LEN 4 +#define PROGRESS_DECORAT_LEN 2 +#define PROGRESS_FILESIZE_LEN 7 + 1 +#define PROGRESS_DWNLOAD_RATE 8 + 2 +#define PROGRESS_ETA_LEN 15 + + int progress_size = bp->width - (PROGRESS_FILENAME_LEN + PROGRESS_PERCENT_LEN + + PROGRESS_DECORAT_LEN + PROGRESS_FILESIZE_LEN + + PROGRESS_DWNLOAD_RATE + PROGRESS_ETA_LEN); + + /* The difference between the number of bytes used, + and the number of columns used. */ + int bytes_cols_diff = 0; + int cols_diff; + const char *down_size; + + if (progress_size < 5) + progress_size = 0; + + // sanitize input + if (dl_total_time >= INT_MAX) + dl_total_time = INT_MAX - 1; + else if (dl_total_time < 0) + dl_total_time = 0; + + if (orig_filename_cols < MAX_FILENAME_COLS) + { + p += sprintf (p, "%s", bp->f_download); + padding = MAX_FILENAME_COLS - orig_filename_cols + 1; + memset (p, ' ', padding); + p += padding; + } + else + { +/* + memcpy(p, bp->f_download, MAX_FILENAME_COLS); + p += MAX_FILENAME_COLS; + *p++ = ' '; + } +*/ + int offset_cols; + int bytes_in_filename, offset_bytes, col; + int *cols_ret = &col; + +#define MIN_SCROLL_TEXT 5 + if ((orig_filename_cols > MAX_FILENAME_COLS + MIN_SCROLL_TEXT) && + !opt.noscroll && + !done) + { + offset_cols = ((int) bp->tick + orig_filename_cols + MAX_FILENAME_COLS / 2) + % (orig_filename_cols + MAX_FILENAME_COLS); + if (offset_cols > orig_filename_cols) + { + padding = MAX_FILENAME_COLS - (offset_cols - orig_filename_cols); + memset(p, ' ', padding); + p += padding; + offset_cols = 0; + } + else + padding = 0; + } + else + { + padding = 0; + offset_cols = 0; + } + offset_bytes = cols_to_bytes (bp->f_download, offset_cols, cols_ret); + bytes_in_filename = cols_to_bytes (bp->f_download + offset_bytes, + MAX_FILENAME_COLS - padding, + cols_ret); + memcpy (p, bp->f_download + offset_bytes, bytes_in_filename); + p += bytes_in_filename; + padding = MAX_FILENAME_COLS - (padding + *cols_ret); + memset (p, ' ', padding + 1); + p += padding + 1; + } + + + /* "xx% " */ + if (bp->total_length > 0) + { + int percentage = 100.0 * size / bp->total_length; + assert (percentage <= 100); + p += sprintf (p, "%3d%%", percentage); + } + else + { + memset (p, ' ', PROGRESS_PERCENT_LEN); + p += PROGRESS_PERCENT_LEN; + } + + /* The progress bar: "[====> ]" or "[++==> ]". */ + if (progress_size && bp->total_length > 0) + { + /* Size of the initial portion. */ + int insz = (double)bp->initial_length / bp->total_length * progress_size; + + /* Size of the downloaded portion. */ + int dlsz = (double)size / bp->total_length * progress_size; + + char *begin; + + assert (dlsz <= progress_size); + assert (insz <= dlsz); + + *p++ = '['; + begin = p; + + /* Print the initial portion of the download with '+' chars, the + rest with '=' and one '>'. */ + memset (p, '+', insz); + p += insz; + + dlsz -= insz; + if (dlsz > 0) + { + memset (p, '=', dlsz-1); + p += dlsz - 1; + *p++ = '>'; + } + + memset (p, ' ', (progress_size - (p - begin))); + p += (progress_size - (p - begin)); + *p++ = ']'; + } + else if (progress_size) + { + /* If we can't draw a real progress bar, then at least show + *something* to the user. */ + int ind = bp->tick % (progress_size * 2 - 6); + int i, pos; + + /* Make the star move in two directions. */ + if (ind < progress_size - 2) + pos = ind + 1; + else + pos = progress_size - (ind - progress_size + 5); + + *p++ = '['; + for (i = 0; i < progress_size; i++) + { + if (i == pos - 1) *p++ = '<'; + else if (i == pos ) *p++ = '='; + else if (i == pos + 1) *p++ = '>'; + else + *p++ = ' '; + } + *p++ = ']'; + + } + ++bp->tick; + + /* " 234.56M" */ + down_size = human_readable (size, 1000, 2); + cols_diff = PROGRESS_FILESIZE_LEN - count_cols (down_size); + if (cols_diff > 0) + { + memset (p, ' ', cols_diff); + p += cols_diff; + } + p += sprintf (p, "%s", down_size); + + /* " 12.52Kb/s or 12.52KB/s" */ + if (hist->total_time > 0 && hist->total_bytes) + { + static const char *short_units[] = { " B/s", "KB/s", "MB/s", "GB/s", "TB/s" }; + static const char *short_units_bits[] = { " b/s", "Kb/s", "Mb/s", "Gb/s", "Tb/s" }; + int units = 0; + /* Calculate the download speed using the history ring and + recent data that hasn't made it to the ring yet. */ + wgint dlquant = hist->total_bytes + bp->recent_bytes; + double dltime = hist->total_time + (dl_total_time - bp->recent_start); + double dlspeed = calc_rate (dlquant, dltime, &units); + p += sprintf (p, " %4.*f%s", dlspeed >= 99.95 ? 0 : dlspeed >= 9.995 ? 1 : 2, + dlspeed, !opt.report_bps ? short_units[units] : short_units_bits[units]); + } + else + APPEND_LITERAL (" --.-KB/s"); + + if (!done) + { + /* " eta ..m ..s"; wait for three seconds before displaying the ETA. + That's because the ETA value needs a while to become + reliable. */ + if (bp->total_length > 0 && bp->count > 0 && dl_total_time > 3) + { + int eta; + + /* Don't change the value of ETA more than approximately once + per second; doing so would cause flashing without providing + any value to the user. */ + if (bp->total_length != size + && bp->last_eta_value != 0 + && dl_total_time - bp->last_eta_time < ETA_REFRESH_INTERVAL) + eta = bp->last_eta_value; + else + { + /* Calculate ETA using the average download speed to predict + the future speed. If you want to use a speed averaged + over a more recent period, replace dl_total_time with + hist->total_time and bp->count with hist->total_bytes. + I found that doing that results in a very jerky and + ultimately unreliable ETA. */ + wgint bytes_remaining = bp->total_length - size; + double eta_ = dl_total_time * bytes_remaining / bp->count; + if (eta_ >= INT_MAX - 1) + goto skip_eta; + eta = (int) (eta_ + 0.5); + bp->last_eta_value = eta; + bp->last_eta_time = dl_total_time; + } + + p += sprintf (p, get_eta(&bytes_cols_diff), + eta_to_human_short (eta, false)); + } + else if (bp->total_length > 0) + { + skip_eta: + memset (p, ' ', PROGRESS_ETA_LEN); + p += PROGRESS_ETA_LEN; + } + } + else + { + /* When the download is done, print the elapsed time. */ + int nbytes; + int ncols; + + /* TRANSLATORS: The meaning is "elapsed time", and it is shown + * next to the progress bar once the download is done. + * This should not take up more room than + * available here (6 columns). Abbreviate if necessary. */ + strcpy (p, _(" in ")); + nbytes = strlen (p); + ncols = count_cols (p); + bytes_cols_diff = nbytes - ncols; + if (dl_total_time >= 10) + ncols += sprintf (p + nbytes, "%s", eta_to_human_short ((int) (dl_total_time + 0.5), false)); + else + ncols += sprintf (p + nbytes, "%ss", print_decimal (dl_total_time)); + p += ncols + bytes_cols_diff; + if (ncols < PROGRESS_ETA_LEN) + { + memset (p, ' ', PROGRESS_ETA_LEN - ncols); + p += PROGRESS_ETA_LEN - ncols; + } + } + + *p = '\0'; + + padding = bp->width - count_cols (bp->buffer); + assert (padding >= 0 && "Padding length became non-positive!"); + if (padding > 0) + { +// if (padding > BUF_LEN - (p - bp->buffer) - 1) +// padding = BUF_LEN - (p - bp->buffer) - 1; + memset (p, ' ', padding); + p += padding; + *p = '\0'; + } + + /* 2014-11-14 Darshit Shah <darnir@gmail.com> + * Assert that the length of the progress bar is lesser than the size of the + * screen with which we are dealing. This assertion *MUST* always be removed + * from the release code since we do not want Wget to crash and burn when the + * assertion fails. Instead Wget should continue downloading and display a + * horrible and irritating progress bar that spams the screen with newlines. + * + * By default, all assertions are disabled in a Wget build and are enabled + * only with the --enable-assert configure option. + */ + assert (count_cols (bp->buffer) == bp->width); +} + +/* Print the contents of the buffer as a one-line ASCII "image" so + that it can be overwritten next time. */ + +static void +display_image (char *buf) +{ + bool old = log_set_save_context (false); + logputs (LOG_PROGRESS, "\r"); + logputs (LOG_PROGRESS, buf); + log_set_save_context (old); +} + +static void +bar_set_params (const char *params) +{ +/* if run_with_timeout() will be used for read, needs to disable interactive bar, + or on every timeout(1s) we will have 'retry' with error "decryption failed" */ +#if (defined(HAVE_LIBSSL) || defined(HAVE_LIBSSL32)) && defined(OPENSSL_RUN_WITHTIMEOUT) + current_impl->interactive = false; +#else + current_impl->interactive = true; +#endif + if (params) + { + for (const char *param = params; *param; ) + { + if (!strncmp (param, "force", 5)) + current_impl_locked = 1; + else if (!strncmp (param, "noscroll", 8)) + opt.noscroll = true; + + if (*(param = strchrnul(param, ':'))) + param++; + } + } + + if (((opt.lfilename && opt.show_progress != 1) +#ifdef HAVE_ISATTY + /* The progress bar doesn't make sense if the output is not a + TTY -- when logging to file, it is better to review the + dots. */ + || !isatty (fileno (stderr)) +#endif + ) + && !current_impl_locked) + { + /* We're not printing to a TTY, so revert to the fallback + display. #### We're recursively calling + set_progress_implementation here, which is slightly kludgy. + It would be nicer if we provided that function a return value + indicating a failure of some sort. */ + set_progress_implementation (FALLBACK_PROGRESS_IMPLEMENTATION); + return; + } +} + +#ifdef SIGWINCH +void +progress_handle_sigwinch (int sig _GL_UNUSED) +{ + received_sigwinch = 1; + signal (SIGWINCH, progress_handle_sigwinch); +} +#endif + +/* Provide a short human-readable rendition of the ETA. This is like + secs_to_human_time in main.c, except the output doesn't include + fractions (which would look silly in by nature imprecise ETA) and + takes less room. If the time is measured in hours, hours and + minutes (but not seconds) are shown; if measured in days, then days + and hours are shown. This ensures brevity while still displaying + as much as possible. + + If CONDENSED is true, the separator between minutes and seconds + (and hours and minutes, etc.) is not included, shortening the + display by one additional character. This is used for dot + progress. + + The display never occupies more than 7 characters of screen + space. */ + +static const char * +eta_to_human_short (int secs, bool condensed) +{ + static char buf[16]; /* enough space to be on the safe side */ + static int last = -1; + const char *space = condensed ? "" : " "; + + /* Trivial optimization. create_image can call us every 200 msecs + (see bar_update) for fast downloads, but ETA will only change + once per 900 msecs. */ + if (secs == last) + return buf; + last = secs; + + if (secs < 100) + sprintf (buf, "%ds", secs); + else if (secs < 100 * 60) + sprintf (buf, "%dm%s%ds", secs / 60, space, secs % 60); + else if (secs < 48 * 3600) + sprintf (buf, "%dh%s%dm", secs / 3600, space, (secs / 60) % 60); + else if (secs < 100 * 86400) + sprintf (buf, "%dd%s%dh", secs / 86400, space, (secs / 3600) % 24); + else + /* even (2^31-1)/86400 doesn't overflow BUF. */ + sprintf (buf, "%dd", secs / 86400); + + return buf; +} |