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