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 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 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 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 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 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 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 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 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 * 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 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 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 627 dialog_maxsize_free(void) 628 { 629 if (maxsize != NULL) { 630 free(maxsize); 631 maxsize = NULL; 632 } 633 } 634