progressmeter.c

   1 /* $OpenBSD: progressmeter.c,v 1.31 2006/07/17 01:31:09 stevesk Exp $ */
   2 /*
   3  * Copyright (c) 2003 Nils Nordman.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "includes.h"
  27
  28 #include <sys/types.h>
  29 #include <sys/ioctl.h>
  30
  31 #include <errno.h>
  32 #include <signal.h>
  33 #include <unistd.h>
  34
  35 #include "progressmeter.h"
  36 #include "atomicio.h"
  37 #include "misc.h"
  38
  39 #define DEFAULT_WINSIZE 80
  40 #define MAX_WINSIZE 512
  41 #define PADDING 1               /* padding between the progress indicators */
  42 #define UPDATE_INTERVAL 1       /* update the progress meter every second */
  43 #define STALL_TIME 5            /* we're stalled after this many seconds */
  44
  45 /* determines whether we can output to the terminal */
  46 static int can_output(void);
  47
  48 /* formats and inserts the specified size into the given buffer */
  49 static void format_size(char *, int, off_t);
  50 static void format_rate(char *, int, off_t);
  51
  52 /* window resizing */
  53 static void sig_winch(int);
  54 static void setscreensize(void);
  55
  56 /* updates the progressmeter to reflect the current state of the transfer */
  57 void refresh_progress_meter(void);
  58
  59 /* signal handler for updating the progress meter */
  60 static void update_progress_meter(int);
  61
  62 static time_t start;            /* start progress */
  63 static time_t last_update;      /* last progress update */
  64 static char *file;              /* name of the file being transferred */
  65 static off_t end_pos;           /* ending position of transfer */
  66 static off_t cur_pos;           /* transfer position as of last refresh */
  67 static volatile off_t *counter; /* progress counter */
  68 static long stalled;            /* how long we have been stalled */
  69 static int bytes_per_second;    /* current speed in bytes per second */
  70 static int win_size;            /* terminal window size */
  71 static volatile sig_atomic_t win_resized; /* for window resizing */
  72
  73 /* units for format_size */
  74 static const char unit[] = " KMGT";
  75
  76 static int
  77 can_output(void)
  78 {
  79         return (getpgrp() == tcgetpgrp(STDOUT_FILENO));
  80 }
  81
  82 static void
  83 format_rate(char *buf, int size, off_t bytes)
  84 {
  85         int i;
  86
  87         bytes *= 100;
  88         for (i = 0; bytes >= 100*1000 && unit[i] != 'T'; i++)
  89                 bytes = (bytes + 512) / 1024;
  90         if (i == 0) {
  91                 i++;
  92                 bytes = (bytes + 512) / 1024;
  93         }
  94         snprintf(buf, size, "%3lld.%1lld%c%s",
  95             (long long) (bytes + 5) / 100,
  96             (long long) (bytes + 5) / 10 % 10,
  97             unit[i],
  98             i ? "B" : " ");
  99 }
 100
 101 static void
 102 format_size(char *buf, int size, off_t bytes)
 103 {
 104         int i;
 105
 106         for (i = 0; bytes >= 10000 && unit[i] != 'T'; i++)
 107                 bytes = (bytes + 512) / 1024;
 108         snprintf(buf, size, "%4lld%c%s",
 109             (long long) bytes,
 110             unit[i],
 111             i ? "B" : " ");
 112 }
 113
 114 void
 115 refresh_progress_meter(void)
 116 {
 117         char buf[MAX_WINSIZE + 1];
 118         time_t now;
 119         off_t transferred;
 120         double elapsed;
 121         int percent;
 122         off_t bytes_left;
 123         int cur_speed;
 124         int hours, minutes, seconds;
 125         int i, len;
 126         int file_len;
 127
 128         transferred = *counter - cur_pos;
 129         cur_pos = *counter;
 130         now = time(NULL);
 131         bytes_left = end_pos - cur_pos;
 132
 133         if (bytes_left > 0)
 134                 elapsed = now - last_update;
 135         else {
 136                 elapsed = now - start;
 137                 /* Calculate true total speed when done */
 138                 transferred = end_pos;
 139                 bytes_per_second = 0;
 140         }
 141
 142         /* calculate speed */
 143         if (elapsed != 0)
 144                 cur_speed = (transferred / elapsed);
 145         else
 146                 cur_speed = transferred;
 147
 148 #define AGE_FACTOR 0.9
 149         if (bytes_per_second != 0) {
 150                 bytes_per_second = (bytes_per_second * AGE_FACTOR) +
 151                     (cur_speed * (1.0 - AGE_FACTOR));
 152         } else
 153                 bytes_per_second = cur_speed;
 154
 155         /* filename */
 156         buf[0] = '\0';
 157         file_len = win_size - 35;
 158         if (file_len > 0) {
 159                 len = snprintf(buf, file_len + 1, "\r%s", file);
 160                 if (len < 0)
 161                         len = 0;
 162                 if (len >= file_len + 1)
 163                         len = file_len;
 164                 for (i = len;  i < file_len; i++ )
 165                         buf[i] = ' ';
 166                 buf[file_len] = '\0';
 167         }
 168
 169         /* percent of transfer done */
 170         if (end_pos != 0)
 171                 percent = ((float)cur_pos / end_pos) * 100;
 172         else
 173                 percent = 100;
 174         snprintf(buf + strlen(buf), win_size - strlen(buf),
 175             " %3d%% ", percent);
 176
 177         /* amount transferred */
 178         format_size(buf + strlen(buf), win_size - strlen(buf),
 179             cur_pos);
 180         strlcat(buf, " ", win_size);
 181
 182         /* bandwidth usage */
 183         format_rate(buf + strlen(buf), win_size - strlen(buf),
 184             (off_t)bytes_per_second);
 185         strlcat(buf, "/s ", win_size);
 186
 187         /* ETA */
 188         if (!transferred)
 189                 stalled += elapsed;
 190         else
 191                 stalled = 0;
 192
 193         if (stalled >= STALL_TIME)
 194                 strlcat(buf, "- stalled -", win_size);
 195         else if (bytes_per_second == 0 && bytes_left)
 196                 strlcat(buf, "  --:-- ETA", win_size);
 197         else {
 198                 if (bytes_left > 0)
 199                         seconds = bytes_left / bytes_per_second;
 200                 else
 201                         seconds = elapsed;
 202
 203                 hours = seconds / 3600;
 204                 seconds -= hours * 3600;
 205                 minutes = seconds / 60;
 206                 seconds -= minutes * 60;
 207
 208                 if (hours != 0)
 209                         snprintf(buf + strlen(buf), win_size - strlen(buf),
 210                             "%d:%02d:%02d", hours, minutes, seconds);
 211                 else
 212                         snprintf(buf + strlen(buf), win_size - strlen(buf),
 213                             "  %02d:%02d", minutes, seconds);
 214
 215                 if (bytes_left > 0)
 216                         strlcat(buf, " ETA", win_size);
 217                 else
 218                         strlcat(buf, "    ", win_size);
 219         }
 220
 221         atomicio(vwrite, STDOUT_FILENO, buf, win_size - 1);
 222         last_update = now;
 223 }
 224
 225 static void
 226 update_progress_meter(int ignore)
 227 {
 228         int save_errno;
 229
 230         save_errno = errno;
 231
 232         if (win_resized) {
 233                 setscreensize();
 234                 win_resized = 0;
 235         }
 236         if (can_output())
 237                 refresh_progress_meter();
 238
 239         signal(SIGALRM, update_progress_meter);
 240         alarm(UPDATE_INTERVAL);
 241         errno = save_errno;
 242 }
 243
 244 void
 245 start_progress_meter(char *f, off_t filesize, off_t *ctr)
 246 {
 247         start = last_update = time(NULL);
 248         file = f;
 249         end_pos = filesize;
 250         cur_pos = 0;
 251         counter = ctr;
 252         stalled = 0;
 253         bytes_per_second = 0;
 254
 255         setscreensize();
 256         if (can_output())
 257                 refresh_progress_meter();
 258
 259         signal(SIGALRM, update_progress_meter);
 260         signal(SIGWINCH, sig_winch);
 261         alarm(UPDATE_INTERVAL);
 262 }
 263
 264 void
 265 stop_progress_meter(void)
 266 {
 267         alarm(0);
 268
 269         if (!can_output())
 270                 return;
 271
 272         /* Ensure we complete the progress */
 273         if (cur_pos != end_pos)
 274                 refresh_progress_meter();
 275
 276         atomicio(vwrite, STDOUT_FILENO, "\n", 1);
 277 }
 278
 279 /*ARGSUSED*/
 280 static void
 281 sig_winch(int sig)
 282 {
 283         win_resized = 1;
 284 }
 285
 286 static void
 287 setscreensize(void)
 288 {
 289         struct winsize winsize;
 290
 291         if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize) != -1 &&
 292             winsize.ws_col != 0) {
 293                 if (winsize.ws_col > MAX_WINSIZE)
 294                         win_size = MAX_WINSIZE;
 295                 else
 296                         win_size = winsize.ws_col;
 297         } else
 298                 win_size = DEFAULT_WINSIZE;
 299         win_size += 1;                                  /* trailing \0 */
 300 }