src/bin/network/ftp/progressbar.c

   1 /*      $NetBSD: progressbar.c,v 1.7 2005/04/11 01:49:31 lukem Exp $    */
   2
   3 /*-
   4  * Copyright (c) 1997-2003 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Luke Mewburn.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the NetBSD
  21  *      Foundation, Inc. and its contributors.
  22  * 4. Neither the name of The NetBSD Foundation nor the names of its
  23  *    contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36  * POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 #include <sys/cdefs.h>
  40
  41 /*
  42  * FTP User Program -- Misc support routines
  43  */
  44 #include <sys/types.h>
  45 #include <sys/param.h>
  46 #include <sys/time.h>
  47
  48 #include <err.h>
  49 #include <errno.h>
  50 #include <signal.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <time.h>
  55 #include <unistd.h>
  56
  57 #include "progressbar.h"
  58
  59 #define SECSPERHOUR     (60 * 60)
  60 #define SECSPERDAY      ((long)60 * 60 * 24)
  61
  62 #if !defined(NO_PROGRESS)
  63 /*
  64  * return non-zero if we're the current foreground process
  65  */
  66 int
  67 foregroundproc(void)
  68 {
  69         static pid_t pgrp = -1;
  70
  71         if (pgrp == -1)
  72                 pgrp = getpgrp();
  73
  74         return (tcgetpgrp(fileno(ttyout)) == pgrp);
  75 }
  76 #endif  /* !defined(NO_PROGRESS) */
  77
  78
  79 static void updateprogressmeter(int);
  80
  81 /*
  82  * SIGALRM handler to update the progress meter
  83  */
  84 static void
  85 updateprogressmeter(int dummy)
  86 {
  87         int oerrno = errno;
  88
  89         progressmeter(0);
  90         errno = oerrno;
  91 }
  92
  93 /*
  94  * List of order of magnitude prefixes.
  95  * The last is `P', as 2^64 = 16384 Petabytes
  96  */
  97 static const char prefixes[] = " KMGTP";
  98
  99 /*
 100  * Display a transfer progress bar if progress is non-zero.
 101  * SIGALRM is hijacked for use by this function.
 102  * - Before the transfer, set filesize to size of file (or -1 if unknown),
 103  *   and call with flag = -1. This starts the once per second timer,
 104  *   and a call to updateprogressmeter() upon SIGALRM.
 105  * - During the transfer, updateprogressmeter will call progressmeter
 106  *   with flag = 0
 107  * - After the transfer, call with flag = 1
 108  */
 109 static struct timeval start;
 110 static struct timeval lastupdate;
 111
 112 #define BUFLEFT (sizeof(buf) - len)
 113
 114 void
 115 progressmeter(int flag)
 116 {
 117         static off_t lastsize;
 118         off_t cursize;
 119         struct timeval now, wait;
 120 #ifndef NO_PROGRESS
 121         struct timeval td;
 122         off_t abbrevsize, bytespersec;
 123         double elapsed;
 124         int ratio, barlength, i, remaining;
 125
 126                         /*
 127                          * Work variables for progress bar.
 128                          *
 129                          * XXX: if the format of the progress bar changes
 130                          *      (especially the number of characters in the
 131                          *      `static' portion of it), be sure to update
 132                          *      these appropriately.
 133                          */
 134 #endif
 135         int len;
 136         char            buf[256];       /* workspace for progress bar */
 137 #ifndef NO_PROGRESS
 138 #define BAROVERHEAD     43              /* non `*' portion of progress bar */
 139                                         /*
 140                                          * stars should contain at least
 141                                          * sizeof(buf) - BAROVERHEAD entries
 142                                          */
 143         static const char       stars[] =
 144 "*****************************************************************************"
 145 "*****************************************************************************"
 146 "*****************************************************************************";
 147
 148 #endif
 149
 150         if (flag == -1) {
 151                 (void)gettimeofday(&start, NULL);
 152                 lastupdate = start;
 153                 lastsize = restart_point;
 154         }
 155
 156         (void)gettimeofday(&now, NULL);
 157         cursize = bytes + restart_point;
 158         timersub(&now, &lastupdate, &wait);
 159         if (cursize > lastsize) {
 160                 lastupdate = now;
 161                 lastsize = cursize;
 162                 wait.tv_sec = 0;
 163         } else {
 164 #ifndef STANDALONE_PROGRESS
 165                 if (quit_time > 0 && wait.tv_sec > quit_time) {
 166                         len = snprintf(buf, sizeof(buf), "\r\n%s: "
 167                             "transfer aborted because stalled for %lu sec.\r\n",
 168                             getprogname(), (unsigned long)wait.tv_sec);
 169                         (void)write(fileno(ttyout), buf, len);
 170                         (void)xsignal(SIGALRM, SIG_DFL);
 171                         alarmtimer(0);
 172                         siglongjmp(toplevel, 1);
 173                 }
 174 #endif  /* !STANDALONE_PROGRESS */
 175         }
 176         /*
 177          * Always set the handler even if we are not the foreground process.
 178          */
 179 #ifdef STANDALONE_PROGRESS
 180         if (progress) {
 181 #else
 182         if (quit_time > 0 || progress) {
 183 #endif /* !STANDALONE_PROGRESS */
 184                 if (flag == -1) {
 185                         (void)xsignal_restart(SIGALRM, updateprogressmeter, 1);
 186                         alarmtimer(1);          /* set alarm timer for 1 Hz */
 187                 } else if (flag == 1) {
 188                         (void)xsignal(SIGALRM, SIG_DFL);
 189                         alarmtimer(0);
 190                 }
 191         }
 192 #ifndef NO_PROGRESS
 193         if (!progress)
 194                 return;
 195         len = 0;
 196
 197         /*
 198          * print progress bar only if we are foreground process.
 199          */
 200         if (! foregroundproc())
 201                 return;
 202
 203         len += snprintf(buf + len, BUFLEFT, "\r");
 204         if (prefix)
 205           len += snprintf(buf + len, BUFLEFT, "%s", prefix);
 206         if (filesize > 0) {
 207                 ratio = (int)((double)cursize * 100.0 / (double)filesize);
 208                 ratio = MAX(ratio, 0);
 209                 ratio = MIN(ratio, 100);
 210                 len += snprintf(buf + len, BUFLEFT, "%3d%% ", ratio);
 211
 212                         /*
 213                          * calculate the length of the `*' bar, ensuring that
 214                          * the number of stars won't exceed the buffer size
 215                          */
 216                 barlength = MIN(sizeof(buf) - 1, ttywidth) - BAROVERHEAD;
 217                 if (prefix)
 218                         barlength -= strlen(prefix);
 219                 if (barlength > 0) {
 220                         i = barlength * ratio / 100;
 221                         len += snprintf(buf + len, BUFLEFT,
 222                             "|%.*s%*s|", i, stars, barlength - i, "");
 223                 }
 224         }
 225
 226         abbrevsize = cursize;
 227         for (i = 0; abbrevsize >= 100000 && i < sizeof(prefixes); i++)
 228                 abbrevsize >>= 10;
 229         len += snprintf(buf + len, BUFLEFT, " " LLFP("5") " %c%c ",
 230             (LLT)abbrevsize,
 231             prefixes[i],
 232             i == 0 ? ' ' : 'B');
 233
 234         timersub(&now, &start, &td);
 235         elapsed = td.tv_sec + (td.tv_usec / 1000000.0);
 236
 237         bytespersec = 0;
 238         if (bytes > 0) {
 239                 bytespersec = bytes;
 240                 if (elapsed > 0.0)
 241                         bytespersec /= elapsed;
 242         }
 243         for (i = 1; bytespersec >= 1024000 && i < sizeof(prefixes); i++)
 244                 bytespersec >>= 10;
 245         len += snprintf(buf + len, BUFLEFT,
 246             " " LLFP("3") ".%02d %cB/s ",
 247             (LLT)(bytespersec / 1024),
 248             (int)((bytespersec % 1024) * 100 / 1024),
 249             prefixes[i]);
 250
 251         if (filesize > 0) {
 252                 if (bytes <= 0 || elapsed <= 0.0 || cursize > filesize) {
 253                         len += snprintf(buf + len, BUFLEFT, "   --:-- ETA");
 254                 } else if (wait.tv_sec >= STALLTIME) {
 255                         len += snprintf(buf + len, BUFLEFT, " - stalled -");
 256                 } else {
 257                         remaining = (int)
 258                             ((filesize - restart_point) / (bytes / elapsed) -
 259                             elapsed);
 260                         if (remaining >= 100 * SECSPERHOUR)
 261                                 len += snprintf(buf + len, BUFLEFT,
 262                                     "   --:-- ETA");
 263                         else {
 264                                 i = remaining / SECSPERHOUR;
 265                                 if (i)
 266                                         len += snprintf(buf + len, BUFLEFT,
 267                                             "%2d:", i);
 268                                 else
 269                                         len += snprintf(buf + len, BUFLEFT,
 270                                             "   ");
 271                                 i = remaining % SECSPERHOUR;
 272                                 len += snprintf(buf + len, BUFLEFT,
 273                                     "%02d:%02d ETA", i / 60, i % 60);
 274                         }
 275                 }
 276         }
 277         if (flag == 1)
 278                 len += snprintf(buf + len, BUFLEFT, "\n");
 279         (void)write(fileno(ttyout), buf, len);
 280
 281 #endif  /* !NO_PROGRESS */
 282 }
 283
 284 #ifndef STANDALONE_PROGRESS
 285 /*
 286  * Display transfer statistics.
 287  * Requires start to be initialised by progressmeter(-1),
 288  * direction to be defined by xfer routines, and filesize and bytes
 289  * to be updated by xfer routines
 290  * If siginfo is nonzero, an ETA is displayed, and the output goes to stderr
 291  * instead of ttyout.
 292  */
 293 void
 294 ptransfer(int siginfo)
 295 {
 296         struct timeval now, td, wait;
 297         double elapsed;
 298         off_t bytespersec;
 299         int remaining, hh, i, len;
 300
 301         char buf[256];          /* Work variable for transfer status. */
 302
 303         if (!verbose && !progress && !siginfo)
 304                 return;
 305
 306         (void)gettimeofday(&now, NULL);
 307         timersub(&now, &start, &td);
 308         elapsed = td.tv_sec + (td.tv_usec / 1000000.0);
 309         bytespersec = 0;
 310         if (bytes > 0) {
 311                 bytespersec = bytes;
 312                 if (elapsed > 0.0)
 313                         bytespersec /= elapsed;
 314         }
 315         len = 0;
 316         len += snprintf(buf + len, BUFLEFT, LLF " byte%s %s in ",
 317             (LLT)bytes, bytes == 1 ? "" : "s", direction);
 318         remaining = (int)elapsed;
 319         if (remaining > SECSPERDAY) {
 320                 int days;
 321
 322                 days = remaining / SECSPERDAY;
 323                 remaining %= SECSPERDAY;
 324                 len += snprintf(buf + len, BUFLEFT,
 325                     "%d day%s ", days, days == 1 ? "" : "s");
 326         }
 327         hh = remaining / SECSPERHOUR;
 328         remaining %= SECSPERHOUR;
 329         if (hh)
 330                 len += snprintf(buf + len, BUFLEFT, "%2d:", hh);
 331         len += snprintf(buf + len, BUFLEFT,
 332             "%02d:%02d ", remaining / 60, remaining % 60);
 333
 334         for (i = 1; bytespersec >= 1024000 && i < sizeof(prefixes); i++)
 335                 bytespersec >>= 10;
 336         len += snprintf(buf + len, BUFLEFT, "(" LLF ".%02d %cB/s)",
 337             (LLT)(bytespersec / 1024),
 338             (int)((bytespersec % 1024) * 100 / 1024),
 339             prefixes[i]);
 340
 341         if (siginfo && bytes > 0 && elapsed > 0.0 && filesize >= 0
 342             && bytes + restart_point <= filesize) {
 343                 remaining = (int)((filesize - restart_point) /
 344                                   (bytes / elapsed) - elapsed);
 345                 hh = remaining / SECSPERHOUR;
 346                 remaining %= SECSPERHOUR;
 347                 len += snprintf(buf + len, BUFLEFT, "  ETA: ");
 348                 if (hh)
 349                         len += snprintf(buf + len, BUFLEFT, "%2d:", hh);
 350                 len += snprintf(buf + len, BUFLEFT, "%02d:%02d",
 351                     remaining / 60, remaining % 60);
 352                 timersub(&now, &lastupdate, &wait);
 353                 if (wait.tv_sec >= STALLTIME)
 354                         len += snprintf(buf + len, BUFLEFT, "  (stalled)");
 355         }
 356         len += snprintf(buf + len, BUFLEFT, "\n");
 357         (void)write(siginfo ? STDERR_FILENO : fileno(ttyout), buf, len);
 358 }
 359
 360 /*
 361  * SIG{INFO,QUIT} handler to print transfer stats if a transfer is in progress
 362  */
 363 void
 364 psummary(int notused)
 365 {
 366         int oerrno = errno;
 367
 368         if (bytes > 0) {
 369                 if (fromatty)
 370                         write(fileno(ttyout), "\n", 1);
 371                 ptransfer(1);
 372         }
 373         errno = oerrno;
 374 }
 375 #endif  /* !STANDALONE_PROGRESS */
 376
 377
 378 /*
 379  * Set the SIGALRM interval timer for wait seconds, 0 to disable.
 380  */
 381 void
 382 alarmtimer(int wait)
 383 {
 384         struct itimerval itv;
 385
 386         itv.it_value.tv_sec = wait;
 387         itv.it_value.tv_usec = 0;
 388         itv.it_interval = itv.it_value;
 389         setitimer(ITIMER_REAL, &itv, NULL);
 390 }
 391
 392
 393 /*
 394  * Install a POSIX signal handler, allowing the invoker to set whether
 395  * the signal should be restartable or not
 396  */
 397 sigfunc
 398 xsignal_restart(int sig, sigfunc func, int restartable)
 399 {
 400         struct sigaction act, oact;
 401         act.sa_handler = func;
 402
 403         sigemptyset(&act.sa_mask);
 404 #if defined(SA_RESTART)                 /* 4.4BSD, Posix(?), SVR4 */
 405         act.sa_flags = restartable ? SA_RESTART : 0;
 406 #elif defined(SA_INTERRUPT)             /* SunOS 4.x */
 407         act.sa_flags = restartable ? 0 : SA_INTERRUPT;
 408 #else
 409 #error "system must have SA_RESTART or SA_INTERRUPT"
 410 #endif
 411         if (sigaction(sig, &act, &oact) < 0)
 412                 return (SIG_ERR);
 413         return (oact.sa_handler);
 414 }
 415
 416 /*
 417  * Install a signal handler with the `restartable' flag set dependent upon
 418  * which signal is being set. (This is a wrapper to xsignal_restart())
 419  */
 420 sigfunc
 421 xsignal(int sig, sigfunc func)
 422 {
 423         int restartable;
 424
 425         /*
 426          * Some signals print output or change the state of the process.
 427          * There should be restartable, so that reads and writes are
 428          * not affected.  Some signals should cause program flow to change;
 429          * these signals should not be restartable, so that the system call
 430          * will return with EINTR, and the program will go do something
 431          * different.  If the signal handler calls longjmp() or siglongjmp(),
 432          * it doesn't matter if it's restartable.
 433          */
 434
 435         switch(sig) {
 436 #ifdef SIGINFO
 437         case SIGINFO:
 438 #endif
 439         case SIGQUIT:
 440         case SIGUSR1:
 441         case SIGUSR2:
 442         case SIGWINCH:
 443                 restartable = 1;
 444                 break;
 445
 446         case SIGALRM:
 447         case SIGINT:
 448         case SIGPIPE:
 449                 restartable = 0;
 450                 break;
 451
 452         default:
 453                 /*
 454                  * This is unpleasant, but I don't know what would be better.
 455                  * Right now, this "can't happen"
 456                  */
 457                 errx(1, "xsignal_restart called with signal %d", sig);
 458         }
 459
 460         return(xsignal_restart(sig, func, restartable));
 461 }