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