lib/libdpv/dpv.c

   1 /*-
   2  * Copyright (c) 2013-2014 Devin Teske <dteske@FreeBSD.org>
   3  * 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 AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/stat.h>
  31 #include <sys/time.h>
  32 #include <sys/types.h>
  33 #include <sys/wait.h>
  34
  35 #include <ctype.h>
  36 #include <dialog.h>
  37 #include <err.h>
  38 #include <limits.h>
  39 #include <locale.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <string_m.h>
  44 #include <unistd.h>
  45
  46 #include "dialog_util.h"
  47 #include "dialogrc.h"
  48 #include "dprompt.h"
  49 #include "dpv.h"
  50 #include "dpv_private.h"
  51 #include "status.h"
  52 #include "util.h"
  53
  54 /* Test Mechanics (Only used when dpv_config.options |= DPV_TEST_MODE) */
  55 #define INCREMENT               1       /* Increment % per-pass test-mode */
  56 #define XDIALOG_INCREMENT       15      /* different for slower Xdialog(1) */
  57 static uint8_t increment = INCREMENT;
  58
  59 /* Debugging */
  60 uint8_t debug = FALSE;
  61
  62 /* Data to process */
  63 int dpv_interrupt = FALSE;
  64 int dpv_abort = FALSE;
  65 unsigned int dpv_nfiles = 0;
  66
  67 /* Data processing */
  68 long long dpv_overall_read = 0;
  69 static char pathbuf[PATH_MAX];
  70
  71 /* Extra display information */
  72 uint8_t no_labels = FALSE;      /* dpv_config.options & DPV_NO_LABELS */
  73 uint8_t wide = FALSE;           /* dpv_config.options & DPV_WIDE_MODE */
  74 char *aprompt = NULL;           /* dpv_config.aprompt */
  75 char *msg_done = NULL;          /* dpv_config.msg_done */
  76 char *msg_fail = NULL;          /* dpv_config.msg_fail */
  77 char *msg_pending = NULL;       /* dpv_config.msg_pending */
  78 char *pprompt = NULL;           /* dpv_config.pprompt */
  79
  80 /* Status-Line format for when using dialog(3) */
  81 static const char *status_format_custom = NULL;
  82 static char status_format_default[DPV_STATUS_FORMAT_MAX];
  83
  84 /*
  85  * Takes a pointer to a dpv_config structure containing layout details and
  86  * pointer to initial element in a linked-list of dpv_file_node structures,
  87  * each presenting a file to process. Executes the `action' function passed-in
  88  * as a member to the `config' structure argument.
  89  */
  90 int
  91 dpv(struct dpv_config *config, struct dpv_file_node *file_list)
  92 {
  93         char c;
  94         uint8_t keep_going;
  95         uint8_t nls = FALSE; /* See dialog_prompt_nlstate() */
  96         uint8_t no_overrun = FALSE;
  97         uint8_t pprompt_nls = FALSE; /* See dialog_prompt_nlstate() */
  98         uint8_t shrink_label_size = FALSE;
  99         mode_t mask;
 100         uint16_t options;
 101         char *cp;
 102         char *fc;
 103         char *last;
 104         char *name;
 105         char *output;
 106         const char *status_fmt;
 107         const char *path_fmt;
 108         enum dpv_display display_type;
 109         enum dpv_output output_type;
 110         enum dpv_status status;
 111         int (*action)(struct dpv_file_node *file, int out);
 112         int backslash;
 113         int dialog_last_update = 0;
 114         int dialog_old_nthfile = 0;
 115         int dialog_old_seconds = -1;
 116         int dialog_out = STDOUT_FILENO;
 117         int dialog_update_usec = 0;
 118         int dialog_updates_per_second;
 119         int files_left;
 120         int max_cols;
 121         int nthfile = 0;
 122         int output_out;
 123         int overall = 0;
 124         int pct;
 125         int res;
 126         int seconds;
 127         int status_last_update = 0;
 128         int status_old_nthfile = 0;
 129         int status_old_seconds = -1;
 130         int status_update_usec = 0;
 131         int status_updates_per_second;
 132         pid_t output_pid;
 133         pid_t pid;
 134         size_t len;
 135         struct dpv_file_node *curfile;
 136         struct dpv_file_node *first_file;
 137         struct dpv_file_node *list_head;
 138         struct timeval now;
 139         struct timeval start;
 140         char init_prompt[PROMPT_MAX + 1] = "";
 141
 142         /* Initialize globals to default values */
 143         aprompt         = NULL;
 144         pprompt         = NULL;
 145         options         = 0;
 146         action          = NULL;
 147         backtitle       = NULL;
 148         debug           = FALSE;
 149         dialog_test     = FALSE;
 150         dialog_updates_per_second = DIALOG_UPDATES_PER_SEC;
 151         display_limit   = DISPLAY_LIMIT_DEFAULT;
 152         display_type    = DPV_DISPLAY_LIBDIALOG;
 153         label_size      = LABEL_SIZE_DEFAULT;
 154         msg_done        = NULL;
 155         msg_fail        = NULL;
 156         msg_pending     = NULL;
 157         no_labels       = FALSE;
 158         output          = NULL;
 159         output_type     = DPV_OUTPUT_NONE;
 160         pbar_size       = PBAR_SIZE_DEFAULT;
 161         status_format_custom = NULL;
 162         status_updates_per_second = STATUS_UPDATES_PER_SEC;
 163         title           = NULL;
 164         wide            = FALSE;
 165
 166         /* Process config options (overriding defaults) */
 167         if (config != NULL) {
 168                 if (config->aprompt != NULL) {
 169                         if (aprompt == NULL) {
 170                                 aprompt = malloc(DPV_APROMPT_MAX);
 171                                 if (aprompt == NULL)
 172                                         return (-1);
 173                         }
 174                         snprintf(aprompt, DPV_APROMPT_MAX, "%s",
 175                             config->aprompt);
 176                 }
 177                 if (config->pprompt != NULL) {
 178                         if (pprompt == NULL) {
 179                                 pprompt = malloc(DPV_PPROMPT_MAX + 2);
 180                                 /* +2 is for implicit "\n" appended later */
 181                                 if (pprompt == NULL)
 182                                         return (-1);
 183                         }
 184                         snprintf(pprompt, DPV_APROMPT_MAX, "%s",
 185                             config->pprompt);
 186                 }
 187
 188                 options         = config->options;
 189                 action          = config->action;
 190                 backtitle       = config->backtitle;
 191                 debug           = config->debug;
 192                 dialog_test     = ((options & DPV_TEST_MODE) != 0);
 193                 dialog_updates_per_second = config->dialog_updates_per_second;
 194                 display_limit   = config->display_limit;
 195                 display_type    = config->display_type;
 196                 label_size      = config->label_size;
 197                 msg_done        = (char *)config->msg_done;
 198                 msg_fail        = (char *)config->msg_fail;
 199                 msg_pending     = (char *)config->msg_pending;
 200                 no_labels       = ((options & DPV_NO_LABELS) != 0);
 201                 no_overrun      = ((options & DPV_NO_OVERRUN) != 0);
 202                 output          = config->output;
 203                 output_type     = config->output_type;
 204                 pbar_size       = config->pbar_size;
 205                 status_updates_per_second = config->status_updates_per_second;
 206                 title           = config->title;
 207                 wide            = ((options & DPV_WIDE_MODE) != 0);
 208
 209                 /* Enforce some minimums (pedantic) */
 210                 if (display_limit < -1)
 211                         display_limit = -1;
 212                 if (label_size < -1)
 213                         label_size = -1;
 214                 if (pbar_size < -1)
 215                         pbar_size = -1;
 216
 217                 /* For the mini-pbar, -1 means hide, zero is invalid unless
 218                  * only one file is given */
 219                 if (pbar_size == 0) {
 220                         if (file_list == NULL || file_list->next == NULL)
 221                                 pbar_size = -1;
 222                         else
 223                                 pbar_size = PBAR_SIZE_DEFAULT;
 224                 }
 225
 226                 /* For the label, -1 means auto-size, zero is invalid unless
 227                  * specifically requested through the use of options flag */
 228                 if (label_size == 0 && no_labels == FALSE)
 229                         label_size = LABEL_SIZE_DEFAULT;
 230
 231                 /* Status update should not be zero */
 232                 if (status_updates_per_second == 0)
 233                         status_updates_per_second = STATUS_UPDATES_PER_SEC;
 234         } /* config != NULL */
 235
 236         /* Process the type of display we've been requested to produce */
 237         switch (display_type) {
 238         case DPV_DISPLAY_STDOUT:
 239                 debug           = TRUE;
 240                 use_color       = FALSE;
 241                 use_dialog      = FALSE;
 242                 use_libdialog   = FALSE;
 243                 use_xdialog     = FALSE;
 244                 break;
 245         case DPV_DISPLAY_DIALOG:
 246                 use_color       = TRUE;
 247                 use_dialog      = TRUE;
 248                 use_libdialog   = FALSE;
 249                 use_xdialog     = FALSE;
 250                 break;
 251         case DPV_DISPLAY_XDIALOG:
 252                 snprintf(dialog, PATH_MAX, XDIALOG);
 253                 use_color       = FALSE;
 254                 use_dialog      = FALSE;
 255                 use_libdialog   = FALSE;
 256                 use_xdialog     = TRUE;
 257                 break;
 258         default:
 259                 use_color       = TRUE;
 260                 use_dialog      = FALSE;
 261                 use_libdialog   = TRUE;
 262                 use_xdialog     = FALSE;
 263                 break;
 264         } /* display_type */
 265
 266         /* Enforce additional minimums that require knowing our display type */
 267         if (dialog_updates_per_second == 0)
 268                 dialog_updates_per_second = use_xdialog ?
 269                         XDIALOG_UPDATES_PER_SEC : DIALOG_UPDATES_PER_SEC;
 270
 271         /* Allow forceful override of use_color */
 272         if (config != NULL && (config->options & DPV_USE_COLOR) != 0)
 273                 use_color = TRUE;
 274
 275         /* Count the number of files in provided list of dpv_file_node's */
 276         if (use_dialog && pprompt != NULL && *pprompt != '\0')
 277                 pprompt_nls = dialog_prompt_nlstate(pprompt);
 278
 279         max_cols = dialog_maxcols();
 280         if (label_size == -1)
 281                 shrink_label_size = TRUE;
 282
 283         /* Process file arguments */
 284         for (curfile = file_list; curfile != NULL; curfile = curfile->next) {
 285                 dpv_nfiles++;
 286
 287                 /* dialog(3) only expands literal newlines */
 288                 if (use_libdialog) strexpandnl(curfile->name);
 289
 290                 /* Optionally calculate label size for file */
 291                 if (shrink_label_size) {
 292                         nls = FALSE;
 293                         name = curfile->name;
 294                         if (curfile == file_list)
 295                                 nls = pprompt_nls;
 296                         last = (char *)dialog_prompt_lastline(name, nls);
 297                         if (use_dialog) {
 298                                 c = *last;
 299                                 *last = '\0';
 300                                 nls = dialog_prompt_nlstate(name);
 301                                 *last = c;
 302                         }
 303                         len = dialog_prompt_longestline(last, nls);
 304                         if ((int)len > (label_size - 3)) {
 305                                 if (label_size > 0)
 306                                         label_size += 3;
 307                                 label_size = len;
 308                                 /* Room for ellipsis (unless NULL) */
 309                                 if (label_size > 0)
 310                                         label_size += 3;
 311                         }
 312
 313                         if (max_cols > 0 && label_size > (max_cols - pbar_size
 314                             - 9))
 315                                 label_size = max_cols - pbar_size - 9;
 316                 }
 317
 318                 if (debug)
 319                         warnx("label=[%s] path=[%s] size=%lli",
 320                             curfile->name, curfile->path, curfile->length);
 321         } /* file_list */
 322
 323         /* Optionally process the contents of DIALOGRC (~/.dialogrc) */
 324         if (use_dialog) {
 325                 res = parse_dialogrc();
 326                 if (debug && res == 0) {
 327                         warnx("Successfully read `%s' config file", DIALOGRC);
 328                         warnx("use_shadow = %i (Boolean)", use_shadow);
 329                         warnx("use_colors = %i (Boolean)", use_colors);
 330                         warnx("gauge_color=[%s] (FBH)", gauge_color);
 331                 }
 332         } else if (use_libdialog) {
 333                 init_dialog(stdin, stdout);
 334                 use_shadow = dialog_state.use_shadow;
 335                 use_colors = dialog_state.use_colors;
 336                 gauge_color[0] = 48 + dlg_color_table[GAUGE_ATTR].fg;
 337                 gauge_color[1] = 48 + dlg_color_table[GAUGE_ATTR].bg;
 338                 gauge_color[2] = dlg_color_table[GAUGE_ATTR].hilite ?
 339                     'b' : 'B';
 340                 gauge_color[3] = '\0';
 341                 end_dialog();
 342                 if (debug) {
 343                         warnx("Finished initializing dialog(3) library");
 344                         warnx("use_shadow = %i (Boolean)", use_shadow);
 345                         warnx("use_colors = %i (Boolean)", use_colors);
 346                         warnx("gauge_color=[%s] (FBH)", gauge_color);
 347                 }
 348         }
 349
 350         /* Enable mini progress bar automatically for stdin streams if unable
 351          * to calculate progress (missing `lines:' syntax). */
 352         if (dpv_nfiles <= 1 && file_list != NULL && file_list->length < 0 &&
 353             !dialog_test)
 354                 pbar_size = PBAR_SIZE_DEFAULT;
 355
 356         /* If $USE_COLOR is set and non-NULL enable color; otherwise disable */
 357         if ((cp = getenv(ENV_USE_COLOR)) != 0)
 358                 use_color = *cp != '\0' ? 1 : 0;
 359
 360         /* Print error and return `-1' if not given at least one name */
 361         if (dpv_nfiles == 0) {
 362                 warnx("%s: no labels provided", __func__);
 363                 return (-1);
 364         } else if (debug)
 365                 warnx("%s: %u label%s provided", __func__, dpv_nfiles,
 366                     dpv_nfiles == 1 ? "" : "s");
 367
 368         /* If only one file and pbar size is zero, default to `-1' */
 369         if (dpv_nfiles <= 1 && pbar_size == 0)
 370                 pbar_size = -1;
 371
 372         /* Print some debugging information */
 373         if (debug) {
 374                 warnx("%s: %s(%i) max rows x cols = %i x %i",
 375                     __func__, use_xdialog ? XDIALOG : DIALOG,
 376                     use_libdialog ? 3 : 1, dialog_maxrows(),
 377                     dialog_maxcols());
 378         }
 379
 380         /* Xdialog(1) updates a lot slower than dialog(1) */
 381         if (dialog_test && use_xdialog)
 382                 increment = XDIALOG_INCREMENT;
 383
 384         /* Always add implicit newline to pprompt (when specified) */
 385         if (pprompt != NULL && *pprompt != '\0') {
 386                 len = strlen(pprompt);
 387                 /*
 388                  * NOTE: pprompt = malloc(PPROMPT_MAX + 2)
 389                  * NOTE: (see getopt(2) section above for pprompt allocation)
 390                  */
 391                 pprompt[len++] = '\\';
 392                 pprompt[len++] = 'n';
 393                 pprompt[len++] = '\0';
 394         }
 395
 396         /* Xdialog(1) requires newlines (a) escaped and (b) in triplicate */
 397         if (use_xdialog && pprompt != NULL) {
 398                 /* Replace `\n' with `\n\\n\n' in pprompt */
 399                 len = strlen(pprompt);
 400                 len += strcount(pprompt, "\\n") * 2;
 401                 if (len > DPV_PPROMPT_MAX)
 402                         errx(EXIT_FAILURE, "%s: Oops, pprompt buffer overflow "
 403                             "(%zu > %i)", __func__, len, DPV_PPROMPT_MAX);
 404                 if (replaceall(pprompt, "\\n", "\n\\n\n") < 0)
 405                         err(EXIT_FAILURE, "%s: replaceall()", __func__);
 406         }
 407         /* libdialog requires literal newlines */
 408         else if (use_libdialog && pprompt != NULL)
 409                 strexpandnl(pprompt);
 410
 411         /* Xdialog(1) requires newlines (a) escaped and (b) in triplicate */
 412         if (use_xdialog && aprompt != NULL) {
 413                 /* Replace `\n' with `\n\\n\n' in aprompt */
 414                 len = strlen(aprompt);
 415                 len += strcount(aprompt, "\\n") * 2;
 416                 if (len > DPV_APROMPT_MAX)
 417                         errx(EXIT_FAILURE, "%s: Oops, aprompt buffer overflow "
 418                             " (%zu > %i)", __func__, len, DPV_APROMPT_MAX);
 419                 if (replaceall(aprompt, "\\n", "\n\\n\n") < 0)
 420                         err(EXIT_FAILURE, "%s: replaceall()", __func__);
 421         }
 422         /* libdialog requires literal newlines */
 423         else if (use_libdialog && aprompt != NULL)
 424                 strexpandnl(aprompt);
 425
 426         /*
 427          * Warn user about an obscure dialog(1) bug (neither Xdialog(1) nor
 428          * libdialog are affected) in the `--gauge' widget. If the first non-
 429          * whitespace letter of "{new_prompt}" in "XXX\n{new_prompt}\nXXX\n"
 430          * is a number, the number can sometimes be mistaken for a percentage
 431          * to the overall progressbar. Other nasty side-effects such as the
 432          * entire prompt not displaying or displaying improperly are caused by
 433          * this bug too.
 434          *
 435          * NOTE: When we can use color, we have a work-around... prefix the
 436          * output with `\Zn' (used to terminate ANSI and reset to normal).
 437          */
 438         if (use_dialog && !use_color) {
 439                 backslash = 0;
 440
 441                 /* First, check pprompt (falls through if NULL) */
 442                 fc = pprompt;
 443                 while (fc != NULL && *fc != '\0') {
 444                         if (*fc == '\n') /* leading literal newline OK */
 445                                 break;
 446                         if (!isspace(*fc) && *fc != '\\' && backslash == 0)
 447                                 break;
 448                         else if (backslash > 0 && *fc != 'n')
 449                                 break;
 450                         else if (*fc == '\\') {
 451                                 backslash++;
 452                                 if (backslash > 2)
 453                                         break; /* we're safe */
 454                         }
 455                         fc++;
 456                 }
 457                 /* First non-whitespace character that dialog(1) will see */
 458                 if (fc != NULL && *fc >= '0' && *fc <= '9')
 459                         warnx("%s: WARNING! text argument to `-p' begins with "
 460                             "a number (not recommended)", __func__);
 461                 else if (fc > pprompt)
 462                         warnx("%s: WARNING! text argument to `-p' begins with "
 463                             "whitespace (not recommended)", __func__);
 464
 465                 /*
 466                  * If no pprompt or pprompt is all whitespace, check the first
 467                  * file name provided to make sure it is alright too.
 468                  */
 469                 if ((pprompt == NULL || *fc == '\0') && file_list != NULL) {
 470                         first_file = file_list;
 471                         fc = first_file->name;
 472                         while (fc != NULL && *fc != '\0' && isspace(*fc))
 473                                 fc++;
 474                         /* First non-whitespace char that dialog(1) will see */
 475                         if (fc != NULL && *fc >= '0' && *fc <= '9')
 476                                 warnx("%s: WARNING! File name `%s' begins "
 477                                     "with a number (use `-p text' for safety)",
 478                                     __func__, first_file->name);
 479                 }
 480         }
 481
 482         dprompt_init(file_list);
 483                 /* Reads: label_size pbar_size pprompt aprompt dpv_nfiles */
 484                 /* Inits: dheight and dwidth */
 485
 486         /* Default localeconv(3) settings for dialog(3) status */
 487         setlocale(LC_NUMERIC,
 488                 getenv("LC_ALL") == NULL && getenv("LC_NUMERIC") == NULL ?
 489                 LC_NUMERIC_DEFAULT : "");
 490
 491         if (!debug) {
 492                 /* Internally create the initial `--gauge' prompt text */
 493                 dprompt_recreate(file_list, (struct dpv_file_node *)NULL, 0);
 494
 495                 /* Spawn [X]dialog(1) `--gauge', returning pipe descriptor */
 496                 if (use_libdialog) {
 497                         status_printf("");
 498                         dprompt_libprint(pprompt, aprompt, 0);
 499                 } else {
 500                         dprompt_sprint(init_prompt, pprompt, aprompt);
 501                         dialog_out = dialog_spawn_gauge(init_prompt, &pid);
 502                         dprompt_dprint(dialog_out, pprompt, aprompt, 0);
 503                 }
 504         } /* !debug */
 505
 506         /* Seed the random(3) generator */
 507         if (dialog_test)
 508                 srandom(0xf1eeface);
 509
 510         /* Set default/custom status line format */
 511         if (dpv_nfiles > 1) {
 512                 snprintf(status_format_default, DPV_STATUS_FORMAT_MAX, "%s",
 513                     DPV_STATUS_MANY);
 514                 status_format_custom = config->status_many;
 515         } else {
 516                 snprintf(status_format_default, DPV_STATUS_FORMAT_MAX, "%s",
 517                     DPV_STATUS_SOLO);
 518                 status_format_custom = config->status_solo;
 519         }
 520
 521         /* Add test mode identifier to default status line if enabled */
 522         if (dialog_test && (strlen(status_format_default) + 12) <
 523             DPV_STATUS_FORMAT_MAX)
 524                 strcat(status_format_default, " [TEST MODE]");
 525
 526         /* Verify custom status format */
 527         status_fmt = fmtcheck(status_format_custom, status_format_default);
 528         if (status_format_custom != NULL &&
 529             status_fmt == status_format_default) {
 530                 warnx("WARNING! Invalid status_format configuration `%s'",
 531                       status_format_custom);
 532                 warnx("Default status_format `%s'", status_format_default);
 533         }
 534
 535         /* Record when we started (used to prevent updating too quickly) */
 536         (void)gettimeofday(&start, (struct timezone *)NULL);
 537
 538         /* Calculate number of microseconds in-between sub-second updates */
 539         if (status_updates_per_second != 0)
 540                 status_update_usec = 1000000 / status_updates_per_second;
 541         if (dialog_updates_per_second != 0)
 542                 dialog_update_usec = 1000000 / dialog_updates_per_second;
 543
 544         /*
 545          * Process the file list [serially] (one for each argument passed)
 546          */
 547         files_left = dpv_nfiles;
 548         list_head = file_list;
 549         for (curfile = file_list; curfile != NULL; curfile = curfile->next) {
 550                 keep_going = TRUE;
 551                 output_out = -1;
 552                 pct = 0;
 553                 nthfile++;
 554                 files_left--;
 555
 556                 if (dpv_interrupt)
 557                         break;
 558                 if (dialog_test)
 559                         pct = 0 - increment;
 560
 561                 /* Attempt to spawn output program for this file */
 562                 if (!dialog_test && output != NULL) {
 563                         mask = umask(0022);
 564                         (void)umask(mask);
 565
 566                         switch (output_type) {
 567                         case DPV_OUTPUT_SHELL:
 568                                 output_out = shell_spawn_pipecmd(output,
 569                                     curfile->name, &output_pid);
 570                                 break;
 571                         case DPV_OUTPUT_FILE:
 572                                 path_fmt = fmtcheck(output, "%s");
 573                                 if (path_fmt == output)
 574                                         len = snprintf(pathbuf,
 575                                             PATH_MAX, output, curfile->name);
 576                                 else
 577                                         len = snprintf(pathbuf,
 578                                             PATH_MAX, "%s", output);
 579                                 if (len >= PATH_MAX) {
 580                                         warnx("%s:%d:%s: pathbuf[%u] too small"
 581                                             "to hold output argument",
 582                                             __FILE__, __LINE__, __func__,
 583                                             PATH_MAX);
 584                                         return (-1);
 585                                 }
 586                                 if ((output_out = open(pathbuf,
 587                                     O_CREAT|O_WRONLY, DEFFILEMODE & ~mask))
 588                                     < 0) {
 589                                         warn("%s", pathbuf);
 590                                         return (-1);
 591                                 }
 592                                 break;
 593                         default:
 594                                 break;
 595                         }
 596                 }
 597
 598                 while (!dpv_interrupt && keep_going) {
 599                         if (dialog_test) {
 600                                 usleep(50000);
 601                                 pct += increment;
 602                                 dpv_overall_read +=
 603                                     (int)(random() / 512 / dpv_nfiles);
 604                                     /* 512 limits fake readout to Megabytes */
 605                         } else if (action != NULL)
 606                                 pct = action(curfile, output_out);
 607
 608                         if (no_overrun || dialog_test)
 609                                 keep_going = (pct < 100);
 610                         else {
 611                                 status = curfile->status;
 612                                 keep_going = (status == DPV_STATUS_RUNNING);
 613                         }
 614
 615                         /* Get current time and calculate seconds elapsed */
 616                         gettimeofday(&now, (struct timezone *)NULL);
 617                         now.tv_sec = now.tv_sec - start.tv_sec;
 618                         now.tv_usec = now.tv_usec - start.tv_usec;
 619                         if (now.tv_usec < 0)
 620                                 now.tv_sec--, now.tv_usec += 1000000;
 621                         seconds = now.tv_sec + (now.tv_usec / 1000000.0);
 622
 623                         /* Update dialog (be it dialog(3), dialog(1), etc.) */
 624                         if ((dialog_updates_per_second != 0 &&
 625                            (
 626                             seconds != dialog_old_seconds ||
 627                             now.tv_usec - dialog_last_update >=
 628                                 dialog_update_usec ||
 629                             nthfile != dialog_old_nthfile
 630                            )) || pct == 100
 631                         ) {
 632                                 /* Calculate overall progress (rounding up) */
 633                                 overall = (100 * nthfile - 100 + pct) /
 634                                     dpv_nfiles;
 635                                 if (((100 * nthfile - 100 + pct) * 10 /
 636                                     dpv_nfiles % 100) > 50)
 637                                         overall++;
 638
 639                                 dprompt_recreate(list_head, curfile, pct);
 640
 641                                 if (use_libdialog && !debug) {
 642                                         /* Update dialog(3) widget */
 643                                         dprompt_libprint(pprompt, aprompt,
 644                                             overall);
 645                                 } else {
 646                                         /* stdout, dialog(1), or Xdialog(1) */
 647                                         dprompt_dprint(dialog_out, pprompt,
 648                                             aprompt, overall);
 649                                         fsync(dialog_out);
 650                                 }
 651                                 dialog_old_seconds = seconds;
 652                                 dialog_old_nthfile = nthfile;
 653                                 dialog_last_update = now.tv_usec;
 654                         }
 655
 656                         /* Update the status line */
 657                         if ((use_libdialog && !debug) &&
 658                             status_updates_per_second != 0 &&
 659                            (
 660                             keep_going != TRUE ||
 661                             seconds != status_old_seconds ||
 662                             now.tv_usec - status_last_update >=
 663                                 status_update_usec ||
 664                             nthfile != status_old_nthfile
 665                            )
 666                         ) {
 667                                 status_printf(status_fmt, dpv_overall_read,
 668                                     (dpv_overall_read / (seconds == 0 ? 1 :
 669                                         seconds) * 1.0),
 670                                     1, /* XXX until we add parallelism XXX */
 671                                     files_left);
 672                                 status_old_seconds = seconds;
 673                                 status_old_nthfile = nthfile;
 674                                 status_last_update = now.tv_usec;
 675                         }
 676                 }
 677
 678                 if (!dialog_test && output_out >= 0) {
 679                         close(output_out);
 680                         waitpid(output_pid, (int *)NULL, 0);
 681                 }
 682
 683                 if (dpv_abort)
 684                         break;
 685
 686                 /* Advance head of list when we hit the max display lines */
 687                 if (display_limit > 0 && nthfile % display_limit == 0)
 688                         list_head = curfile->next;
 689         }
 690
 691         if (!debug) {
 692                 if (use_libdialog)
 693                         end_dialog();
 694                 else {
 695                         close(dialog_out);
 696                         waitpid(pid, (int *)NULL, 0);
 697                 }
 698                 if (!dpv_interrupt)
 699                         printf("\n");
 700         } else
 701                 warnx("%s: %lli overall read", __func__, dpv_overall_read);
 702
 703         if (dpv_interrupt || dpv_abort)
 704                 return (-1);
 705         else
 706                 return (0);
 707 }
 708
 709 /*
 710  * Free allocated items initialized by dpv()
 711  */
 712 void
 713 dpv_free(void)
 714 {
 715         dialogrc_free();
 716         dprompt_free();
 717         dialog_maxsize_free();
 718         if (aprompt != NULL) {
 719                 free(aprompt);
 720                 aprompt = NULL;
 721         }
 722         if (pprompt != NULL) {
 723                 free(pprompt);
 724                 pprompt = NULL;
 725         }
 726         status_free();
 727 }