lib/libdpv/dialog_util.c

   1 /*-
   2  * Copyright (c) 2013-2018 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         } else {
 265                 if ((dargv[n] = malloc(8)) == NULL)
 266                         errx(EXIT_FAILURE, "Out of memory?!");
 267                 sprintf(dargv[n++], "--title");
 268                 if ((dargv[n] = malloc(1)) == NULL)
 269                         errx(EXIT_FAILURE, "Out of memory?!");
 270                 *dargv[n++] = '\0';
 271         }
 272         if (backtitle != NULL) {
 273                 if ((dargv[n] = malloc(12)) == NULL)
 274                         errx(EXIT_FAILURE, "Out of memory?!");
 275                 sprintf(dargv[n++], "--backtitle");
 276                 dargv[n++] = backtitle;
 277         }
 278         if (use_color) {
 279                 if ((dargv[n] = malloc(11)) == NULL)
 280                         errx(EXIT_FAILURE, "Out of memory?!");
 281                 sprintf(dargv[n++], "--colors");
 282         }
 283         if (use_xdialog) {
 284                 if ((dargv[n] = malloc(7)) == NULL)
 285                         errx(EXIT_FAILURE, "Out of memory?!");
 286                 sprintf(dargv[n++], "--left");
 287
 288                 /*
 289                  * NOTE: Xdialog(1)'s `--wrap' appears to be broken for the
 290                  * `--gauge' widget prompt-updates. Add it anyway (in-case it
 291                  * gets fixed in some later release).
 292                  */
 293                 if ((dargv[n] = malloc(7)) == NULL)
 294                         errx(EXIT_FAILURE, "Out of memory?!");
 295                 sprintf(dargv[n++], "--wrap");
 296         }
 297         if ((dargv[n] = malloc(8)) == NULL)
 298                 errx(EXIT_FAILURE, "Out of memory?!");
 299         sprintf(dargv[n++], "--gauge");
 300         dargv[n++] = use_xdialog ? dummy_init : init_prompt;
 301         if ((dargv[n] = malloc(40)) == NULL)
 302                 errx(EXIT_FAILURE, "Out of memory?!");
 303         snprintf(dargv[n++], 40, "%u", height);
 304         if ((dargv[n] = malloc(40)) == NULL)
 305                 errx(EXIT_FAILURE, "Out of memory?!");
 306         snprintf(dargv[n++], 40, "%u", width);
 307         dargv[n] = NULL;
 308
 309         /* Open a pipe(2) to communicate with [X]dialog(1) */
 310         if (pipe(stdin_pipe) < 0)
 311                 err(EXIT_FAILURE, "%s: pipe(2)", __func__);
 312
 313         /* Fork [X]dialog(1) process */
 314 #if DIALOG_SPAWN_DEBUG
 315         fprintf(stderr, "%s: spawning `", __func__);
 316         for (i = 0; i < n; i++) {
 317                 if (i == 0)
 318                         fprintf(stderr, "%s", dargv[i]);
 319                 else if (*dargv[i] == '-' && *(dargv[i] + 1) == '-')
 320                         fprintf(stderr, " %s", dargv[i]);
 321                 else
 322                         fprintf(stderr, " \"%s\"", dargv[i]);
 323         }
 324         fprintf(stderr, "'\n");
 325 #endif
 326         posix_spawn_file_actions_init(&action);
 327         posix_spawn_file_actions_adddup2(&action, stdin_pipe[0], STDIN_FILENO);
 328         posix_spawn_file_actions_addclose(&action, stdin_pipe[1]);
 329         error = posix_spawnp(pid, dialog, &action,
 330             (const posix_spawnattr_t *)NULL, dargv, environ);
 331         if (error != 0) err(EXIT_FAILURE, "%s", dialog);
 332
 333         /* NB: Do not free(3) *dargv[], else SIGSEGV */
 334
 335         return (stdin_pipe[1]);
 336 }
 337
 338 /*
 339  * Returns the number of lines in buffer pointed to by `prompt'. Takes both
 340  * newlines and escaped-newlines into account.
 341  */
 342 unsigned int
 343 dialog_prompt_numlines(const char *prompt, uint8_t nlstate)
 344 {
 345         uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
 346         const char *cp = prompt;
 347         unsigned int nlines = 1;
 348
 349         if (prompt == NULL || *prompt == '\0')
 350                 return (0);
 351
 352         while (*cp != '\0') {
 353                 if (use_dialog) {
 354                         if (strncmp(cp, "\\n", 2) == 0) {
 355                                 cp++;
 356                                 nlines++;
 357                                 nls = TRUE; /* See declaration comment */
 358                         } else if (*cp == '\n') {
 359                                 if (!nls)
 360                                         nlines++;
 361                                 nls = FALSE; /* See declaration comment */
 362                         }
 363                 } else if (use_libdialog) {
 364                         if (*cp == '\n')
 365                                 nlines++;
 366                 } else if (strncmp(cp, "\\n", 2) == 0) {
 367                         cp++;
 368                         nlines++;
 369                 }
 370                 cp++;
 371         }
 372
 373         return (nlines);
 374 }
 375
 376 /*
 377  * Returns the length in bytes of the longest line in buffer pointed to by
 378  * `prompt'. Takes newlines and escaped newlines into account. Also discounts
 379  * dialog(1) color escape codes if enabled (via `use_color' global).
 380  */
 381 unsigned int
 382 dialog_prompt_longestline(const char *prompt, uint8_t nlstate)
 383 {
 384         uint8_t backslash = 0;
 385         uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
 386         const char *p = prompt;
 387         int longest = 0;
 388         int n = 0;
 389
 390         /* `prompt' parameter is required */
 391         if (prompt == NULL)
 392                 return (0);
 393         if (*prompt == '\0')
 394                 return (0); /* shortcut */
 395
 396         /* Loop until the end of the string */
 397         while (*p != '\0') {
 398                 /* dialog(1) and dialog(3) will render literal newlines */
 399                 if (use_dialog || use_libdialog) {
 400                         if (*p == '\n') {
 401                                 if (!use_libdialog && nls)
 402                                         n++;
 403                                 else {
 404                                         if (n > longest)
 405                                                 longest = n;
 406                                         n = 0;
 407                                 }
 408                                 nls = FALSE; /* See declaration comment */
 409                                 p++;
 410                                 continue;
 411                         }
 412                 }
 413
 414                 /* Check for backslash character */
 415                 if (*p == '\\') {
 416                         /* If second backslash, count as a single-char */
 417                         if ((backslash ^= 1) == 0)
 418                                 n++;
 419                 } else if (backslash) {
 420                         if (*p == 'n' && !use_libdialog) { /* new line */
 421                                 /* NB: dialog(3) ignores escaped newlines */
 422                                 nls = TRUE; /* See declaration comment */
 423                                 if (n > longest)
 424                                         longest = n;
 425                                 n = 0;
 426                         } else if (use_color && *p == 'Z') {
 427                                 if (*++p != '\0')
 428                                         p++;
 429                                 backslash = 0;
 430                                 continue;
 431                         } else /* [X]dialog(1)/dialog(3) only expand those */
 432                                 n += 2;
 433
 434                         backslash = 0;
 435                 } else
 436                         n++;
 437                 p++;
 438         }
 439         if (n > longest)
 440                 longest = n;
 441
 442         return (longest);
 443 }
 444
 445 /*
 446  * Returns a pointer to the last line in buffer pointed to by `prompt'. Takes
 447  * both newlines (if using dialog(1) versus Xdialog(1)) and escaped newlines
 448  * into account. If no newlines (escaped or otherwise) appear in the buffer,
 449  * `prompt' is returned. If passed a NULL pointer, returns NULL.
 450  */
 451 char *
 452 dialog_prompt_lastline(char *prompt, uint8_t nlstate)
 453 {
 454         uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
 455         char *lastline;
 456         char *p;
 457
 458         if (prompt == NULL)
 459                 return (NULL);
 460         if (*prompt == '\0')
 461                 return (prompt); /* shortcut */
 462
 463         lastline = p = prompt;
 464         while (*p != '\0') {
 465                 /* dialog(1) and dialog(3) will render literal newlines */
 466                 if (use_dialog || use_libdialog) {
 467                         if (*p == '\n') {
 468                                 if (use_libdialog || !nls)
 469                                         lastline = p + 1;
 470                                 nls = FALSE; /* See declaration comment */
 471                         }
 472                 }
 473                 /* dialog(3) does not expand escaped newlines */
 474                 if (use_libdialog) {
 475                         p++;
 476                         continue;
 477                 }
 478                 if (*p == '\\' && *(p + 1) != '\0' && *(++p) == 'n') {
 479                         nls = TRUE; /* See declaration comment */
 480                         lastline = p + 1;
 481                 }
 482                 p++;
 483         }
 484
 485         return (lastline);
 486 }
 487
 488 /*
 489  * Returns the number of extra lines generated by wrapping the text in buffer
 490  * pointed to by `prompt' within `ncols' columns (for prompts, this should be
 491  * dwidth - 4). Also discounts dialog(1) color escape codes if enabled (via
 492  * `use_color' global).
 493  */
 494 int
 495 dialog_prompt_wrappedlines(char *prompt, int ncols, uint8_t nlstate)
 496 {
 497         uint8_t backslash = 0;
 498         uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
 499         char *cp;
 500         char *p = prompt;
 501         int n = 0;
 502         int wlines = 0;
 503
 504         /* `prompt' parameter is required */
 505         if (p == NULL)
 506                 return (0);
 507         if (*p == '\0')
 508                 return (0); /* shortcut */
 509
 510         /* Loop until the end of the string */
 511         while (*p != '\0') {
 512                 /* dialog(1) and dialog(3) will render literal newlines */
 513                 if (use_dialog || use_libdialog) {
 514                         if (*p == '\n') {
 515                                 if (use_dialog || !nls)
 516                                         n = 0;
 517                                 nls = FALSE; /* See declaration comment */
 518                         }
 519                 }
 520
 521                 /* Check for backslash character */
 522                 if (*p == '\\') {
 523                         /* If second backslash, count as a single-char */
 524                         if ((backslash ^= 1) == 0)
 525                                 n++;
 526                 } else if (backslash) {
 527                         if (*p == 'n' && !use_libdialog) { /* new line */
 528                                 /* NB: dialog(3) ignores escaped newlines */
 529                                 nls = TRUE; /* See declaration comment */
 530                                 n = 0;
 531                         } else if (use_color && *p == 'Z') {
 532                                 if (*++p != '\0')
 533                                         p++;
 534                                 backslash = 0;
 535                                 continue;
 536                         } else /* [X]dialog(1)/dialog(3) only expand those */
 537                                 n += 2;
 538
 539                         backslash = 0;
 540                 } else
 541                         n++;
 542
 543                 /* Did we pass the width barrier? */
 544                 if (n > ncols) {
 545                         /*
 546                          * Work backward to find the first whitespace on-which
 547                          * dialog(1) will wrap the line (but don't go before
 548                          * the start of this line).
 549                          */
 550                         cp = p;
 551                         while (n > 1 && !isspace(*cp)) {
 552                                 cp--;
 553                                 n--;
 554                         }
 555                         if (n > 0 && isspace(*cp))
 556                                 p = cp;
 557                         wlines++;
 558                         n = 1;
 559                 }
 560
 561                 p++;
 562         }
 563
 564         return (wlines);
 565 }
 566
 567 /*
 568  * Returns zero if the buffer pointed to by `prompt' contains an escaped
 569  * newline but only if appearing after any/all literal newlines. This is
 570  * specific to dialog(1) and does not apply to Xdialog(1).
 571  *
 572  * As an attempt to make shell scripts easier to read, dialog(1) will "eat"
 573  * the first literal newline after an escaped newline. This however has a bug
 574  * in its implementation in that rather than allowing `\\n\n' to be treated
 575  * similar to `\\n' or `\n', dialog(1) expands the `\\n' and then translates
 576  * the following literal newline (with or without characters between [!]) into
 577  * a single space.
 578  *
 579  * If you want to be compatible with Xdialog(1), it is suggested that you not
 580  * use literal newlines (they aren't supported); but if you have to use them,
 581  * go right ahead. But be forewarned... if you set $DIALOG in your environment
 582  * to something other than `cdialog' (our current dialog(1)), then it should
 583  * do the same thing w/respect to how to handle a literal newline after an
 584  * escaped newline (you could do no wrong by translating every literal newline
 585  * into a space but only when you've previously encountered an escaped one;
 586  * this is what dialog(1) is doing).
 587  *
 588  * The ``newline state'' (or nlstate for short; as I'm calling it) is helpful
 589  * if you plan to combine multiple strings into a single prompt text. In lead-
 590  * up to this procedure, a common task is to calculate and utilize the widths
 591  * and heights of each piece of prompt text to later be combined. However, if
 592  * (for example) the first string ends in a positive newline state (has an
 593  * escaped newline without trailing literal), the first literal newline in the
 594  * second string will be mangled.
 595  *
 596  * The return value of this function should be used as the `nlstate' argument
 597  * to dialog_*() functions that require it to allow accurate calculations in
 598  * the event such information is needed.
 599  */
 600 uint8_t
 601 dialog_prompt_nlstate(const char *prompt)
 602 {
 603         const char *cp;
 604
 605         if (prompt == NULL)
 606                 return 0;
 607
 608         /*
 609          * Work our way backward from the end of the string for efficiency.
 610          */
 611         cp = prompt + strlen(prompt);
 612         while (--cp >= prompt) {
 613                 /*
 614                  * If we get to a literal newline first, this prompt ends in a
 615                  * clean state for rendering with dialog(1). Otherwise, if we
 616                  * get to an escaped newline first, this prompt ends in an un-
 617                  * clean state (following literal will be mangled; see above).
 618                  */
 619                 if (*cp == '\n')
 620                         return (0);
 621                 else if (*cp == 'n' && --cp > prompt && *cp == '\\')
 622                         return (1);
 623         }
 624
 625         return (0); /* no newlines (escaped or otherwise) */
 626 }
 627
 628 /*
 629  * Free allocated items initialized by tty_maxsize_update() and
 630  * x11_maxsize_update()
 631  */
 632 void
 633 dialog_maxsize_free(void)
 634 {
 635         if (maxsize != NULL) {
 636                 free(maxsize);
 637                 maxsize = NULL;
 638         }
 639 }