mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-17 10:26:15 +00:00
Code Issues Releases Activity
324c11a1be
freebsd/lib/libdpv/dpv.c
Devin Teske 324c11a1be Fix a debug statement. Only the callback function (performing the 
incrementing of dpv_overall_oread) knows what its purpose is (and
often times it was bytes, not lines).

MFC after:	3 days
X-MFC-to:	stable/10
2015-06-01 02:06:57 +00:00

722 lines
21 KiB
C
Raw Blame History

/*-
* Copyright (c) 2013-2014 Devin Teske <dteske@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
#include <dialog.h>
#include <err.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string_m.h>
#include <unistd.h>
#include "dialog_util.h"
#include "dialogrc.h"
#include "dprompt.h"
#include "dpv.h"
#include "dpv_private.h"
#include "status.h"
#include "util.h"
/* Test Mechanics (Only used when dpv_config.options |= DPV_TEST_MODE) */
#define INCREMENT 1 /* Increment % per-pass test-mode */
#define XDIALOG_INCREMENT 15 /* different for slower Xdialog(1) */
static uint8_t increment = INCREMENT;
/* Debugging */
uint8_t debug = FALSE;
/* Data to process */
int dpv_interrupt = FALSE;
int dpv_abort = FALSE;
unsigned int dpv_nfiles = 0;
/* Data processing */
long long dpv_overall_read = 0;
static char pathbuf[PATH_MAX];
/* Extra display information */
uint8_t no_labels = FALSE; /* dpv_config.options & DPV_NO_LABELS */
uint8_t wide = FALSE; /* dpv_config.options & DPV_WIDE_MODE */
char *aprompt = NULL; /* dpv_config.aprompt */
char *msg_done = NULL; /* dpv_config.msg_done */
char *msg_fail = NULL; /* dpv_config.msg_fail */
char *msg_pending = NULL; /* dpv_config.msg_pending */
char *pprompt = NULL; /* dpv_config.pprompt */
/* Status-Line format for when using dialog(3) */
static const char *status_format_custom = NULL;
static char status_format_default[DPV_STATUS_FORMAT_MAX];
/*
* Takes a pointer to a dpv_config structure containing layout details and
* pointer to initial element in a linked-list of dpv_file_node structures,
* each presenting a file to process. Executes the `action' function passed-in
* as a member to the `config' structure argument.
*/
int
dpv(struct dpv_config *config, struct dpv_file_node *file_list)
{
char c;
uint8_t keep_going;
uint8_t nls = FALSE; /* See dialog_prompt_nlstate() */
uint8_t no_overrun = FALSE;
uint8_t pprompt_nls = FALSE; /* See dialog_prompt_nlstate() */
uint8_t shrink_label_size = FALSE;
mode_t mask;
uint16_t options;
char *cp;
char *fc;
char *last;
char *name;
char *output;
const char *status_fmt;
const char *path_fmt;
enum dpv_display display_type;
enum dpv_output output_type;
enum dpv_status status;
int (*action)(struct dpv_file_node *file, int out);
int backslash;
int dialog_last_update = 0;
int dialog_old_nthfile = 0;
int dialog_old_seconds = -1;
int dialog_out = STDOUT_FILENO;
int dialog_update_usec = 0;
int dialog_updates_per_second;
int files_left;
int max_cols;
int nthfile = 0;
int output_out;
int overall = 0;
int pct;
int res;
int seconds;
int status_last_update = 0;
int status_old_nthfile = 0;
int status_old_seconds = -1;
int status_update_usec = 0;
int status_updates_per_second;
pid_t output_pid;
pid_t pid;
size_t len;
struct dpv_file_node *curfile;
struct dpv_file_node *first_file;
struct dpv_file_node *list_head;
struct timeval now;
struct timeval start;
char init_prompt[PROMPT_MAX + 1] = "";
/* Initialize globals to default values */
aprompt = NULL;
pprompt = NULL;
options = 0;
action = NULL;
backtitle = NULL;
debug = FALSE;
dialog_test = FALSE;
dialog_updates_per_second = DIALOG_UPDATES_PER_SEC;
display_limit = DISPLAY_LIMIT_DEFAULT;
display_type = DPV_DISPLAY_LIBDIALOG;
label_size = LABEL_SIZE_DEFAULT;
msg_done = NULL;
msg_fail = NULL;
msg_pending = NULL;
no_labels = FALSE;
output = NULL;
output_type = DPV_OUTPUT_NONE;
pbar_size = PBAR_SIZE_DEFAULT;
status_format_custom = NULL;
status_updates_per_second = STATUS_UPDATES_PER_SEC;
title = NULL;
wide = FALSE;
/* Process config options (overriding defaults) */
if (config != NULL) {
if (config->aprompt != NULL) {
if (aprompt == NULL) {
aprompt = malloc(DPV_APROMPT_MAX);
if (aprompt == NULL)
return (-1);
}
snprintf(aprompt, DPV_APROMPT_MAX, "%s",
config->aprompt);
}
if (config->pprompt != NULL) {
if (pprompt == NULL) {
pprompt = malloc(DPV_PPROMPT_MAX + 2);
/* +2 is for implicit "\n" appended later */
if (pprompt == NULL)
return (-1);
}
snprintf(pprompt, DPV_APROMPT_MAX, "%s",
config->pprompt);
}
options = config->options;
action = config->action;
backtitle = config->backtitle;
debug = config->debug;
dialog_test = ((options & DPV_TEST_MODE) != 0);
dialog_updates_per_second = config->dialog_updates_per_second;
display_limit = config->display_limit;
display_type = config->display_type;
label_size = config->label_size;
msg_done = (char *)config->msg_done;
msg_fail = (char *)config->msg_fail;
msg_pending = (char *)config->msg_pending;
no_labels = ((options & DPV_NO_LABELS) != 0);
no_overrun = ((options & DPV_NO_OVERRUN) != 0);
output = config->output;
output_type = config->output_type;
pbar_size = config->pbar_size;
status_updates_per_second = config->status_updates_per_second;
title = config->title;
wide = ((options & DPV_WIDE_MODE) != 0);
/* Enforce some minimums (pedantic) */
if (display_limit < -1)
display_limit = -1;
if (label_size < -1)
label_size = -1;
if (pbar_size < -1)
pbar_size = -1;
/* For the mini-pbar, -1 means hide, zero is invalid unless
* only one file is given */
if (pbar_size == 0) {
if (file_list == NULL || file_list->next == NULL)
pbar_size = -1;
else
pbar_size = PBAR_SIZE_DEFAULT;
}
/* For the label, -1 means auto-size, zero is invalid unless
* specifically requested through the use of options flag */
if (label_size == 0 && no_labels == FALSE)
label_size = LABEL_SIZE_DEFAULT;
/* Status update should not be zero */
if (status_updates_per_second == 0)
status_updates_per_second = STATUS_UPDATES_PER_SEC;
} /* config != NULL */
/* Process the type of display we've been requested to produce */
switch (display_type) {
case DPV_DISPLAY_STDOUT:
debug = TRUE;
use_color = FALSE;
use_dialog = FALSE;
use_libdialog = FALSE;
use_xdialog = FALSE;
break;
case DPV_DISPLAY_DIALOG:
use_color = TRUE;
use_dialog = TRUE;
use_libdialog = FALSE;
use_xdialog = FALSE;
break;
case DPV_DISPLAY_XDIALOG:
snprintf(dialog, PATH_MAX, XDIALOG);
use_color = FALSE;
use_dialog = FALSE;
use_libdialog = FALSE;
use_xdialog = TRUE;
break;
default:
use_color = TRUE;
use_dialog = FALSE;
use_libdialog = TRUE;
use_xdialog = FALSE;
break;
} /* display_type */
/* Enforce additional minimums that require knowing our display type */
if (dialog_updates_per_second == 0)
dialog_updates_per_second = use_xdialog ?
XDIALOG_UPDATES_PER_SEC : DIALOG_UPDATES_PER_SEC;
/* Allow forceful override of use_color */
if (config != NULL && (config->options & DPV_USE_COLOR) != 0)
use_color = TRUE;
/* Count the number of files in provided list of dpv_file_node's */
if (use_dialog && pprompt != NULL && *pprompt != '\0')
pprompt_nls = dialog_prompt_nlstate(pprompt);
max_cols = dialog_maxcols();
if (label_size == -1)
shrink_label_size = TRUE;
/* Process file arguments */
for (curfile = file_list; curfile != NULL; curfile = curfile->next) {
dpv_nfiles++;
/* dialog(3) only expands literal newlines */
if (use_libdialog) strexpandnl(curfile->name);
/* Optionally calculate label size for file */
if (shrink_label_size) {
nls = FALSE;
name = curfile->name;
if (curfile == file_list)
nls = pprompt_nls;
last = (char *)dialog_prompt_lastline(name, nls);
if (use_dialog) {
c = *last;
*last = '\0';
nls = dialog_prompt_nlstate(name);
*last = c;
}
len = dialog_prompt_longestline(last, nls);
if ((int)len > (label_size - 3)) {
if (label_size > 0)
label_size += 3;
label_size = len;
/* Room for ellipsis (unless NULL) */
if (label_size > 0)
label_size += 3;
}
if (max_cols > 0 && label_size > (max_cols - pbar_size
- 9))
label_size = max_cols - pbar_size - 9;
}
if (debug)
warnx("label=[%s] path=[%s] size=%lli",
curfile->name, curfile->path, curfile->length);
} /* file_list */
/* Optionally process the contents of DIALOGRC (~/.dialogrc) */
if (use_dialog) {
res = parse_dialogrc();
if (debug && res == 0) {
warnx("Successfully read `%s' config file", DIALOGRC);
warnx("use_shadow = %i (Boolean)", use_shadow);
warnx("use_colors = %i (Boolean)", use_colors);
warnx("gauge_color=[%s] (FBH)", gauge_color);
}
} else if (use_libdialog) {
init_dialog(stdin, stdout);
use_shadow = dialog_state.use_shadow;
use_colors = dialog_state.use_colors;
gauge_color[0] = 48 + dlg_color_table[GAUGE_ATTR].fg;
gauge_color[1] = 48 + dlg_color_table[GAUGE_ATTR].bg;
gauge_color[2] = dlg_color_table[GAUGE_ATTR].hilite ?
'b' : 'B';
gauge_color[3] = '\0';
end_dialog();
if (debug) {
warnx("Finished initializing dialog(3) library");
warnx("use_shadow = %i (Boolean)", use_shadow);
warnx("use_colors = %i (Boolean)", use_colors);
warnx("gauge_color=[%s] (FBH)", gauge_color);
}
}
/* Enable mini progress bar automatically for stdin streams if unable
* to calculate progress (missing `lines:' syntax). */
if (dpv_nfiles <= 1 && file_list != NULL && file_list->length < 0 &&
!dialog_test)
pbar_size = PBAR_SIZE_DEFAULT;
/* If $USE_COLOR is set and non-NULL enable color; otherwise disable */
if ((cp = getenv(ENV_USE_COLOR)) != 0)
use_color = *cp != '\0' ? 1 : 0;
/* Print error and return `-1' if not given at least one name */
if (dpv_nfiles == 0) {
warnx("%s: no labels provided", __func__);
return (-1);
} else if (debug)
warnx("%s: %u label%s provided", __func__, dpv_nfiles,
dpv_nfiles == 1 ? "" : "s");
/* If only one file and pbar size is zero, default to `-1' */
if (dpv_nfiles <= 1 && pbar_size == 0)
pbar_size = -1;
/* Print some debugging information */
if (debug) {
warnx("%s: %s(%i) max rows x cols = %i x %i",
__func__, use_xdialog ? XDIALOG : DIALOG,
use_libdialog ? 3 : 1, dialog_maxrows(),
dialog_maxcols());
}
/* Xdialog(1) updates a lot slower than dialog(1) */
if (dialog_test && use_xdialog)
increment = XDIALOG_INCREMENT;
/* Always add implicit newline to pprompt (when specified) */
if (pprompt != NULL && *pprompt != '\0') {
len = strlen(pprompt);
/*
* NOTE: pprompt = malloc(PPROMPT_MAX + 2)
* NOTE: (see getopt(2) section above for pprompt allocation)
*/
pprompt[len++] = '\\';
pprompt[len++] = 'n';
pprompt[len++] = '\0';
}
/* Xdialog(1) requires newlines (a) escaped and (b) in triplicate */
if (use_xdialog && pprompt != NULL) {
/* Replace `\n' with `\n\\n\n' in pprompt */
len = strlen(pprompt);
len += strcount(pprompt, "\\n") * 2;
if (len > DPV_PPROMPT_MAX)
errx(EXIT_FAILURE, "%s: Oops, pprompt buffer overflow "
"(%zu > %i)", __func__, len, DPV_PPROMPT_MAX);
if (replaceall(pprompt, "\\n", "\n\\n\n") < 0)
err(EXIT_FAILURE, "%s: replaceall()", __func__);
}
/* libdialog requires literal newlines */
else if (use_libdialog && pprompt != NULL)
strexpandnl(pprompt);
/* Xdialog(1) requires newlines (a) escaped and (b) in triplicate */
if (use_xdialog && aprompt != NULL) {
/* Replace `\n' with `\n\\n\n' in aprompt */
len = strlen(aprompt);
len += strcount(aprompt, "\\n") * 2;
if (len > DPV_APROMPT_MAX)
errx(EXIT_FAILURE, "%s: Oops, aprompt buffer overflow "
" (%zu > %i)", __func__, len, DPV_APROMPT_MAX);
if (replaceall(aprompt, "\\n", "\n\\n\n") < 0)
err(EXIT_FAILURE, "%s: replaceall()", __func__);
}
/* libdialog requires literal newlines */
else if (use_libdialog && aprompt != NULL)
strexpandnl(aprompt);
/*
* Warn user about an obscure dialog(1) bug (neither Xdialog(1) nor
* libdialog are affected) in the `--gauge' widget. If the first non-
* whitespace letter of "{new_prompt}" in "XXX\n{new_prompt}\nXXX\n"
* is a number, the number can sometimes be mistaken for a percentage
* to the overall progressbar. Other nasty side-effects such as the
* entire prompt not displaying or displaying improperly are caused by
* this bug too.
*
* NOTE: When we can use color, we have a work-around... prefix the
* output with `\Zn' (used to terminate ANSI and reset to normal).
*/
if (use_dialog && !use_color) {
backslash = 0;
/* First, check pprompt (falls through if NULL) */
fc = pprompt;
while (fc != NULL && *fc != '\0') {
if (*fc == '\n') /* leading literal newline OK */
break;
if (!isspace(*fc) && *fc != '\\' && backslash == 0)
break;
else if (backslash > 0 && *fc != 'n')
break;
else if (*fc == '\\') {
backslash++;
if (backslash > 2)
break; /* we're safe */
}
fc++;
}
/* First non-whitespace character that dialog(1) will see */
if (fc != NULL && *fc >= '0' && *fc <= '9')
warnx("%s: WARNING! text argument to `-p' begins with "
"a number (not recommended)", __func__);
else if (fc > pprompt)
warnx("%s: WARNING! text argument to `-p' begins with "
"whitespace (not recommended)", __func__);
/*
* If no pprompt or pprompt is all whitespace, check the first
* file name provided to make sure it is alright too.
*/
if ((pprompt == NULL || *fc == '\0') && file_list != NULL) {
first_file = file_list;
fc = first_file->name;
while (fc != NULL && *fc != '\0' && isspace(*fc))
fc++;
/* First non-whitespace char that dialog(1) will see */
if (fc != NULL && *fc >= '0' && *fc <= '9')
warnx("%s: WARNING! File name `%s' begins "
"with a number (use `-p text' for safety)",
__func__, first_file->name);
}
}
dprompt_init(file_list);
/* Reads: label_size pbar_size pprompt aprompt dpv_nfiles */
/* Inits: dheight and dwidth */
if (!debug) {
/* Internally create the initial `--gauge' prompt text */
dprompt_recreate(file_list, (struct dpv_file_node *)NULL, 0);
/* Spawn [X]dialog(1) `--gauge', returning pipe descriptor */
if (use_libdialog) {
status_printf("");
dprompt_libprint(pprompt, aprompt, 0);
} else {
dprompt_sprint(init_prompt, pprompt, aprompt);
dialog_out = dialog_spawn_gauge(init_prompt, &pid);
dprompt_dprint(dialog_out, pprompt, aprompt, 0);
}
} /* !debug */
/* Seed the random(3) generator */
if (dialog_test)
srandom(0xf1eeface);
/* Set default/custom status line format */
if (dpv_nfiles > 1) {
snprintf(status_format_default, DPV_STATUS_FORMAT_MAX, "%s",
DPV_STATUS_MANY);
status_format_custom = config->status_many;
} else {
snprintf(status_format_default, DPV_STATUS_FORMAT_MAX, "%s",
DPV_STATUS_SOLO);
status_format_custom = config->status_solo;
}
/* Add test mode identifier to default status line if enabled */
if (dialog_test && (strlen(status_format_default) + 12) <
DPV_STATUS_FORMAT_MAX)
strcat(status_format_default, " [TEST MODE]");
/* Verify custom status format */
status_fmt = fmtcheck(status_format_custom, status_format_default);
if (status_format_custom != NULL &&
status_fmt == status_format_default) {
warnx("WARNING! Invalid status_format configuration `%s'",
status_format_custom);
warnx("Default status_format `%s'", status_format_default);
}
/* Record when we started (used to prevent updating too quickly) */
(void)gettimeofday(&start, (struct timezone *)NULL);
/* Calculate number of microseconds in-between sub-second updates */
if (status_updates_per_second != 0)
status_update_usec = 1000000 / status_updates_per_second;
if (dialog_updates_per_second != 0)
dialog_update_usec = 1000000 / dialog_updates_per_second;
/*
* Process the file list [serially] (one for each argument passed)
*/
files_left = dpv_nfiles;
list_head = file_list;
for (curfile = file_list; curfile != NULL; curfile = curfile->next) {
keep_going = TRUE;
output_out = -1;
pct = 0;
nthfile++;
files_left--;
if (dpv_interrupt)
break;
if (dialog_test)
pct = 0 - increment;
/* Attempt to spawn output program for this file */
if (!dialog_test && output != NULL) {
mask = umask(0022);
(void)umask(mask);
switch (output_type) {
case DPV_OUTPUT_SHELL:
output_out = shell_spawn_pipecmd(output,
curfile->name, &output_pid);
break;
case DPV_OUTPUT_FILE:
path_fmt = fmtcheck(output, "%s");
if (path_fmt == output)
len = snprintf(pathbuf,
PATH_MAX, output, curfile->name);
else
len = snprintf(pathbuf,
PATH_MAX, "%s", output);
if (len >= PATH_MAX) {
warnx("%s:%d:%s: pathbuf[%u] too small"
"to hold output argument",
__FILE__, __LINE__, __func__,
PATH_MAX);
return (-1);
}
if ((output_out = open(pathbuf,
O_CREAT|O_WRONLY, DEFFILEMODE & ~mask))
< 0) {
warn("%s", pathbuf);
return (-1);
}
break;
default:
break;
}
}
while (!dpv_interrupt && keep_going) {
if (dialog_test) {
usleep(50000);
pct += increment;
dpv_overall_read +=
(int)(random() / 512 / dpv_nfiles);
/* 512 limits fake readout to Megabytes */
} else if (action != NULL)
pct = action(curfile, output_out);
if (no_overrun || dialog_test)
keep_going = (pct < 100);
else {
status = curfile->status;
keep_going = (status == DPV_STATUS_RUNNING);
}
/* Get current time and calculate seconds elapsed */
gettimeofday(&now, (struct timezone *)NULL);
now.tv_sec = now.tv_sec - start.tv_sec;
now.tv_usec = now.tv_usec - start.tv_usec;
if (now.tv_usec < 0)
now.tv_sec--, now.tv_usec += 1000000;
seconds = now.tv_sec + (now.tv_usec / 1000000.0);
/* Update dialog (be it dialog(3), dialog(1), etc.) */
if ((dialog_updates_per_second != 0 &&
(
seconds != dialog_old_seconds ||
now.tv_usec - dialog_last_update >=
dialog_update_usec ||
nthfile != dialog_old_nthfile
)) || pct == 100
) {
/* Calculate overall progress (rounding up) */
overall = (100 * nthfile - 100 + pct) /
dpv_nfiles;
if (((100 * nthfile - 100 + pct) * 10 /
dpv_nfiles % 100) > 50)
overall++;
dprompt_recreate(list_head, curfile, pct);
if (use_libdialog && !debug) {
/* Update dialog(3) widget */
dprompt_libprint(pprompt, aprompt,
overall);
} else {
/* stdout, dialog(1), or Xdialog(1) */
dprompt_dprint(dialog_out, pprompt,
aprompt, overall);
fsync(dialog_out);
}
dialog_old_seconds = seconds;
dialog_old_nthfile = nthfile;
dialog_last_update = now.tv_usec;
}
/* Update the status line */
if ((use_libdialog && !debug) &&
status_updates_per_second != 0 &&
(
keep_going != TRUE ||
seconds != status_old_seconds ||
now.tv_usec - status_last_update >=
status_update_usec ||
nthfile != status_old_nthfile
)
) {
status_printf(status_fmt, dpv_overall_read,
(dpv_overall_read / (seconds == 0 ? 1 :
seconds) * 1.0),
1, /* XXX until we add parallelism XXX */
files_left);
status_old_seconds = seconds;
status_old_nthfile = nthfile;
status_last_update = now.tv_usec;
}
}
if (!dialog_test && output_out >= 0) {
close(output_out);
waitpid(output_pid, (int *)NULL, 0);
}
if (dpv_abort)
break;
/* Advance head of list when we hit the max display lines */
if (display_limit > 0 && nthfile % display_limit == 0)
list_head = curfile->next;
}
if (!debug) {
if (use_libdialog)
end_dialog();
else {
close(dialog_out);
waitpid(pid, (int *)NULL, 0);
}
if (!dpv_interrupt)
printf("\n");
} else
warnx("%s: %lli overall read", __func__, dpv_overall_read);
if (dpv_interrupt || dpv_abort)
return (-1);
else
return (0);
}
/*
* Free allocated items initialized by dpv()
*/
void
dpv_free(void)
{
dialogrc_free();
dprompt_free();
dialog_maxsize_free();
if (aprompt != NULL) {
free(aprompt);
aprompt = NULL;
}
if (pprompt != NULL) {
free(pprompt);
pprompt = NULL;
}
status_free();
}
Reference in New Issue View Git Blame Copy Permalink