1 /* 2 * $Id: dialog.c,v 1.289 2022/07/28 21:11:36 tom Exp $ 3 * 4 * cdialog - Display simple dialog boxes from shell scripts 5 * 6 * Copyright 2000-2021,2022 Thomas E. Dickey 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU Lesser General Public License, version 2.1 10 * as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this program; if not, write to 19 * Free Software Foundation, Inc. 20 * 51 Franklin St., Fifth Floor 21 * Boston, MA 02110, USA. 22 * 23 * An earlier version of this program lists as authors 24 * Savio Lam (lam836@cs.cuhk.hk) 25 */ 26 27 #include <dlg_internals.h> 28 29 #define USEMAX_ARGS 20 30 #define USEMAX_FILE 50 31 32 #define PASSARGS t, av, offset_add 33 #define CALLARGS const char *t, char *av[], int *offset_add 34 typedef int (callerFn) (CALLARGS); 35 36 typedef enum { 37 o_unknown = 0 38 ,o_allow_close 39 ,o_and_widget 40 ,o_ascii_lines 41 ,o_aspect_ratio 42 ,o_auto_placement 43 ,o_backtitle 44 ,o_beep_signal 45 ,o_beep_after_signal 46 ,o_begin_set 47 ,o_cancel_label 48 ,o_checklist 49 ,o_dlg_clear_screen 50 ,o_colors 51 ,o_column_separator 52 ,o_cr_wrap 53 ,o_create_rc 54 ,o_cursor_off_label 55 ,o_date_format 56 ,o_default_button 57 ,o_default_item 58 ,o_defaultno 59 ,o_erase_on_exit 60 ,o_exit_label 61 ,o_extra_button 62 ,o_extra_label 63 ,o_fixed_font 64 ,o_form 65 ,o_gauge 66 ,o_help 67 ,o_help_button 68 ,o_help_file 69 ,o_help_label 70 ,o_help_line 71 ,o_help_status 72 ,o_help_tags 73 ,o_icon 74 ,o_ignore 75 ,o_infobox 76 ,o_input_fd 77 ,o_inputbox 78 ,o_inputmenu 79 ,o_insecure 80 ,o_item_help 81 ,o_keep_colors 82 ,o_keep_tite 83 ,o_keep_window 84 ,o_last_key 85 ,o_max_input 86 ,o_menu 87 ,o_mixedform 88 ,o_mixedgauge 89 ,o_msgbox 90 ,o_no_close 91 ,o_nocollapse 92 ,o_no_cr_wrap 93 ,o_cant_kill 94 ,o_no_hot_list 95 ,o_no_label 96 ,o_no_lines 97 ,o_no_mouse 98 ,o_no_nl_expand 99 ,o_use_shadow 100 ,o_nocancel 101 ,o_nook 102 ,o_ok_label 103 ,o_output_fd 104 ,o_output_separator 105 ,o_passwordbox 106 ,o_passwordform 107 ,o_pause 108 ,o_prgbox 109 ,o_print_maxsize 110 ,o_print_siz 111 ,o_text_only 112 ,o_print_text_size 113 ,o_print_version 114 ,o_programbox 115 ,o_progressbox 116 ,o_quoted 117 ,o_radiolist 118 ,o_screen_center 119 ,o_use_scrollbar 120 ,o_separate_output 121 ,o_separate_str 122 ,o_single_quoted 123 ,o_size_err 124 ,o_sleep_secs 125 ,o_smooth 126 ,o_output_stderr 127 ,o_output_stdout 128 ,o_tab_correct 129 ,o_tab_len 130 ,o_tailbox 131 ,o_tailboxbg 132 ,o_textbox 133 ,o_time_format 134 ,o_timeout_secs 135 ,o_title 136 ,o_trim_whitespace 137 ,o_under_mouse 138 ,o_version 139 ,o_visit_items 140 ,o_wmclass 141 ,o_yes_label 142 ,o_yesno 143 #ifdef HAVE_WHIPTAIL 144 ,o_fullbutton 145 ,o_topleft 146 #endif 147 #ifdef HAVE_XDIALOG 148 ,o_calendar 149 ,o_dselect 150 ,o_editbox 151 ,o_fselect 152 ,o_timebox 153 ,o_week_start 154 #endif 155 #ifdef HAVE_XDIALOG2 156 ,o_buildlist 157 ,o_rangebox 158 ,o_reorder 159 ,o_treeview 160 #endif 161 #if defined(HAVE_XDIALOG2) || defined(HAVE_WHIPTAIL) 162 ,o_no_items 163 ,o_no_tags 164 #endif 165 #ifdef HAVE_DLG_TRACE 166 ,o_trace 167 #endif 168 ,o_iso_week 169 } eOptions; 170 171 typedef enum { 172 tUnknown 173 ,tFalse 174 ,tTrue 175 ,tNumber 176 ,tString 177 } tOptions; 178 179 /* 180 * The bits in 'pass' are used to decide which options are applicable at 181 * different stages in the program: 182 * 1 flags before widgets 183 * 2 widgets 184 * 4 non-widget options 185 */ 186 typedef struct { 187 const char *name; 188 eOptions code; 189 int vars; /* 0=none, 1=state, 2=vars */ 190 tOptions type; /* type for bool(true/false), number, string */ 191 unsigned offset; 192 int pass; /* 1,2,4 or combination */ 193 const char *help; /* NULL to suppress, non-empty to display params */ 194 } Options; 195 196 typedef struct { 197 eOptions code; 198 int argmin, argmax; 199 callerFn *jumper; 200 } Mode; 201 202 /* use these macros for simple options in DIALOG_STATE */ 203 #define ssF(name) o_##name, 1, tFalse, offsetof(DIALOG_STATE,name) 204 #define ssT(name) o_##name, 1, tTrue, offsetof(DIALOG_STATE,name) 205 #define ssN(name) o_##name, 1, tNumber, offsetof(DIALOG_STATE,name) 206 #define ssS(name) o_##name, 1, tString, offsetof(DIALOG_STATE,name) 207 208 /* use these macros for simple options in DIALOG_VARS */ 209 #define svF(name) o_##name, 2, tFalse, offsetof(DIALOG_VARS,name) 210 #define svT(name) o_##name, 2, tTrue, offsetof(DIALOG_VARS,name) 211 #define svN(name) o_##name, 2, tNumber, offsetof(DIALOG_VARS,name) 212 #define svS(name) o_##name, 2, tString, offsetof(DIALOG_VARS,name) 213 214 /* use these macros for ignored options */ 215 #define xxF(name) o_##name, 0, tFalse, 0 216 #define xxT(name) o_##name, 0, tTrue, 0 217 #define xxN(name) o_##name, 0, tNumber, 0 218 #define xxS(name) o_##name, 0, tString, 0 219 220 /* use this macro for widget options */ 221 #define opW(name) o_##name, 0, 0, 0 222 223 /* use this macro for other options */ 224 #define opO(name) o_##name, 0, 0, 0 225 226 static int known_opts = 0; 227 static const char **dialog_opts; 228 static char **dialog_argv; 229 230 static char **special_argv = 0; 231 static int special_argc = 0; 232 233 static bool ignore_unknown = FALSE; 234 235 static const char *program = "dialog"; 236 237 #ifdef NO_LEAKS 238 typedef struct _all_blobs { 239 struct _all_blobs *next; 240 void *blob; 241 } AllBlobs; 242 243 static AllBlobs *all_blobs; 244 #endif 245 246 /* 247 * The options[] table is organized this way to make it simple to maintain 248 * a sorted list of options for the help-message. 249 * 250 * Because Boolean options correspond to "true", --shadow is listed here while 251 * --no-shadow is not. The findOption and optionBool functions handle the 252 * cases where "no" is added or removed from the option name to derive an 253 * opposite setting. 254 */ 255 /* *INDENT-OFF* */ 256 static const Options options[] = { 257 { "allow-close", xxT(allow_close), 1, NULL }, 258 { "and-widget", opO(and_widget), 4, NULL }, 259 { "ascii-lines", svT(ascii_lines), 1, "" }, 260 { "aspect", ssN(aspect_ratio), 1, "<ratio>" }, 261 { "auto-placement", xxT(auto_placement), 1, NULL }, 262 { "backtitle", svS(backtitle), 1, "<backtitle>" }, 263 { "beep", svT(beep_signal), 1, "" }, 264 { "beep-after", svT(beep_after_signal), 1, "" }, 265 { "begin", svT(begin_set), 1, "<y> <x>" }, 266 { "cancel-label", svS(cancel_label), 1, "<str>" }, 267 { "checklist", opW(checklist), 2, "<text> <height> <width> <list height> <tag1> <item1> <status1>..." }, 268 { "clear", svT(dlg_clear_screen), 1, "" }, 269 { "colors", svT(colors), 1, "" }, 270 { "column-separator",svS(column_separator), 1, "<str>" }, 271 { "cr-wrap", svT(cr_wrap), 1, "" }, 272 { "create-rc", opO(create_rc), 1, NULL }, 273 { "cursor-off-label",svT(cursor_off_label), 1, "" }, 274 { "date-format", svS(date_format), 1, "<str>" }, 275 { "default-button", xxS(default_button), 1, "<str>" }, 276 { "default-item", svS(default_item), 1, "<str>" }, 277 { "defaultno", svT(defaultno), 1, "" }, 278 { "erase-on-exit", svT(erase_on_exit), 1, "" }, 279 { "exit-label", svS(exit_label), 1, "<str>" }, 280 { "extra-button", svT(extra_button), 1, "" }, 281 { "extra-label", svS(extra_label), 1, "<str>" }, 282 { "fixed-font", xxT(fixed_font), 1, NULL }, 283 { "form", opW(form), 2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>..." }, 284 { "gauge", opW(gauge), 2, "<text> <height> <width> [<percent>]" }, 285 { "guage", opW(gauge), 2, NULL }, 286 { "help", opO(help), 4, "" }, 287 { "help-button", svT(help_button), 1, "" }, 288 { "help-label", svS(help_label), 1, "<str>" }, 289 { "help-status", svT(help_status), 1, "" }, 290 { "help-tags", svT(help_tags), 1, "" }, 291 { "hfile", svS(help_file), 1, "<str>" }, 292 { "hline", svS(help_line), 1, "<str>" }, 293 { "icon", xxS(icon), 1, NULL }, 294 { "ignore", opO(ignore), 1, "" }, 295 { "infobox", opW(infobox), 2, "<text> <height> <width>" }, 296 { "input-fd", opO(input_fd), 1, "<fd>" }, 297 { "inputbox", opW(inputbox), 2, "<text> <height> <width> [<init>]" }, 298 { "inputmenu", opW(inputmenu), 2, "<text> <height> <width> <menu height> <tag1> <item1>..." }, 299 { "insecure", svT(insecure), 1, "" }, 300 { "item-help", svT(item_help), 1, "" }, 301 { "keep-colors", xxT(keep_colors), 1, NULL }, 302 { "keep-tite", svT(keep_tite), 1, "" }, 303 { "keep-window", svT(keep_window), 1, "" }, 304 { "last-key", svT(last_key), 1, "" }, 305 { "max-input", svN(max_input), 1, "<n>" }, 306 { "menu", opW(menu), 2, "<text> <height> <width> <menu height> <tag1> <item1>..." }, 307 { "mixedform", opW(mixedform), 2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1> <itype>..." }, 308 { "mixedgauge", opW(mixedgauge), 2, "<text> <height> <width> <percent> <tag1> <item1>..." }, 309 { "msgbox", opW(msgbox), 2, "<text> <height> <width>" }, 310 { "no-cancel", svT(nocancel), 1, "" }, 311 { "no-close", xxT(no_close), 1, NULL }, 312 { "no-collapse", svT(nocollapse), 1, "" }, 313 { "no-hot-list", svT(no_hot_list), 1, "" }, 314 { "no-kill", svT(cant_kill), 1, "" }, 315 { "no-label", svS(no_label), 1, "<str>" }, 316 { "no-lines", svT(no_lines), 1, "" }, 317 { "no-mouse", ssT(no_mouse), 1, "" }, 318 { "no-nl-expand", svT(no_nl_expand), 1, "" }, 319 { "no-ok", svT(nook), 1, "" }, 320 { "no-shadow", ssF(use_shadow), 1, "" }, 321 { "ok-label", svS(ok_label), 1, "<str>" }, 322 { "output-fd", opO(output_fd), 1, "<fd>" }, 323 { "output-separator",svS(output_separator), 1, "<str>" }, 324 { "passwordbox", opW(passwordbox), 2, "<text> <height> <width> [<init>]" }, 325 { "passwordform", opW(passwordform), 2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>..." }, 326 { "pause", opW(pause), 2, "<text> <height> <width> <seconds>" }, 327 { "prgbox", opW(prgbox), 2, "<text> <command> <height> <width>" }, 328 { "print-maxsize", opO(print_maxsize), 1, "" }, 329 { "print-size", svT(print_siz), 1, "" }, 330 { "print-text-only",ssT(text_only), 5, "<text> <height> <width>" }, 331 { "print-text-size",opO(print_text_size), 5, "<text> <height> <width>" }, 332 { "print-version", opO(print_version), 5, "" }, 333 { "programbox", opW(programbox), 2, "<text> <height> <width>" }, 334 { "progressbox", opW(progressbox), 2, "<text> <height> <width>" }, 335 { "quoted", svT(quoted), 1, "" }, 336 { "radiolist", opW(radiolist), 2, "<text> <height> <width> <list height> <tag1> <item1> <status1>..." }, 337 { "screen-center", xxT(screen_center), 1, NULL }, 338 { "scrollbar", ssT(use_scrollbar), 1, "" }, 339 { "separate-output",svT(separate_output), 1, "" }, 340 { "separate-widget",ssS(separate_str), 1, "<str>" }, 341 { "separator", svS(output_separator), 1, NULL }, 342 { "single-quoted", svT(single_quoted), 1, "" }, 343 { "size-err", svT(size_err), 1, "" }, 344 { "sleep", svN(sleep_secs), 1, "<secs>" }, 345 { "smooth", xxT(smooth), 1, NULL }, 346 { "stderr", opO(output_stderr), 1, "" }, 347 { "stdout", opO(output_stdout), 1, "" }, 348 { "tab-correct", svT(tab_correct), 1, "" }, 349 { "tab-len", ssN(tab_len), 1, "<n>" }, 350 { "tailbox", opW(tailbox), 2, "<file> <height> <width>" }, 351 { "tailboxbg", opW(tailboxbg), 2, "<file> <height> <width>" }, 352 { "textbox", opW(textbox), 2, "<file> <height> <width>" }, 353 { "time-format", svS(time_format), 1, "<str>" }, 354 { "timeout", svN(timeout_secs), 1, "<secs>" }, 355 { "title", svS(title), 1, "<title>" }, 356 { "trim", svT(trim_whitespace), 1, "" }, 357 { "under-mouse", xxT(under_mouse), 1, NULL }, 358 { "version", opO(version), 5, "" }, 359 { "visit-items", ssT(visit_items), 1, "" }, 360 { "wmclass", xxS(wmclass), 1, NULL }, 361 { "yes-label", svS(yes_label), 1, "<str>" }, 362 { "yesno", opW(yesno), 2, "<text> <height> <width>" }, 363 #ifdef HAVE_WHIPTAIL 364 { "cancel-button", svS(cancel_label), 1, NULL }, 365 { "fb", xxT(fullbutton), 1, NULL }, 366 { "fullbutton", xxT(fullbutton), 1, NULL }, 367 { "no-button", svS(no_label), 1, NULL }, 368 { "ok-button", svS(ok_label), 1, NULL }, 369 { "scrolltext", ssT(use_scrollbar), 1, NULL }, 370 { "topleft", svT(begin_set), 1, NULL }, 371 { "yes-button", svS(yes_label), 1, NULL }, 372 #endif 373 #ifdef HAVE_XDIALOG 374 { "calendar", opW(calendar), 2, "<text> <height> <width> <day> <month> <year>" }, 375 { "dselect", opW(dselect), 2, "<directory> <height> <width>" }, 376 { "editbox", opW(editbox), 2, "<file> <height> <width>" }, 377 { "fselect", opW(fselect), 2, "<filepath> <height> <width>" }, 378 { "timebox", opW(timebox), 2, "<text> <height> <width> <hour> <minute> <second>" }, 379 { "week-start", svS(week_start), 1, "<str>" }, 380 { "iso-week", svT(iso_week), 1, NULL }, 381 #endif 382 #ifdef HAVE_XDIALOG2 383 { "buildlist", opW(buildlist), 2, "<text> <height> <width> <list-height> <tag1> <item1> <status1>..." }, 384 { "no-items", svT(no_items), 1, "" }, 385 { "no-tags", svT(no_tags), 1, "" }, 386 { "rangebox", opW(rangebox), 2, "<text> <height> <width> <min-value> <max-value> <default-value>" }, 387 { "reorder", svT(reorder), 1, "" }, 388 { "treeview", opW(treeview), 2, "<text> <height> <width> <list-height> <tag1> <item1> <status1> <depth1>..." }, 389 #endif 390 #if defined(HAVE_XDIALOG2) || defined(HAVE_WHIPTAIL) 391 { "noitem", svT(no_items), 1, NULL }, 392 { "notags", svT(no_tags), 1, NULL }, 393 #endif 394 #ifdef HAVE_DLG_TRACE 395 { "trace", opO(trace), 1, "<file>" }, 396 #endif 397 }; 398 /* *INDENT-ON* */ 399 400 #ifdef NO_LEAKS 401 static void 402 ignore_leak(void *value) 403 { 404 AllBlobs *next = dlg_calloc(AllBlobs, (size_t) 1); 405 if (next != 0) { 406 next->blob = value; 407 next->next = all_blobs; 408 all_blobs = next; 409 } 410 } 411 412 static void 413 handle_leaks(void) 414 { 415 while (all_blobs != 0) { 416 char *blob = all_blobs->blob; 417 AllBlobs *next = all_blobs->next; 418 free(blob); 419 free(all_blobs); 420 all_blobs = next; 421 } 422 free(dialog_opts); 423 if (special_argv != 0) { 424 free(special_argv[0]); 425 free(special_argv); 426 special_argv = 0; 427 special_argc = 0; 428 } 429 } 430 #else 431 #define handle_leaks() /* nothing */ 432 #define ignore_leak(n) /* nothing */ 433 #endif 434 435 #define OptionChars "\ 436 0123456789\ 437 -\ 438 abcdefghijklmnopqrstuvwxyz\ 439 " 440 441 /* 442 * Check if the given string from main's argv is an option. 443 */ 444 static bool 445 isOption(const char *arg) 446 { 447 bool result = FALSE; 448 449 if (arg != 0) { 450 if (dialog_opts != 0) { 451 int n; 452 for (n = 0; dialog_opts[n] != 0; ++n) { 453 if (dialog_opts[n] == arg) { 454 result = TRUE; 455 break; 456 } 457 } 458 } else if (!strncmp(arg, "--", (size_t) 2) && isalpha(UCH(arg[2]))) { 459 if (strlen(arg) == (strspn) (arg, OptionChars)) { 460 result = TRUE; 461 } else { 462 handle_leaks(); 463 dlg_exiterr(_("Invalid option \"%s\""), arg); 464 } 465 } 466 } 467 return result; 468 } 469 470 /* 471 * Make an array showing which argv[] entries are options. Use "--" as a 472 * special token to escape the next argument, allowing it to begin with "--". 473 * When we find a "--" argument, also remove it from argv[] and adjust argc. 474 * That appears to be an undocumented feature of the popt library. 475 * 476 * Also, if we see a "--file", expand it into the parameter list by reading the 477 * text from the given file and stripping quotes, treating whitespace outside 478 * quotes as a parameter delimiter. 479 * 480 * Finally, if we see a "--args", dump the current list of arguments to the 481 * standard error. This is used for debugging complex --file combinations. 482 */ 483 static void 484 unescape_argv(int *argcp, char ***argvp) 485 { 486 int j, k; 487 int limit_includes = 20 + *argcp; 488 int count_includes = 0; 489 bool doalloc = FALSE; 490 char *filename; 491 const char **my_argv = 0; 492 int my_argc; 493 494 DLG_TRACE(("# unescape_argv\n")); 495 for (k = 0; k < 2; ++k) { 496 497 my_argc = 0; 498 if (special_argv != 0) { 499 for (j = 0; special_argv[j] != 0; ++j) { 500 if (!strcmp(special_argv[j], "--")) { 501 break; 502 } else if (isOption(special_argv[j])) { 503 if (k != 0) 504 my_argv[my_argc] = special_argv[j]; 505 my_argc++; 506 } 507 } 508 } 509 510 if (k == 0) { 511 my_argc += (*argcp + 1); 512 my_argv = dlg_calloc(const char *, (size_t) my_argc); 513 assert_ptr(my_argv, "unescape_argv"); 514 } 515 } 516 517 for (j = 1; j < *argcp; j++) { 518 bool escaped = FALSE; 519 if (!strcmp((*argvp)[j], "--")) { 520 escaped = TRUE; 521 dlg_eat_argv(argcp, argvp, j, 1); 522 } else if (!strcmp((*argvp)[j], "--args")) { 523 fprintf(stderr, _("Showing arguments at arg%d\n"), j); 524 for (k = 0; k < *argcp; ++k) { 525 fprintf(stderr, " arg%d:%s\n", k, (*argvp)[k]); 526 } 527 dlg_eat_argv(argcp, argvp, j, 1); 528 --j; 529 } else if (!strcmp((*argvp)[j], "--file")) { 530 if (++count_includes > limit_includes) { 531 handle_leaks(); 532 dlg_exiterr(_("Too many --file options")); 533 } 534 535 if ((filename = (*argvp)[j + 1]) != 0) { 536 FILE *fp; 537 char **list; 538 539 if (*filename == '&') { 540 fp = fdopen(atoi(filename + sizeof(char)), "r"); 541 } else { 542 fp = fopen(filename, "r"); 543 } 544 545 if (fp) { 546 char *blob; 547 int added; 548 size_t bytes_read; 549 size_t length; 550 int n; 551 552 DLG_TRACE(("# opened --file %s ..\n", filename)); 553 blob = NULL; 554 length = 0; 555 do { 556 blob = dlg_realloc(char, length + BUFSIZ + 1, blob); 557 assert_ptr(blob, "unescape_argv"); 558 bytes_read = fread(blob + length, 559 sizeof(char), 560 (size_t) BUFSIZ, 561 fp); 562 length += bytes_read; 563 if (ferror(fp)) { 564 handle_leaks(); 565 dlg_exiterr(_("error on filehandle in unescape_argv")); 566 } 567 } while (bytes_read == BUFSIZ); 568 fclose(fp); 569 570 blob[length] = '\0'; 571 ignore_leak(blob); 572 573 list = dlg_string_to_argv(blob); 574 added = dlg_count_argv(list); 575 if (added > 2) { 576 /* *argcp arguments before the expansion of --file 577 - 2 for the removal of '--file <filepath>' 578 + added for the arguments contained in <filepath> 579 + 1 for the terminating NULL pointer */ 580 size_t need = (size_t) (*argcp + added - 1); 581 if (doalloc) { 582 *argvp = dlg_realloc(char *, need, *argvp); 583 assert_ptr(*argvp, "unescape_argv"); 584 } else { 585 char **newp = dlg_malloc(char *, need); 586 ignore_leak(newp); 587 assert_ptr(newp, "unescape_argv"); 588 for (n = 0; n < *argcp; ++n) { 589 newp[n] = (*argvp)[n]; 590 } 591 /* The new array is not NULL-terminated yet. */ 592 *argvp = newp; 593 doalloc = TRUE; 594 } 595 my_argv = dlg_realloc(const char *, need, my_argv); 596 assert_ptr(my_argv, "unescape_argv"); 597 598 /* Shift the arguments after '--file <filepath>' 599 right by (added - 2) positions */ 600 for (n = *argcp - 1; n >= j + 2; --n) { 601 (*argvp)[n + added - 2] = (*argvp)[n]; 602 } 603 } else if (added < 2) { 604 /* 0 or 1 argument read from the included file 605 -> shift the arguments after '--file <filepath>' 606 left by (2 - added) positions */ 607 for (n = j + added; n + 2 - added < *argcp; ++n) { 608 (*argvp)[n] = (*argvp)[n + 2 - added]; 609 } 610 } 611 /* Copy the inserted arguments to *argvp */ 612 for (n = 0; n < added; ++n) { 613 (*argvp)[n + j] = list[n]; 614 } 615 *argcp += added - 2; 616 (*argvp)[*argcp] = 0; /* Write the NULL terminator */ 617 free(list); /* No-op if 'list' is NULL */ 618 /* Force rescan starting from the first inserted argument */ 619 --j; 620 DLG_TRACE(("# finished --file\n")); 621 continue; 622 } else { 623 handle_leaks(); 624 dlg_exiterr(_("Cannot open --file %s"), filename); 625 } 626 } else { 627 handle_leaks(); 628 dlg_exiterr(_("No value given for --file")); 629 } 630 } 631 if (!escaped 632 && (*argvp)[j] != 0 633 && !strncmp((*argvp)[j], "--", (size_t) 2) 634 && isalpha(UCH((*argvp)[j][2]))) { 635 my_argv[my_argc++] = (*argvp)[j]; 636 DLG_TRACE(("#\toption argv[%d]=%s\n", j, (*argvp)[j])); 637 } 638 } 639 640 my_argv[my_argc] = 0; 641 642 known_opts = my_argc; 643 dialog_opts = my_argv; 644 645 DLG_TRACE(("#\t%d options vs %d arguments\n", known_opts, *argcp)); 646 dialog_argv = (*argvp); 647 } 648 649 static const Options * 650 findOption(const char *name, int pass, bool recur) 651 { 652 const Options *result = NULL; 653 654 if (!strncmp(name, "--", 2) && isalpha(UCH(name[2]))) { 655 unsigned n; 656 657 name += 2; /* skip the "--" */ 658 for (n = 0; n < TableSize(options); n++) { 659 if ((pass & options[n].pass) != 0 660 && !strcmp(name, options[n].name)) { 661 result = &options[n]; 662 break; 663 } 664 } 665 if (result == NULL && !recur) { 666 char *temp = malloc(8 + strlen(name)); 667 if (temp != NULL) { 668 if (!strncmp(name, "no", 2)) { 669 int skip = !strncmp(name, "no-", 3) ? 3 : 2; 670 sprintf(temp, "--no-%s", name + skip); 671 result = findOption(temp, pass, TRUE); 672 if (result == NULL) { 673 sprintf(temp, "--%s", name + skip); 674 result = findOption(temp, pass, TRUE); 675 } 676 } 677 if (result == NULL && strncmp(name, "no", 2)) { 678 sprintf(temp, "--no-%s", name); 679 result = findOption(temp, pass, TRUE); 680 } 681 free(temp); 682 } 683 } 684 } 685 return result; 686 } 687 688 static eOptions 689 lookupOption(const char *name, int pass) 690 { 691 eOptions result = o_unknown; 692 const Options *data = findOption(name, pass, FALSE); 693 if (data != NULL) { 694 result = data->code; 695 } 696 return result; 697 } 698 699 static void 700 Usage(const char *msg) 701 { 702 handle_leaks(); 703 dlg_exiterr(_("%s.\nUse --help to list options.\n\n"), msg); 704 } 705 706 /* 707 * Count arguments, stopping at the end of the argument list, or on any of our 708 * "--" tokens. 709 */ 710 static int 711 arg_rest(char *argv[]) 712 { 713 int i = 1; /* argv[0] points to a "--" token */ 714 715 while (argv[i] != 0 716 && (!isOption(argv[i]) || lookupOption(argv[i], 7) == o_unknown)) 717 i++; 718 return i; 719 } 720 721 /* 722 * In MultiWidget this function is needed to count how many tags 723 * a widget (menu, checklist, radiolist) has 724 */ 725 static int 726 howmany_tags(char *argv[], int group) 727 { 728 int result = 0; 729 char temp[80]; 730 731 while (argv[0] != 0) { 732 int have; 733 734 if (isOption(argv[0])) 735 break; 736 if ((have = arg_rest(argv)) < group) { 737 const char *format = _("Expected %d arguments, found only %d"); 738 sprintf(temp, format, group, have); 739 Usage(temp); 740 } else if ((have % group) != 0) { 741 const char *format = _("Expected %d arguments, found extra %d"); 742 sprintf(temp, format, group, (have % group)); 743 Usage(temp); 744 } 745 746 argv += have; 747 result += (have / group); 748 } 749 750 return result; 751 } 752 753 static int 754 numeric_arg(char **av, int n) 755 { 756 int result = 0; 757 758 if (n < dlg_count_argv(av)) { 759 char *last = 0; 760 result = (int) strtol(av[n], &last, 10); 761 762 if (last == 0 || *last != 0) { 763 char msg[80]; 764 765 sprintf(msg, _("Expected a number for token %d of %.*s"), n, 766 USEMAX_ARGS, av[0]); 767 Usage(msg); 768 } 769 } 770 return result; 771 } 772 773 static char * 774 optional_str(char **av, int n, char *dft) 775 { 776 char *ret = dft; 777 if (arg_rest(av) > n) 778 ret = av[n]; 779 return ret; 780 } 781 782 #if defined(HAVE_DLG_GAUGE) || defined(HAVE_XDIALOG) 783 static int 784 optional_num(char **av, int n, int dft) 785 { 786 int ret = dft; 787 if (arg_rest(av) > n) 788 ret = numeric_arg(av, n); 789 return ret; 790 } 791 #endif 792 793 /* 794 * On AIX 4.x, we have to flush the output right away since there is a bug in 795 * the curses package which discards stdout even when we've used newterm to 796 * redirect output to /dev/tty. 797 */ 798 static int 799 show_result(int ret) 800 { 801 bool either = FALSE; 802 803 switch (ret) { 804 case DLG_EXIT_OK: 805 case DLG_EXIT_EXTRA: 806 case DLG_EXIT_HELP: 807 case DLG_EXIT_ITEM_HELP: 808 if ((dialog_state.output_count > 1) && !dialog_vars.separate_output) { 809 fputs((dialog_state.separate_str 810 ? dialog_state.separate_str 811 : DEFAULT_SEPARATE_STR), 812 dialog_state.output); 813 either = TRUE; 814 } 815 if (dialog_vars.input_result != 0 816 && dialog_vars.input_result[0] != '\0') { 817 fputs(dialog_vars.input_result, dialog_state.output); 818 DLG_TRACE(("# input_result:\n%s\n", dialog_vars.input_result)); 819 either = TRUE; 820 } 821 if (either) { 822 fflush(dialog_state.output); 823 } 824 break; 825 } 826 return ret; 827 } 828 829 /* 830 * These are the widget callers. 831 */ 832 833 static int 834 call_yesno(CALLARGS) 835 { 836 *offset_add = 4; 837 return dialog_yesno(t, 838 av[1], 839 numeric_arg(av, 2), 840 numeric_arg(av, 3)); 841 } 842 843 static int 844 call_msgbox(CALLARGS) 845 { 846 *offset_add = 4; 847 return dialog_msgbox(t, 848 av[1], 849 numeric_arg(av, 2), 850 numeric_arg(av, 3), 1); 851 } 852 853 static int 854 call_infobox(CALLARGS) 855 { 856 *offset_add = 4; 857 return dialog_msgbox(t, 858 av[1], 859 numeric_arg(av, 2), 860 numeric_arg(av, 3), 0); 861 } 862 863 static int 864 call_textbox(CALLARGS) 865 { 866 *offset_add = 4; 867 return dialog_textbox(t, 868 av[1], 869 numeric_arg(av, 2), 870 numeric_arg(av, 3)); 871 } 872 873 static int 874 call_menu(CALLARGS) 875 { 876 int tags = howmany_tags(av + 5, MENUBOX_TAGS); 877 *offset_add = 5 + tags * MENUBOX_TAGS; 878 879 return dialog_menu(t, 880 av[1], 881 numeric_arg(av, 2), 882 numeric_arg(av, 3), 883 numeric_arg(av, 4), 884 tags, av + 5); 885 } 886 887 static int 888 call_inputmenu(CALLARGS) 889 { 890 int tags = howmany_tags(av + 5, MENUBOX_TAGS); 891 bool free_extra_label = FALSE; 892 int result; 893 894 dialog_vars.input_menu = TRUE; 895 896 if (dialog_vars.extra_label == 0) { 897 free_extra_label = TRUE; 898 dialog_vars.extra_label = dlg_strclone(_("Rename")); 899 } 900 901 dialog_vars.extra_button = TRUE; 902 903 *offset_add = 5 + tags * MENUBOX_TAGS; 904 result = dialog_menu(t, 905 av[1], 906 numeric_arg(av, 2), 907 numeric_arg(av, 3), 908 numeric_arg(av, 4), 909 tags, av + 5); 910 if (free_extra_label) { 911 free(dialog_vars.extra_label); 912 dialog_vars.extra_label = 0; 913 } 914 return result; 915 } 916 917 static int 918 call_checklist(CALLARGS) 919 { 920 int tags = howmany_tags(av + 5, CHECKBOX_TAGS); 921 int code; 922 923 *offset_add = 5 + tags * CHECKBOX_TAGS; 924 code = dialog_checklist(t, 925 av[1], 926 numeric_arg(av, 2), 927 numeric_arg(av, 3), 928 numeric_arg(av, 4), 929 tags, av + 5, FLAG_CHECK); 930 return code; 931 } 932 933 static int 934 call_radiolist(CALLARGS) 935 { 936 int tags = howmany_tags(av + 5, CHECKBOX_TAGS); 937 *offset_add = 5 + tags * CHECKBOX_TAGS; 938 return dialog_checklist(t, 939 av[1], 940 numeric_arg(av, 2), 941 numeric_arg(av, 3), 942 numeric_arg(av, 4), 943 tags, av + 5, FLAG_RADIO); 944 } 945 946 static int 947 call_inputbox(CALLARGS) 948 { 949 *offset_add = arg_rest(av); 950 return dialog_inputbox(t, 951 av[1], 952 numeric_arg(av, 2), 953 numeric_arg(av, 3), 954 optional_str(av, 4, 0), 0); 955 } 956 957 static int 958 call_passwordbox(CALLARGS) 959 { 960 *offset_add = arg_rest(av); 961 return dialog_inputbox(t, 962 av[1], 963 numeric_arg(av, 2), 964 numeric_arg(av, 3), 965 optional_str(av, 4, 0), 1); 966 } 967 968 #ifdef HAVE_XDIALOG 969 static int 970 call_calendar(CALLARGS) 971 { 972 *offset_add = arg_rest(av); 973 return dialog_calendar(t, 974 av[1], 975 numeric_arg(av, 2), 976 numeric_arg(av, 3), 977 optional_num(av, 4, -1), 978 optional_num(av, 5, -1), 979 optional_num(av, 6, -1)); 980 } 981 982 static int 983 call_dselect(CALLARGS) 984 { 985 *offset_add = arg_rest(av); 986 return dialog_dselect(t, 987 av[1], 988 numeric_arg(av, 2), 989 numeric_arg(av, 3)); 990 } 991 992 static int 993 call_editbox(CALLARGS) 994 { 995 *offset_add = 4; 996 return dialog_editbox(t, 997 av[1], 998 numeric_arg(av, 2), 999 numeric_arg(av, 3)); 1000 } 1001 1002 static int 1003 call_fselect(CALLARGS) 1004 { 1005 *offset_add = arg_rest(av); 1006 return dialog_fselect(t, 1007 av[1], 1008 numeric_arg(av, 2), 1009 numeric_arg(av, 3)); 1010 } 1011 1012 static int 1013 call_timebox(CALLARGS) 1014 { 1015 *offset_add = arg_rest(av); 1016 return dialog_timebox(t, 1017 av[1], 1018 numeric_arg(av, 2), 1019 numeric_arg(av, 3), 1020 optional_num(av, 4, -1), 1021 optional_num(av, 5, -1), 1022 optional_num(av, 6, -1)); 1023 } 1024 #endif /* HAVE_XDIALOG */ 1025 1026 /* dialog 1.2 widgets */ 1027 #ifdef HAVE_XDIALOG2 1028 1029 #define DisableNoTags() \ 1030 bool save_no_tags = dialog_vars.no_tags; \ 1031 bool save_no_items = dialog_vars.no_items; \ 1032 dialog_vars.no_tags = TRUE; \ 1033 dialog_vars.no_items = FALSE 1034 1035 #define RestoreNoTags() \ 1036 dialog_vars.no_tags = save_no_tags; \ 1037 dialog_vars.no_items = save_no_items 1038 1039 static int 1040 call_buildlist(CALLARGS) 1041 { 1042 int tags = howmany_tags(av + 5, CHECKBOX_TAGS); 1043 int result; 1044 1045 DisableNoTags(); 1046 1047 *offset_add = 5 + tags * CHECKBOX_TAGS; 1048 result = dialog_buildlist(t, 1049 av[1], 1050 numeric_arg(av, 2), 1051 numeric_arg(av, 3), 1052 numeric_arg(av, 4), 1053 tags, av + 5, 1054 dialog_vars.reorder); 1055 RestoreNoTags(); 1056 return result; 1057 } 1058 1059 static int 1060 call_rangebox(CALLARGS) 1061 { 1062 int min_value; 1063 1064 *offset_add = arg_rest(av); 1065 min_value = numeric_arg(av, 4); 1066 return dialog_rangebox(t, 1067 av[1], 1068 numeric_arg(av, 2), 1069 numeric_arg(av, 3), 1070 min_value, 1071 numeric_arg(av, 5), 1072 (*offset_add > 6) ? numeric_arg(av, 6) : min_value); 1073 } 1074 1075 static int 1076 call_treeview(CALLARGS) 1077 { 1078 int tags = howmany_tags(av + 5, TREEVIEW_TAGS); 1079 int result; 1080 1081 DisableNoTags(); 1082 1083 *offset_add = arg_rest(av); 1084 result = dialog_treeview(t, 1085 av[1], 1086 numeric_arg(av, 2), 1087 numeric_arg(av, 3), 1088 numeric_arg(av, 4), 1089 tags, av + 5, FLAG_RADIO); 1090 RestoreNoTags(); 1091 return result; 1092 } 1093 #endif /* HAVE_XDIALOG */ 1094 1095 #ifdef HAVE_DLG_FORMBOX 1096 static int 1097 call_form(CALLARGS) 1098 { 1099 int group = FORMBOX_TAGS; 1100 int tags = howmany_tags(av + 5, group); 1101 *offset_add = 5 + tags * group; 1102 1103 return dialog_form(t, 1104 av[1], 1105 numeric_arg(av, 2), 1106 numeric_arg(av, 3), 1107 numeric_arg(av, 4), 1108 tags, av + 5); 1109 } 1110 1111 static int 1112 call_password_form(CALLARGS) 1113 { 1114 unsigned save = dialog_vars.formitem_type; 1115 int result; 1116 1117 dialog_vars.formitem_type = 1; 1118 result = call_form(PASSARGS); 1119 dialog_vars.formitem_type = save; 1120 1121 return result; 1122 } 1123 #endif /* HAVE_DLG_FORMBOX */ 1124 1125 #ifdef HAVE_DLG_MIXEDFORM 1126 static int 1127 call_mixed_form(CALLARGS) 1128 { 1129 int group = MIXEDFORM_TAGS; 1130 int tags = howmany_tags(av + 5, group); 1131 *offset_add = 5 + tags * group; 1132 1133 return dialog_mixedform(t, 1134 av[1], 1135 numeric_arg(av, 2), 1136 numeric_arg(av, 3), 1137 numeric_arg(av, 4), 1138 tags, av + 5); 1139 } 1140 #endif /* HAVE_DLG_MIXEDFORM */ 1141 1142 #ifdef HAVE_DLG_GAUGE 1143 static int 1144 call_gauge(CALLARGS) 1145 { 1146 *offset_add = arg_rest(av); 1147 return dialog_gauge(t, 1148 av[1], 1149 numeric_arg(av, 2), 1150 numeric_arg(av, 3), 1151 optional_num(av, 4, 0)); 1152 } 1153 1154 static int 1155 call_pause(CALLARGS) 1156 { 1157 *offset_add = arg_rest(av); 1158 return dialog_pause(t, 1159 av[1], 1160 numeric_arg(av, 2), 1161 numeric_arg(av, 3), 1162 numeric_arg(av, 4)); 1163 } 1164 #endif 1165 1166 #ifdef HAVE_MIXEDGAUGE 1167 static int 1168 call_mixed_gauge(CALLARGS) 1169 { 1170 #define MIXEDGAUGE_BASE 5 1171 int tags = howmany_tags(av + MIXEDGAUGE_BASE, MIXEDGAUGE_TAGS); 1172 *offset_add = MIXEDGAUGE_BASE + tags * MIXEDGAUGE_TAGS; 1173 return dialog_mixedgauge(t, 1174 av[1], 1175 numeric_arg(av, 2), 1176 numeric_arg(av, 3), 1177 numeric_arg(av, 4), 1178 tags, av + MIXEDGAUGE_BASE); 1179 } 1180 #endif 1181 1182 #ifdef HAVE_DLG_GAUGE 1183 static int 1184 call_prgbox(CALLARGS) 1185 { 1186 *offset_add = arg_rest(av); 1187 /* the original version does not accept a prompt string, but for 1188 * consistency we allow it. 1189 */ 1190 return ((*offset_add == 5) 1191 ? dialog_prgbox(t, 1192 av[1], 1193 av[2], 1194 numeric_arg(av, 3), 1195 numeric_arg(av, 4), TRUE) 1196 : dialog_prgbox(t, 1197 "", 1198 av[1], 1199 numeric_arg(av, 2), 1200 numeric_arg(av, 3), TRUE)); 1201 } 1202 #endif 1203 1204 #ifdef HAVE_DLG_GAUGE 1205 static int 1206 call_programbox(CALLARGS) 1207 { 1208 int result; 1209 1210 *offset_add = arg_rest(av); 1211 /* this function is a compromise between --prgbox and --progressbox. 1212 */ 1213 result = ((*offset_add == 4) 1214 ? dlg_progressbox(t, 1215 av[1], 1216 numeric_arg(av, 2), 1217 numeric_arg(av, 3), 1218 TRUE, 1219 dialog_state.pipe_input) 1220 : dlg_progressbox(t, 1221 "", 1222 numeric_arg(av, 1), 1223 numeric_arg(av, 2), 1224 TRUE, 1225 dialog_state.pipe_input)); 1226 dialog_state.pipe_input = 0; 1227 return result; 1228 } 1229 #endif 1230 1231 #ifdef HAVE_DLG_GAUGE 1232 static int 1233 call_progressbox(CALLARGS) 1234 { 1235 *offset_add = arg_rest(av); 1236 /* the original version does not accept a prompt string, but for 1237 * consistency we allow it. 1238 */ 1239 return ((*offset_add == 4) 1240 ? dialog_progressbox(t, 1241 av[1], 1242 numeric_arg(av, 2), 1243 numeric_arg(av, 3)) 1244 : dialog_progressbox(t, 1245 "", 1246 numeric_arg(av, 1), 1247 numeric_arg(av, 2))); 1248 } 1249 #endif 1250 1251 #ifdef HAVE_DLG_TAILBOX 1252 static int 1253 call_tailbox(CALLARGS) 1254 { 1255 *offset_add = 4; 1256 return dialog_tailbox(t, 1257 av[1], 1258 numeric_arg(av, 2), 1259 numeric_arg(av, 3), 1260 FALSE); 1261 } 1262 1263 static int 1264 call_tailboxbg(CALLARGS) 1265 { 1266 *offset_add = 4; 1267 return dialog_tailbox(t, 1268 av[1], 1269 numeric_arg(av, 2), 1270 numeric_arg(av, 3), 1271 TRUE); 1272 } 1273 #endif 1274 /* *INDENT-OFF* */ 1275 static const Mode modes[] = 1276 { 1277 {o_yesno, 4, 4, call_yesno}, 1278 {o_msgbox, 4, 4, call_msgbox}, 1279 {o_infobox, 4, 4, call_infobox}, 1280 {o_textbox, 4, 4, call_textbox}, 1281 {o_menu, 6, 0, call_menu}, 1282 {o_inputmenu, 6, 0, call_inputmenu}, 1283 {o_checklist, 7, 0, call_checklist}, 1284 {o_radiolist, 7, 0, call_radiolist}, 1285 {o_inputbox, 4, 5, call_inputbox}, 1286 {o_passwordbox, 4, 5, call_passwordbox}, 1287 #ifdef HAVE_DLG_GAUGE 1288 {o_gauge, 4, 5, call_gauge}, 1289 {o_pause, 5, 5, call_pause}, 1290 {o_prgbox, 4, 5, call_prgbox}, 1291 {o_programbox, 3, 4, call_programbox}, 1292 {o_progressbox, 3, 4, call_progressbox}, 1293 #endif 1294 #ifdef HAVE_DLG_FORMBOX 1295 {o_passwordform, 13, 0, call_password_form}, 1296 {o_form, 13, 0, call_form}, 1297 #endif 1298 #ifdef HAVE_MIXEDGAUGE 1299 {o_mixedgauge, MIXEDGAUGE_BASE, 0, call_mixed_gauge}, 1300 #endif 1301 #ifdef HAVE_DLG_MIXEDFORM 1302 {o_mixedform, 13, 0, call_mixed_form}, 1303 #endif 1304 #ifdef HAVE_DLG_TAILBOX 1305 {o_tailbox, 4, 4, call_tailbox}, 1306 {o_tailboxbg, 4, 4, call_tailboxbg}, 1307 #endif 1308 #ifdef HAVE_XDIALOG 1309 {o_calendar, 4, 7, call_calendar}, 1310 {o_dselect, 4, 5, call_dselect}, 1311 {o_editbox, 4, 4, call_editbox}, 1312 {o_fselect, 4, 5, call_fselect}, 1313 {o_timebox, 4, 7, call_timebox}, 1314 #endif 1315 #ifdef HAVE_XDIALOG2 1316 {o_buildlist, 4, 0, call_buildlist}, 1317 {o_rangebox, 5, 7, call_rangebox}, 1318 {o_treeview, 4, 0, call_treeview}, 1319 #endif 1320 }; 1321 /* *INDENT-ON* */ 1322 1323 static char * 1324 optionString(char **argv, int *num) 1325 { 1326 int next = *num + 1; 1327 char *result = argv[next]; 1328 if (result == 0) { 1329 char temp[80]; 1330 sprintf(temp, ("Expected a string-parameter for %.*s"), USEMAX_ARGS, 1331 argv[*num]); 1332 Usage(temp); 1333 } 1334 *num = next; 1335 return result; 1336 } 1337 1338 static int 1339 optionValue(char **argv, int *num) 1340 { 1341 int next = *num + 1; 1342 char *src = argv[next]; 1343 char *tmp = 0; 1344 int result = 0; 1345 1346 if (src != 0) { 1347 result = (int) strtol(src, &tmp, 0); 1348 if (tmp == 0 || *tmp != 0) 1349 src = 0; 1350 } 1351 1352 if (src == 0) { 1353 char temp[80]; 1354 sprintf(temp, _("Expected a numeric-parameter for %.*s"), 1355 USEMAX_ARGS, argv[*num]); 1356 Usage(temp); 1357 } 1358 *num = next; 1359 return result; 1360 } 1361 1362 /* 1363 * In findOption, we made provision for adding/removing a "no" prefix from 1364 * any boolean option. This function determines the actual true/false result. 1365 */ 1366 static bool 1367 optionBool(const char *actual, const Options * data) 1368 { 1369 bool normal = (data->type == tTrue) ? TRUE : FALSE; 1370 bool result = !strcmp(actual + 2, data->name) ? normal : !normal; 1371 if (result != normal) { 1372 int want_no = (strncmp(actual + 2, "no", 2) == 0); 1373 int have_no = (strncmp(data->name, "no", 2) == 0); 1374 if (have_no == want_no) 1375 result = normal; 1376 } 1377 return result; 1378 } 1379 1380 /* Return exit-code for a named button */ 1381 static int 1382 button_code(const char *name) 1383 { 1384 /* *INDENT-OFF* */ 1385 static struct { 1386 const char *name; 1387 int code; 1388 } table[] = { 1389 { "ok", DLG_EXIT_OK }, 1390 { "yes", DLG_EXIT_OK }, 1391 { "cancel", DLG_EXIT_CANCEL }, 1392 { "no", DLG_EXIT_CANCEL }, 1393 { "help", DLG_EXIT_HELP }, 1394 { "extra", DLG_EXIT_EXTRA }, 1395 }; 1396 /* *INDENT-ON* */ 1397 1398 int code = DLG_EXIT_ERROR; 1399 size_t i; 1400 1401 for (i = 0; i < TableSize(table); i++) { 1402 if (!dlg_strcmp(name, table[i].name)) { 1403 code = table[i].code; 1404 break; 1405 } 1406 } 1407 1408 if (code == DLG_EXIT_ERROR) { 1409 char temp[80]; 1410 sprintf(temp, _("Button name \"%.*s\" unknown"), USEMAX_ARGS, name); 1411 Usage(temp); 1412 } 1413 1414 return code; 1415 } 1416 1417 /* 1418 * If this is the last option, we do not want any error messages - just our 1419 * output. Calling end_dialog() cancels the refresh() at the end of the 1420 * program as well. 1421 */ 1422 static void 1423 IgnoreNonScreen(char **argv, int offset) 1424 { 1425 if (argv[offset + 1] == 0) { 1426 ignore_unknown = TRUE; 1427 end_dialog(); 1428 } 1429 } 1430 1431 static void 1432 PrintTextOnly(char **argv, int *offset, eOptions code) 1433 { 1434 /* TODO - handle two optional numeric params */ 1435 char *text; 1436 int height = 0; 1437 int width = 0; 1438 int height2 = 0; 1439 int width2 = 0; 1440 int next = arg_rest(argv + *offset); 1441 1442 if (LINES <= 0 && COLS <= 0) { 1443 dlg_ttysize(fileno(dialog_state.input), 1444 &dialog_state.screen_height, 1445 &dialog_state.screen_width); 1446 } 1447 1448 text = strdup(optionString(argv, offset)); 1449 IgnoreNonScreen(argv, *offset); 1450 1451 if (next >= 1) { 1452 next = MIN(next, 3); 1453 height = numeric_arg(argv, *offset + 1); 1454 if (next >= 2) 1455 width = numeric_arg(argv, *offset + 2); 1456 *offset += next - 1; 1457 } 1458 1459 dlg_trim_string(text); 1460 dlg_auto_size(NULL, text, &height2, &width2, height, width); 1461 1462 switch (code) { 1463 case o_text_only: 1464 dialog_state.text_only = TRUE; 1465 dlg_print_autowrap(stdscr, text, height2, width2); 1466 dialog_state.text_only = FALSE; 1467 break; 1468 case o_print_text_size: 1469 fprintf(dialog_state.output, "%d %d\n", 1470 dialog_state.text_height, 1471 dialog_state.text_width); 1472 break; 1473 default: 1474 break; 1475 } 1476 } 1477 1478 /* 1479 * Print parts of a message 1480 */ 1481 static void 1482 PrintList(const char *const *list) 1483 { 1484 const char *leaf = strrchr(program, '/'); 1485 unsigned n = 0; 1486 1487 if (leaf != 0) 1488 leaf++; 1489 else 1490 leaf = program; 1491 1492 while (*list != 0) { 1493 fprintf(dialog_state.output, *list, n ? leaf : dialog_version()); 1494 (void) fputc('\n', dialog_state.output); 1495 n = 1; 1496 list++; 1497 } 1498 } 1499 1500 static const Mode * 1501 lookupMode(eOptions code) 1502 { 1503 const Mode *modePtr = 0; 1504 unsigned n; 1505 1506 for (n = 0; n < TableSize(modes); n++) { 1507 if (modes[n].code == code) { 1508 modePtr = &modes[n]; 1509 break; 1510 } 1511 } 1512 return modePtr; 1513 } 1514 1515 static int 1516 compare_opts(const void *a, const void *b) 1517 { 1518 Options *const *p = (Options * const *) a; 1519 Options *const *q = (Options * const *) b; 1520 return strcmp((*p)->name, (*q)->name); 1521 } 1522 1523 /* 1524 * Print program's version. 1525 */ 1526 static void 1527 PrintVersion(FILE *fp) 1528 { 1529 fprintf(fp, "Version: %s\n", dialog_version()); 1530 } 1531 1532 /* 1533 * Print program help-message 1534 */ 1535 static void 1536 Help(void) 1537 { 1538 static const char *const tbl_1[] = 1539 { 1540 "cdialog (ComeOn Dialog!) version %s", 1541 "Copyright 2000-2021,2022 Thomas E. Dickey", 1542 "This is free software; see the source for copying conditions. There is NO", 1543 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.", 1544 "", 1545 "* Display dialog boxes from shell scripts *", 1546 "", 1547 "Usage: %s <options> { --and-widget <options> }", 1548 "where options are \"common\" options, followed by \"box\" options", 1549 "", 1550 #ifdef HAVE_RC_FILE 1551 "Special options:", 1552 " [--create-rc \"file\"]", 1553 #endif 1554 0 1555 }, *const tbl_3[] = 1556 { 1557 "", 1558 "Auto-size with height and width = 0. Maximize with height and width = -1.", 1559 "Global-auto-size if also menu_height/list_height = 0.", 1560 0 1561 }; 1562 size_t limit = TableSize(options); 1563 size_t j, k; 1564 const Options **opts; 1565 1566 end_dialog(); 1567 dialog_state.output = stdout; 1568 1569 opts = dlg_calloc(const Options *, limit); 1570 assert_ptr(opts, "Help"); 1571 for (j = 0; j < limit; ++j) { 1572 opts[j] = &(options[j]); 1573 } 1574 qsort(opts, limit, sizeof(Options *), compare_opts); 1575 1576 PrintList(tbl_1); 1577 fprintf(dialog_state.output, "Common options:\n "); 1578 for (j = k = 0; j < limit; j++) { 1579 if ((opts[j]->pass & 1) 1580 && opts[j]->help != 0) { 1581 size_t len = 6 + strlen(opts[j]->name) + strlen(opts[j]->help); 1582 k += len; 1583 if (k > 75) { 1584 fprintf(dialog_state.output, "\n "); 1585 k = len; 1586 } 1587 fprintf(dialog_state.output, " [--%s%s%s]", opts[j]->name, 1588 *(opts[j]->help) ? " " : "", opts[j]->help); 1589 } 1590 } 1591 fprintf(dialog_state.output, "\nBox options:\n"); 1592 for (j = 0; j < limit; j++) { 1593 if ((opts[j]->pass & 2) != 0 1594 && opts[j]->help != 0 1595 && lookupMode(opts[j]->code)) { 1596 fprintf(dialog_state.output, " --%-12s %s\n", opts[j]->name, 1597 opts[j]->help); 1598 } 1599 } 1600 PrintList(tbl_3); 1601 1602 free(opts); 1603 handle_leaks(); 1604 dlg_exit(DLG_EXIT_OK); 1605 } 1606 1607 #ifdef HAVE_DLG_TRACE 1608 /* 1609 * Only the first call to dlg_trace will open a trace file. But each time 1610 * --trace is parsed, we show the whole parameter list as it is at that moment, 1611 * counting discarded parameters. The only way to capture the whole parameter 1612 * list is if --trace is the first option. 1613 */ 1614 static void 1615 process_trace_option(char **argv, int *offset) 1616 { 1617 int j; 1618 1619 if (dialog_state.trace_output == 0) { 1620 dlg_trace(optionString(argv, offset)); 1621 } else { 1622 DLG_TRACE(("# ignore extra --trace option\n")); 1623 *offset += 1; 1624 } 1625 1626 DLG_TRACE(("# Parameters:\n")); 1627 for (j = 0; argv[j] != 0; ++j) { 1628 DLG_TRACE(("#\targv[%d] = %s\n", j, argv[j])); 1629 } 1630 } 1631 #endif 1632 1633 /* 1634 * "Common" options apply to all widgets more/less. Most of the common options 1635 * set values in dialog_vars, a few set dialog_state and a couple write to the 1636 * output stream. 1637 */ 1638 static int 1639 process_common_options(int argc, char **argv, int offset, int output) 1640 { 1641 const Options *data = NULL; 1642 bool done = FALSE; 1643 1644 DLG_TRACE(("# process_common_options, offset %d:%d\n", offset, argc)); 1645 1646 while (!done && offset < argc) { 1647 static char empty[] = ""; 1648 eOptions code = o_unknown; 1649 char *sval = empty; 1650 bool bval; 1651 int nval; 1652 char *target; 1653 1654 DLG_TRACE(("#\targv[%d] = %s\n", offset, argv[offset])); 1655 if ((data = findOption(argv[offset], 1, FALSE)) == NULL) { 1656 done = TRUE; 1657 continue; 1658 } 1659 1660 switch (data->vars) { 1661 default: 1662 target = NULL; 1663 break; 1664 case 1: 1665 target = (char *) &dialog_state; 1666 break; 1667 case 2: 1668 target = (char *) &dialog_vars; 1669 break; 1670 } 1671 1672 #define TraceTarget \ 1673 ((target == (char *) &dialog_state) \ 1674 ? "dialog_state" \ 1675 : "dialog_vars") 1676 #define TraceBVal (bval ? "TRUE" : "FALSE") 1677 #define TraceDone(fmt,value) \ 1678 DLG_TRACE(("#\t.. set %s.%s = %"fmt"\n", TraceTarget, data->name, value)) 1679 #define TraceLate(fmt,value) \ 1680 DLG_TRACE(("#\t.. defer setting %s = %"fmt"\n", data->name, value)) 1681 1682 code = data->code; 1683 switch (data->type) { 1684 default: 1685 break; 1686 case tFalse: 1687 case tTrue: 1688 bval = optionBool(argv[offset], data); 1689 if (target != NULL) { 1690 *(bool *) (target + data->offset) = bval; 1691 TraceDone("s", TraceBVal); 1692 } else { 1693 TraceLate("s", TraceBVal); 1694 } 1695 break; 1696 case tNumber: 1697 nval = optionValue(argv, &offset); 1698 if (target != NULL) { 1699 *(int *) (void *) (target + data->offset) = nval; 1700 TraceDone("d", nval); 1701 } else { 1702 TraceLate("d", nval); 1703 } 1704 break; 1705 case tString: 1706 sval = optionString(argv, &offset); 1707 if (target != NULL) { 1708 *(char **) (void *) (target + data->offset) = sval; 1709 TraceDone("s", sval); 1710 } else { 1711 TraceLate("s", sval); 1712 } 1713 break; 1714 } 1715 1716 switch (code) { 1717 case o_defaultno: 1718 dialog_vars.default_button = DLG_EXIT_CANCEL; 1719 break; 1720 case o_default_button: 1721 dialog_vars.default_button = button_code(sval); 1722 dialog_vars.defaultno = dialog_vars.default_button == DLG_EXIT_CANCEL; 1723 break; 1724 case o_text_only: 1725 case o_print_text_size: 1726 PrintTextOnly(argv, &offset, code); 1727 break; 1728 case o_print_maxsize: 1729 if (output) { 1730 IgnoreNonScreen(argv, offset); 1731 fflush(dialog_state.output); 1732 fprintf(dialog_state.output, "MaxSize: %d, %d\n", SLINES, SCOLS); 1733 } 1734 break; 1735 case o_print_version: 1736 if (output) { 1737 PrintVersion(dialog_state.output); 1738 } 1739 break; 1740 case o_visit_items: 1741 dialog_state.visit_cols = 1; 1742 break; 1743 case o_begin_set: 1744 #ifdef HAVE_WHIPTAIL 1745 if (!strcmp(argv[offset], "--topleft")) { 1746 dialog_vars.begin_y = 0; 1747 dialog_vars.begin_x = 0; 1748 } else 1749 #endif 1750 { 1751 dialog_vars.begin_y = optionValue(argv, &offset); 1752 dialog_vars.begin_x = optionValue(argv, &offset); 1753 } 1754 break; 1755 case o_ascii_lines: 1756 dialog_vars.no_lines = FALSE; 1757 break; 1758 case o_no_lines: 1759 dialog_vars.ascii_lines = FALSE; 1760 break; 1761 case o_no_mouse: 1762 mouse_close(); 1763 break; 1764 case o_unknown: 1765 done = !ignore_unknown; 1766 default: 1767 break; 1768 #ifdef HAVE_DLG_TRACE 1769 case o_trace: 1770 process_trace_option(argv, &offset); 1771 break; 1772 #endif 1773 case o_iso_week: 1774 if (dialog_vars.week_start == 0) { /* Monday is implied */ 1775 static char default_1st[] = "1"; 1776 dialog_vars.week_start = default_1st; 1777 } 1778 break; 1779 } 1780 if (!done) 1781 offset++; 1782 } 1783 1784 if (dialog_state.aspect_ratio == 0) 1785 dialog_state.aspect_ratio = DEFAULT_ASPECT_RATIO; 1786 1787 return offset; 1788 } 1789 1790 /* 1791 * Initialize options at the start of a series of common options culminating 1792 * in a widget. 1793 */ 1794 static void 1795 init_result(char *buffer) 1796 { 1797 static bool first = TRUE; 1798 1799 DLG_TRACE(("# init_result\n")); 1800 1801 /* clear everything we do not save for the next widget */ 1802 memset(&dialog_vars, 0, sizeof(dialog_vars)); 1803 1804 dialog_vars.input_result = buffer; 1805 dialog_vars.input_result[0] = '\0'; 1806 1807 dialog_vars.default_button = -1; 1808 1809 /* 1810 * The first time this is called, check for common options given by an 1811 * environment variable. 1812 */ 1813 if (first) { 1814 char *env = dlg_getenv_str("DIALOGOPTS"); 1815 if (env != 0) 1816 env = dlg_strclone(env); 1817 if (env != 0) { 1818 special_argv = dlg_string_to_argv(env); 1819 special_argc = dlg_count_argv(special_argv); 1820 } 1821 first = FALSE; 1822 } 1823 1824 if (special_argv != 0) { 1825 process_common_options(special_argc, special_argv, 0, FALSE); 1826 } 1827 } 1828 1829 int 1830 main(int argc, char *argv[]) 1831 { 1832 char temp[256]; 1833 bool esc_pressed = FALSE; 1834 bool keep_tite = FALSE; 1835 int initial = 1; 1836 int offset = 1; 1837 int offset_add = 0; 1838 int retval = DLG_EXIT_OK; 1839 int j; 1840 eOptions code; 1841 char my_buffer[MAX_LEN + 1]; 1842 1843 memset(&dialog_state, 0, sizeof(dialog_state)); 1844 memset(&dialog_vars, 0, sizeof(dialog_vars)); 1845 1846 #if defined(ENABLE_NLS) 1847 /* initialize locale support */ 1848 setlocale(LC_ALL, ""); 1849 bindtextdomain(NLS_TEXTDOMAIN, LOCALEDIR); 1850 textdomain(NLS_TEXTDOMAIN); 1851 #elif defined(HAVE_SETLOCALE) 1852 (void) setlocale(LC_ALL, ""); 1853 #endif 1854 1855 init_result(my_buffer); /* honor $DIALOGOPTS */ 1856 unescape_argv(&argc, &argv); 1857 program = argv[0]; 1858 dialog_state.output = stderr; 1859 dialog_state.input = stdin; 1860 1861 /* 1862 * Look for the last --stdout, --stderr or --output-fd option, and use 1863 * that. We can only write to one of them. If --stdout is used, that 1864 * can interfere with initializing the curses library, so we want to 1865 * know explicitly if it is used. 1866 * 1867 * Also, look for any --version or --help message, processing those 1868 * immediately. 1869 */ 1870 while (offset < argc) { 1871 int base = offset; 1872 switch (lookupOption(argv[offset], 7)) { 1873 case o_output_stdout: 1874 dialog_state.output = stdout; 1875 break; 1876 case o_output_stderr: 1877 dialog_state.output = stderr; 1878 break; 1879 case o_input_fd: 1880 if ((j = optionValue(argv, &offset)) < 0 1881 || (dialog_state.input = fdopen(j, "r")) == 0) { 1882 handle_leaks(); 1883 dlg_exiterr(_("Cannot open input-fd\n")); 1884 } 1885 break; 1886 case o_output_fd: 1887 if ((j = optionValue(argv, &offset)) < 0 1888 || (dialog_state.output = fdopen(j, "w")) == 0) { 1889 handle_leaks(); 1890 dlg_exiterr(_("Cannot open output-fd\n")); 1891 } 1892 break; 1893 case o_keep_tite: 1894 keep_tite = TRUE; 1895 break; 1896 case o_version: 1897 dialog_state.output = stdout; 1898 PrintVersion(dialog_state.output); 1899 dlg_exit(DLG_EXIT_OK); 1900 break; 1901 case o_help: 1902 Help(); 1903 break; 1904 #ifdef HAVE_DLG_TRACE 1905 case o_trace: 1906 /* 1907 * Process/remove the --trace option if it is the first option. 1908 * Otherwise, process it in more/less expected order as a 1909 * "common" option. 1910 */ 1911 if (base == 1) { 1912 process_trace_option(argv, &offset); 1913 break; 1914 } else { 1915 ++offset; 1916 continue; 1917 } 1918 #endif 1919 default: 1920 ++offset; 1921 continue; 1922 } 1923 DLG_TRACE(("# discarding %d parameters starting with argv[%d] (%s)\n", 1924 1 + offset - base, base, 1925 argv[base])); 1926 for (j = base; j < argc; ++j) { 1927 dialog_argv[j] = dialog_argv[j + 1 + (offset - base)]; 1928 } 1929 argc -= (1 + offset - base); 1930 offset = base; 1931 } 1932 offset = 1; 1933 init_result(my_buffer); 1934 dialog_vars.keep_tite |= keep_tite; /* init_result() cleared global */ 1935 1936 /* 1937 * Dialog's output may be redirected (see above). Handle the special 1938 * case of options that only report information without interaction. 1939 */ 1940 if (argc == 2) { 1941 switch (lookupOption(argv[1], 7)) { 1942 case o_print_maxsize: 1943 (void) initscr(); 1944 endwin(); 1945 fflush(dialog_state.output); 1946 fprintf(dialog_state.output, "MaxSize: %d, %d\n", SLINES, SCOLS); 1947 break; 1948 case o_print_version: 1949 PrintVersion(dialog_state.output); 1950 break; 1951 case o_dlg_clear_screen: 1952 initscr(); 1953 refresh(); 1954 dlg_keep_tite((dialog_state.output == stdout) ? stderr : stdout); 1955 endwin(); 1956 break; 1957 case o_ignore: 1958 break; 1959 default: 1960 Help(); 1961 break; 1962 } 1963 dlg_exit(DLG_EXIT_OK); 1964 } else if (argc < 2) { 1965 Help(); 1966 } 1967 #ifdef HAVE_RC_FILE 1968 else if (lookupOption(argv[1], 7) == o_create_rc) { 1969 if (argc != 3) { 1970 sprintf(temp, _("Expected a filename for %.*s"), USEMAX_FILE, 1971 argv[1]); 1972 Usage(temp); 1973 } 1974 #ifdef HAVE_COLOR 1975 dialog_state.use_colors = USE_COLORS; /* use colors by default? */ 1976 dialog_state.use_shadow = USE_SHADOW; /* shadow dialog boxes by default? */ 1977 #endif 1978 if (dlg_parse_rc() == -1) { /* Read the configuration file */ 1979 handle_leaks(); 1980 dlg_exiterr("dialog: dlg_parse_rc"); 1981 } 1982 dlg_create_rc(argv[2]); 1983 dlg_exit(DLG_EXIT_OK); 1984 } 1985 #endif /* HAVE_RC_FILE */ 1986 else { 1987 /* 1988 * Handle combinations of common options including --print-text-only 1989 * which can be done before involving curses, in case we can exit 1990 * without initializing curses (and writing to the terminal). 1991 */ 1992 initial = process_common_options(argc, argv, offset, TRUE); 1993 if (initial >= argc) 1994 dlg_exit(DLG_EXIT_OK); 1995 } 1996 1997 init_dialog(dialog_state.input, dialog_state.output); 1998 1999 while (offset < argc && !esc_pressed) { 2000 int have; 2001 const Mode *modePtr; 2002 2003 init_result(my_buffer); 2004 offset = process_common_options(argc, argv, offset, offset > initial); 2005 2006 if (argv[offset] == NULL) { 2007 if (ignore_unknown) 2008 break; 2009 Usage(_("Expected a box option")); 2010 } 2011 2012 if (dialog_vars.separate_output) { 2013 switch (lookupOption(argv[offset], 2)) { 2014 #ifdef HAVE_XDIALOG2 2015 case o_buildlist: 2016 case o_treeview: 2017 #endif 2018 case o_checklist: 2019 break; 2020 default: 2021 sprintf(temp, 2022 _("Unexpected widget with --separate-output %.*s"), 2023 USEMAX_ARGS, argv[offset]); 2024 Usage(temp); 2025 } 2026 } 2027 2028 dlg_put_backtitle(); 2029 2030 /* use a table to look for the requested mode, to avoid code duplication */ 2031 2032 modePtr = 0; 2033 if ((code = lookupOption(argv[offset], 2)) != o_unknown) 2034 modePtr = lookupMode(code); 2035 if (modePtr == 0) { 2036 sprintf(temp, 2037 (lookupOption(argv[offset], 7) != o_unknown 2038 ? _("Unexpected option %.*s") 2039 : _("Unknown option %.*s")), 2040 USEMAX_ARGS, 2041 argv[offset]); 2042 Usage(temp); 2043 } 2044 2045 have = arg_rest(&argv[offset]); 2046 if (have < modePtr->argmin) { 2047 sprintf(temp, _("Expected at least %d tokens for %.*s, have %d"), 2048 USEMAX_ARGS, 2049 modePtr->argmin - 1, argv[offset], 2050 have - 1); 2051 Usage(temp); 2052 } 2053 if (modePtr->argmax && have > modePtr->argmax) { 2054 sprintf(temp, 2055 _("Expected no more than %d tokens for %.*s, have %d"), 2056 USEMAX_ARGS, 2057 modePtr->argmax - 1, argv[offset], 2058 have - 1); 2059 Usage(temp); 2060 } 2061 2062 /* 2063 * Trim whitespace from non-title option values, e.g., the ones that 2064 * will be used as captions or prompts. Do that only for the widget 2065 * we are about to process, since the "--trim" option is reset before 2066 * accumulating options for each widget. 2067 */ 2068 for (j = offset + 1; j <= offset + have; j++) { 2069 switch (lookupOption(argv[j - 1], 7)) { 2070 case o_unknown: 2071 case o_title: 2072 case o_backtitle: 2073 case o_help_line: 2074 case o_help_file: 2075 break; 2076 default: 2077 if (argv[j] != 0) { 2078 char *argv_j = strdup(argv[j]); 2079 if (argv_j != 0) { 2080 dlg_trim_string(argv_j); 2081 argv[j] = argv_j; 2082 } else { 2083 argv[j] = strdup("?"); 2084 } 2085 ignore_leak(argv[j]); 2086 } 2087 break; 2088 } 2089 } 2090 2091 DLG_TRACE(("# execute %s\n", argv[offset])); 2092 retval = show_result((*(modePtr->jumper)) (dialog_vars.title, 2093 argv + offset, 2094 &offset_add)); 2095 DLG_TRACE(("# widget returns %d\n", retval)); 2096 offset += offset_add; 2097 2098 if (dialog_vars.input_result != my_buffer) { 2099 free(dialog_vars.input_result); 2100 dialog_vars.input_result = 0; 2101 } 2102 2103 if (retval == DLG_EXIT_ESC) { 2104 esc_pressed = TRUE; 2105 } else { 2106 2107 if (dialog_vars.beep_after_signal) 2108 (void) beep(); 2109 2110 if (dialog_vars.sleep_secs) 2111 (void) napms(dialog_vars.sleep_secs * 1000); 2112 2113 if (offset < argc) { 2114 switch (lookupOption(argv[offset], 7)) { 2115 case o_and_widget: 2116 offset++; 2117 break; 2118 case o_unknown: 2119 sprintf(temp, _("Expected --and-widget, not %.*s"), 2120 USEMAX_ARGS, argv[offset]); 2121 Usage(temp); 2122 break; 2123 default: 2124 /* if we got a cancel, etc., stop chaining */ 2125 if (retval != DLG_EXIT_OK) 2126 esc_pressed = TRUE; 2127 else 2128 dialog_vars.dlg_clear_screen = TRUE; 2129 break; 2130 } 2131 } 2132 if (dialog_vars.dlg_clear_screen) 2133 dlg_clear(); 2134 } 2135 } 2136 2137 dlg_killall_bg(&retval); 2138 if (dialog_state.screen_initialized) { 2139 (void) refresh(); 2140 end_dialog(); 2141 } 2142 handle_leaks(); 2143 dlg_exit(retval); 2144 } 2145