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/ioctl.h>
31
32 #include <ctype.h>
33 #include <err.h>
34 #include <fcntl.h>
35 #include <limits.h>
36 #include <spawn.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <termios.h>
41 #include <unistd.h>
42
43 #include "dialog_util.h"
44 #include "dpv.h"
45 #include "dpv_private.h"
46
47 extern char **environ;
48
49 #define TTY_DEFAULT_ROWS 24
50 #define TTY_DEFAULT_COLS 80
51
52 /* [X]dialog(1) characteristics */
53 uint8_t dialog_test = 0;
54 uint8_t use_dialog = 0;
55 uint8_t use_libdialog = 1;
56 uint8_t use_xdialog = 0;
57 uint8_t use_color = 1;
58 char dialog[PATH_MAX] = DIALOG;
59
60 /* [X]dialog(1) functionality */
61 char *title = NULL;
62 char *backtitle = NULL;
63 int dheight = 0;
64 int dwidth = 0;
65 static char *dargv[64] = { NULL };
66
67 /* TTY/Screen characteristics */
68 static struct winsize *maxsize = NULL;
69
70 /* Function prototypes */
71 static void tty_maxsize_update(void);
72 static void x11_maxsize_update(void);
73
74 /*
75 * Update row/column fields of `maxsize' global (used by dialog_maxrows() and
76 * dialog_maxcols()). If the `maxsize' pointer is NULL, it will be initialized.
77 * The `ws_row' and `ws_col' fields of `maxsize' are updated to hold current
78 * maximum height and width (respectively) for a dialog(1) widget based on the
79 * active TTY size.
80 *
81 * This function is called automatically by dialog_maxrows/cols() to reflect
82 * changes in terminal size in-between calls.
83 */
84 static void
tty_maxsize_update(void)85 tty_maxsize_update(void)
86 {
87 int fd = STDIN_FILENO;
88 struct termios t;
89
90 if (maxsize == NULL) {
91 if ((maxsize = malloc(sizeof(struct winsize))) == NULL)
92 errx(EXIT_FAILURE, "Out of memory?!");
93 memset((void *)maxsize, '\0', sizeof(struct winsize));
94 }
95
96 if (!isatty(fd))
97 fd = open("/dev/tty", O_RDONLY);
98 if ((tcgetattr(fd, &t) < 0) || (ioctl(fd, TIOCGWINSZ, maxsize) < 0)) {
99 maxsize->ws_row = TTY_DEFAULT_ROWS;
100 maxsize->ws_col = TTY_DEFAULT_COLS;
101 }
102 }
103
104 /*
105 * Update row/column fields of `maxsize' global (used by dialog_maxrows() and
106 * dialog_maxcols()). If the `maxsize' pointer is NULL, it will be initialized.
107 * The `ws_row' and `ws_col' fields of `maxsize' are updated to hold current
108 * maximum height and width (respectively) for an Xdialog(1) widget based on
109 * the active video resolution of the X11 environment.
110 *
111 * This function is called automatically by dialog_maxrows/cols() to initialize
112 * `maxsize'. Since video resolution changes are less common and more obtrusive
113 * than changes to terminal size, the dialog_maxrows/cols() functions only call
114 * this function when `maxsize' is set to NULL.
115 */
116 static void
x11_maxsize_update(void)117 x11_maxsize_update(void)
118 {
119 FILE *f = NULL;
120 char *cols;
121 char *cp;
122 char *rows;
123 char cmdbuf[LINE_MAX];
124 char rbuf[LINE_MAX];
125
126 if (maxsize == NULL) {
127 if ((maxsize = malloc(sizeof(struct winsize))) == NULL)
128 errx(EXIT_FAILURE, "Out of memory?!");
129 memset((void *)maxsize, '\0', sizeof(struct winsize));
130 }
131
132 /* Assemble the command necessary to get X11 sizes */
133 snprintf(cmdbuf, LINE_MAX, "%s --print-maxsize 2>&1", dialog);
134
135 fflush(STDIN_FILENO); /* prevent popen(3) from seeking on stdin */
136
137 if ((f = popen(cmdbuf, "r")) == NULL) {
138 if (debug)
139 warnx("WARNING! Command `%s' failed", cmdbuf);
140 return;
141 }
142
143 /* Read in the line returned from Xdialog(1) */
144 if ((fgets(rbuf, LINE_MAX, f) == NULL) || (pclose(f) < 0))
145 return;
146
147 /* Check for X11-related errors */
148 if (strncmp(rbuf, "Xdialog: Error", 14) == 0)
149 return;
150
151 /* Parse expected output: MaxSize: YY, XXX */
152 if ((rows = strchr(rbuf, ' ')) == NULL)
153 return;
154 if ((cols = strchr(rows, ',')) != NULL) {
155 /* strtonum(3) doesn't like trailing junk */
156 *(cols++) = '\0';
157 if ((cp = strchr(cols, '\n')) != NULL)
158 *cp = '\0';
159 }
160
161 /* Convert to unsigned short */
162 maxsize->ws_row = (unsigned short)strtonum(
163 rows, 0, USHRT_MAX, (const char **)NULL);
164 maxsize->ws_col = (unsigned short)strtonum(
165 cols, 0, USHRT_MAX, (const char **)NULL);
166 }
167
168 /*
169 * Return the current maximum height (rows) for an [X]dialog(1) widget.
170 */
171 int
dialog_maxrows(void)172 dialog_maxrows(void)
173 {
174
175 if (use_xdialog && maxsize == NULL)
176 x11_maxsize_update(); /* initialize maxsize for GUI */
177 else if (!use_xdialog)
178 tty_maxsize_update(); /* update maxsize for TTY */
179 return (maxsize->ws_row);
180 }
181
182 /*
183 * Return the current maximum width (cols) for an [X]dialog(1) widget.
184 */
185 int
dialog_maxcols(void)186 dialog_maxcols(void)
187 {
188
189 if (use_xdialog && maxsize == NULL)
190 x11_maxsize_update(); /* initialize maxsize for GUI */
191 else if (!use_xdialog)
192 tty_maxsize_update(); /* update maxsize for TTY */
193
194 if (use_dialog || use_libdialog) {
195 if (use_shadow)
196 return (maxsize->ws_col - 2);
197 else
198 return (maxsize->ws_col);
199 } else
200 return (maxsize->ws_col);
201 }
202
203 /*
204 * Return the current maximum width (cols) for the terminal.
205 */
206 int
tty_maxcols(void)207 tty_maxcols(void)
208 {
209
210 if (use_xdialog && maxsize == NULL)
211 x11_maxsize_update(); /* initialize maxsize for GUI */
212 else if (!use_xdialog)
213 tty_maxsize_update(); /* update maxsize for TTY */
214
215 return (maxsize->ws_col);
216 }
217
218 /*
219 * Spawn an [X]dialog(1) `--gauge' box with a `--prompt' value of init_prompt.
220 * Writes the resulting process ID to the pid_t pointed at by `pid'. Returns a
221 * file descriptor (int) suitable for writing data to the [X]dialog(1) instance
222 * (data written to the file descriptor is seen as standard-in by the spawned
223 * [X]dialog(1) process).
224 */
225 int
dialog_spawn_gauge(char * init_prompt,pid_t * pid)226 dialog_spawn_gauge(char *init_prompt, pid_t *pid)
227 {
228 char dummy_init[2] = "";
229 char *cp;
230 int height;
231 int width;
232 int error;
233 posix_spawn_file_actions_t action;
234 #if DIALOG_SPAWN_DEBUG
235 unsigned int i;
236 #endif
237 unsigned int n = 0;
238 int stdin_pipe[2] = { -1, -1 };
239
240 /* Override `dialog' with a path from ENV_DIALOG if provided */
241 if ((cp = getenv(ENV_DIALOG)) != NULL)
242 snprintf(dialog, PATH_MAX, "%s", cp);
243
244 /* For Xdialog(1), set ENV_XDIALOG_HIGH_DIALOG_COMPAT */
245 setenv(ENV_XDIALOG_HIGH_DIALOG_COMPAT, "1", 1);
246
247 /* Constrain the height/width */
248 height = dialog_maxrows();
249 if (backtitle != NULL)
250 height -= use_shadow ? 5 : 4;
251 if (dheight < height)
252 height = dheight;
253 width = dialog_maxcols();
254 if (dwidth < width)
255 width = dwidth;
256
257 /* Populate argument array */
258 dargv[n++] = dialog;
259 if (title != NULL) {
260 if ((dargv[n] = malloc(8)) == NULL)
261 errx(EXIT_FAILURE, "Out of memory?!");
262 sprintf(dargv[n++], "--title");
263 dargv[n++] = title;
264 }
265 if (backtitle != NULL) {
266 if ((dargv[n] = malloc(12)) == NULL)
267 errx(EXIT_FAILURE, "Out of memory?!");
268 sprintf(dargv[n++], "--backtitle");
269 dargv[n++] = backtitle;
270 }
271 if (use_color) {
272 if ((dargv[n] = malloc(11)) == NULL)
273 errx(EXIT_FAILURE, "Out of memory?!");
274 sprintf(dargv[n++], "--colors");
275 }
276 if (use_xdialog) {
277 if ((dargv[n] = malloc(7)) == NULL)
278 errx(EXIT_FAILURE, "Out of memory?!");
279 sprintf(dargv[n++], "--left");
280
281 /*
282 * NOTE: Xdialog(1)'s `--wrap' appears to be broken for the
283 * `--gauge' widget prompt-updates. Add it anyway (in-case it
284 * gets fixed in some later release).
285 */
286 if ((dargv[n] = malloc(7)) == NULL)
287 errx(EXIT_FAILURE, "Out of memory?!");
288 sprintf(dargv[n++], "--wrap");
289 }
290 if ((dargv[n] = malloc(8)) == NULL)
291 errx(EXIT_FAILURE, "Out of memory?!");
292 sprintf(dargv[n++], "--gauge");
293 dargv[n++] = use_xdialog ? dummy_init : init_prompt;
294 if ((dargv[n] = malloc(40)) == NULL)
295 errx(EXIT_FAILURE, "Out of memory?!");
296 snprintf(dargv[n++], 40, "%u", height);
297 if ((dargv[n] = malloc(40)) == NULL)
298 errx(EXIT_FAILURE, "Out of memory?!");
299 snprintf(dargv[n++], 40, "%u", width);
300 dargv[n] = NULL;
301
302 /* Open a pipe(2) to communicate with [X]dialog(1) */
303 if (pipe(stdin_pipe) < 0)
304 err(EXIT_FAILURE, "%s: pipe(2)", __func__);
305
306 /* Fork [X]dialog(1) process */
307 #if DIALOG_SPAWN_DEBUG
308 fprintf(stderr, "%s: spawning `", __func__);
309 for (i = 0; i < n; i++) {
310 if (i == 0)
311 fprintf(stderr, "%s", dargv[i]);
312 else if (*dargv[i] == '-' && *(dargv[i] + 1) == '-')
313 fprintf(stderr, " %s", dargv[i]);
314 else
315 fprintf(stderr, " \"%s\"", dargv[i]);
316 }
317 fprintf(stderr, "'\n");
318 #endif
319 posix_spawn_file_actions_init(&action);
320 posix_spawn_file_actions_adddup2(&action, stdin_pipe[0], STDIN_FILENO);
321 posix_spawn_file_actions_addclose(&action, stdin_pipe[1]);
322 error = posix_spawnp(pid, dialog, &action,
323 (const posix_spawnattr_t *)NULL, dargv, environ);
324 if (error != 0)
325 err(EXIT_FAILURE, "%s: posix_spawnp(3)", __func__);
326
327 /* NB: Do not free(3) *dargv[], else SIGSEGV */
328
329 return (stdin_pipe[1]);
330 }
331
332 /*
333 * Returns the number of lines in buffer pointed to by `prompt'. Takes both
334 * newlines and escaped-newlines into account.
335 */
336 unsigned int
dialog_prompt_numlines(const char * prompt,uint8_t nlstate)337 dialog_prompt_numlines(const char *prompt, uint8_t nlstate)
338 {
339 uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
340 const char *cp = prompt;
341 unsigned int nlines = 1;
342
343 if (prompt == NULL || *prompt == '\0')
344 return (0);
345
346 while (*cp != '\0') {
347 if (use_dialog) {
348 if (strncmp(cp, "\\n", 2) == 0) {
349 cp++;
350 nlines++;
351 nls = TRUE; /* See declaration comment */
352 } else if (*cp == '\n') {
353 if (!nls)
354 nlines++;
355 nls = FALSE; /* See declaration comment */
356 }
357 } else if (use_libdialog) {
358 if (*cp == '\n')
359 nlines++;
360 } else if (strncmp(cp, "\\n", 2) == 0) {
361 cp++;
362 nlines++;
363 }
364 cp++;
365 }
366
367 return (nlines);
368 }
369
370 /*
371 * Returns the length in bytes of the longest line in buffer pointed to by
372 * `prompt'. Takes newlines and escaped newlines into account. Also discounts
373 * dialog(1) color escape codes if enabled (via `use_color' global).
374 */
375 unsigned int
dialog_prompt_longestline(const char * prompt,uint8_t nlstate)376 dialog_prompt_longestline(const char *prompt, uint8_t nlstate)
377 {
378 uint8_t backslash = 0;
379 uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
380 const char *p = prompt;
381 int longest = 0;
382 int n = 0;
383
384 /* `prompt' parameter is required */
385 if (prompt == NULL)
386 return (0);
387 if (*prompt == '\0')
388 return (0); /* shortcut */
389
390 /* Loop until the end of the string */
391 while (*p != '\0') {
392 /* dialog(1) and dialog(3) will render literal newlines */
393 if (use_dialog || use_libdialog) {
394 if (*p == '\n') {
395 if (!use_libdialog && nls)
396 n++;
397 else {
398 if (n > longest)
399 longest = n;
400 n = 0;
401 }
402 nls = FALSE; /* See declaration comment */
403 p++;
404 continue;
405 }
406 }
407
408 /* Check for backslash character */
409 if (*p == '\\') {
410 /* If second backslash, count as a single-char */
411 if ((backslash ^= 1) == 0)
412 n++;
413 } else if (backslash) {
414 if (*p == 'n' && !use_libdialog) { /* new line */
415 /* NB: dialog(3) ignores escaped newlines */
416 nls = TRUE; /* See declaration comment */
417 if (n > longest)
418 longest = n;
419 n = 0;
420 } else if (use_color && *p == 'Z') {
421 if (*++p != '\0')
422 p++;
423 backslash = 0;
424 continue;
425 } else /* [X]dialog(1)/dialog(3) only expand those */
426 n += 2;
427
428 backslash = 0;
429 } else
430 n++;
431 p++;
432 }
433 if (n > longest)
434 longest = n;
435
436 return (longest);
437 }
438
439 /*
440 * Returns a pointer to the last line in buffer pointed to by `prompt'. Takes
441 * both newlines (if using dialog(1) versus Xdialog(1)) and escaped newlines
442 * into account. If no newlines (escaped or otherwise) appear in the buffer,
443 * `prompt' is returned. If passed a NULL pointer, returns NULL.
444 */
445 char *
dialog_prompt_lastline(char * prompt,uint8_t nlstate)446 dialog_prompt_lastline(char *prompt, uint8_t nlstate)
447 {
448 uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
449 char *lastline;
450 char *p;
451
452 if (prompt == NULL)
453 return (NULL);
454 if (*prompt == '\0')
455 return (prompt); /* shortcut */
456
457 lastline = p = prompt;
458 while (*p != '\0') {
459 /* dialog(1) and dialog(3) will render literal newlines */
460 if (use_dialog || use_libdialog) {
461 if (*p == '\n') {
462 if (use_libdialog || !nls)
463 lastline = p + 1;
464 nls = FALSE; /* See declaration comment */
465 }
466 }
467 /* dialog(3) does not expand escaped newlines */
468 if (use_libdialog) {
469 p++;
470 continue;
471 }
472 if (*p == '\\' && *(p + 1) != '\0' && *(++p) == 'n') {
473 nls = TRUE; /* See declaration comment */
474 lastline = p + 1;
475 }
476 p++;
477 }
478
479 return (lastline);
480 }
481
482 /*
483 * Returns the number of extra lines generated by wrapping the text in buffer
484 * pointed to by `prompt' within `ncols' columns (for prompts, this should be
485 * dwidth - 4). Also discounts dialog(1) color escape codes if enabled (via
486 * `use_color' global).
487 */
488 int
dialog_prompt_wrappedlines(char * prompt,int ncols,uint8_t nlstate)489 dialog_prompt_wrappedlines(char *prompt, int ncols, uint8_t nlstate)
490 {
491 uint8_t backslash = 0;
492 uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
493 char *cp;
494 char *p = prompt;
495 int n = 0;
496 int wlines = 0;
497
498 /* `prompt' parameter is required */
499 if (p == NULL)
500 return (0);
501 if (*p == '\0')
502 return (0); /* shortcut */
503
504 /* Loop until the end of the string */
505 while (*p != '\0') {
506 /* dialog(1) and dialog(3) will render literal newlines */
507 if (use_dialog || use_libdialog) {
508 if (*p == '\n') {
509 if (use_dialog || !nls)
510 n = 0;
511 nls = FALSE; /* See declaration comment */
512 }
513 }
514
515 /* Check for backslash character */
516 if (*p == '\\') {
517 /* If second backslash, count as a single-char */
518 if ((backslash ^= 1) == 0)
519 n++;
520 } else if (backslash) {
521 if (*p == 'n' && !use_libdialog) { /* new line */
522 /* NB: dialog(3) ignores escaped newlines */
523 nls = TRUE; /* See declaration comment */
524 n = 0;
525 } else if (use_color && *p == 'Z') {
526 if (*++p != '\0')
527 p++;
528 backslash = 0;
529 continue;
530 } else /* [X]dialog(1)/dialog(3) only expand those */
531 n += 2;
532
533 backslash = 0;
534 } else
535 n++;
536
537 /* Did we pass the width barrier? */
538 if (n > ncols) {
539 /*
540 * Work backward to find the first whitespace on-which
541 * dialog(1) will wrap the line (but don't go before
542 * the start of this line).
543 */
544 cp = p;
545 while (n > 1 && !isspace(*cp)) {
546 cp--;
547 n--;
548 }
549 if (n > 0 && isspace(*cp))
550 p = cp;
551 wlines++;
552 n = 1;
553 }
554
555 p++;
556 }
557
558 return (wlines);
559 }
560
561 /*
562 * Returns zero if the buffer pointed to by `prompt' contains an escaped
563 * newline but only if appearing after any/all literal newlines. This is
564 * specific to dialog(1) and does not apply to Xdialog(1).
565 *
566 * As an attempt to make shell scripts easier to read, dialog(1) will "eat"
567 * the first literal newline after an escaped newline. This however has a bug
568 * in its implementation in that rather than allowing `\\n\n' to be treated
569 * similar to `\\n' or `\n', dialog(1) expands the `\\n' and then translates
570 * the following literal newline (with or without characters between [!]) into
571 * a single space.
572 *
573 * If you want to be compatible with Xdialog(1), it is suggested that you not
574 * use literal newlines (they aren't supported); but if you have to use them,
575 * go right ahead. But be forewarned... if you set $DIALOG in your environment
576 * to something other than `cdialog' (our current dialog(1)), then it should
577 * do the same thing w/respect to how to handle a literal newline after an
578 * escaped newline (you could do no wrong by translating every literal newline
579 * into a space but only when you've previously encountered an escaped one;
580 * this is what dialog(1) is doing).
581 *
582 * The ``newline state'' (or nlstate for short; as I'm calling it) is helpful
583 * if you plan to combine multiple strings into a single prompt text. In lead-
584 * up to this procedure, a common task is to calculate and utilize the widths
585 * and heights of each piece of prompt text to later be combined. However, if
586 * (for example) the first string ends in a positive newline state (has an
587 * escaped newline without trailing literal), the first literal newline in the
588 * second string will be mangled.
589 *
590 * The return value of this function should be used as the `nlstate' argument
591 * to dialog_*() functions that require it to allow accurate calculations in
592 * the event such information is needed.
593 */
594 uint8_t
dialog_prompt_nlstate(const char * prompt)595 dialog_prompt_nlstate(const char *prompt)
596 {
597 const char *cp;
598
599 if (prompt == NULL)
600 return 0;
601
602 /*
603 * Work our way backward from the end of the string for efficiency.
604 */
605 cp = prompt + strlen(prompt);
606 while (--cp >= prompt) {
607 /*
608 * If we get to a literal newline first, this prompt ends in a
609 * clean state for rendering with dialog(1). Otherwise, if we
610 * get to an escaped newline first, this prompt ends in an un-
611 * clean state (following literal will be mangled; see above).
612 */
613 if (*cp == '\n')
614 return (0);
615 else if (*cp == 'n' && --cp > prompt && *cp == '\\')
616 return (1);
617 }
618
619 return (0); /* no newlines (escaped or otherwise) */
620 }
621
622 /*
623 * Free allocated items initialized by tty_maxsize_update() and
624 * x11_maxsize_update()
625 */
626 void
dialog_maxsize_free(void)627 dialog_maxsize_free(void)
628 {
629 if (maxsize != NULL) {
630 free(maxsize);
631 maxsize = NULL;
632 }
633 }
634