1 /* ----------------------------------------------------------------------- * 2 * 3 * Copyright 2004-2008 H. Peter Anvin - All Rights Reserved 4 * Copyright 2009-2014 Intel Corporation; author: H. Peter Anvin 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, 9 * Boston MA 02110-1301, USA; either version 2 of the License, or 10 * (at your option) any later version; incorporated herein by reference. 11 * 12 * ----------------------------------------------------------------------- */ 13 14 /* 15 * menumain.c 16 * 17 * Simple menu system which displays a list and allows the user to select 18 * a command line and/or edit it. 19 */ 20 21 #include <ctype.h> 22 #include <string.h> 23 #include <stdlib.h> 24 #include <stdio.h> 25 #include <consoles.h> 26 #include <getkey.h> 27 #include <minmax.h> 28 #include <setjmp.h> 29 #include <limits.h> 30 #include <com32.h> 31 #include <core.h> 32 #include <syslinux/adv.h> 33 #include <syslinux/boot.h> 34 35 #include "menu.h" 36 37 /* The symbol "cm" always refers to the current menu across this file... */ 38 static struct menu *cm; 39 40 const struct menu_parameter mparm[NPARAMS] = { 41 [P_WIDTH] = {"width", 0}, 42 [P_MARGIN] = {"margin", 10}, 43 [P_PASSWD_MARGIN] = {"passwordmargin", 3}, 44 [P_MENU_ROWS] = {"rows", 12}, 45 [P_TABMSG_ROW] = {"tabmsgrow", 18}, 46 [P_CMDLINE_ROW] = {"cmdlinerow", 18}, 47 [P_END_ROW] = {"endrow", -1}, 48 [P_PASSWD_ROW] = {"passwordrow", 11}, 49 [P_TIMEOUT_ROW] = {"timeoutrow", 20}, 50 [P_HELPMSG_ROW] = {"helpmsgrow", 22}, 51 [P_HELPMSGEND_ROW] = {"helpmsgendrow", -1}, 52 [P_HSHIFT] = {"hshift", 0}, 53 [P_VSHIFT] = {"vshift", 0}, 54 [P_HIDDEN_ROW] = {"hiddenrow", -2}, 55 }; 56 57 /* These macros assume "cm" is a pointer to the current menu */ 58 #define WIDTH (cm->mparm[P_WIDTH]) 59 #define MARGIN (cm->mparm[P_MARGIN]) 60 #define PASSWD_MARGIN (cm->mparm[P_PASSWD_MARGIN]) 61 #define MENU_ROWS (cm->mparm[P_MENU_ROWS]) 62 #define TABMSG_ROW (cm->mparm[P_TABMSG_ROW]+VSHIFT) 63 #define CMDLINE_ROW (cm->mparm[P_CMDLINE_ROW]+VSHIFT) 64 #define END_ROW (cm->mparm[P_END_ROW]) 65 #define PASSWD_ROW (cm->mparm[P_PASSWD_ROW]+VSHIFT) 66 #define TIMEOUT_ROW (cm->mparm[P_TIMEOUT_ROW]+VSHIFT) 67 #define HELPMSG_ROW (cm->mparm[P_HELPMSG_ROW]+VSHIFT) 68 #define HELPMSGEND_ROW (cm->mparm[P_HELPMSGEND_ROW]) 69 #define HSHIFT (cm->mparm[P_HSHIFT]) 70 #define VSHIFT (cm->mparm[P_VSHIFT]) 71 #define HIDDEN_ROW (cm->mparm[P_HIDDEN_ROW]) 72 73 static char *pad_line(const char *text, int align, int width) 74 { 75 static char buffer[MAX_CMDLINE_LEN]; 76 int n, p; 77 78 if (width >= (int)sizeof buffer) 79 return NULL; /* Can't do it */ 80 81 n = strlen(text); 82 if (n >= width) 83 n = width; 84 85 memset(buffer, ' ', width); 86 buffer[width] = 0; 87 p = ((width - n) * align) >> 1; 88 memcpy(buffer + p, text, n); 89 90 return buffer; 91 } 92 93 /* Display an entry, with possible hotkey highlight. Assumes 94 that the current attribute is the non-hotkey one, and will 95 guarantee that as an exit condition as well. */ 96 static void 97 display_entry(const struct menu_entry *entry, const char *attrib, 98 const char *hotattrib, int width) 99 { 100 const char *p = entry->displayname; 101 char marker; 102 103 if (!p) 104 p = ""; 105 106 switch (entry->action) { 107 case MA_SUBMENU: 108 marker = '>'; 109 break; 110 case MA_EXIT: 111 marker = '<'; 112 break; 113 default: 114 marker = 0; 115 break; 116 } 117 118 if (marker) 119 width -= 2; 120 121 while (width) { 122 if (*p) { 123 if (*p == '^') { 124 p++; 125 if (*p && ((unsigned char)*p & ~0x20) == entry->hotkey) { 126 fputs(hotattrib, stdout); 127 putchar(*p++); 128 fputs(attrib, stdout); 129 width--; 130 } 131 } else { 132 putchar(*p++); 133 width--; 134 } 135 } else { 136 putchar(' '); 137 width--; 138 } 139 } 140 141 if (marker) { 142 putchar(' '); 143 putchar(marker); 144 } 145 } 146 147 static void draw_row(int y, int sel, int top, int sbtop, int sbbot) 148 { 149 int i = (y - 4 - VSHIFT) + top; 150 int dis = (i < cm->nentries) && is_disabled(cm->menu_entries[i]); 151 152 printf("\033[%d;%dH\1#1\016x\017%s ", 153 y, MARGIN + 1 + HSHIFT, 154 (i == sel) ? "\1#5" : dis ? "\2#17" : "\1#3"); 155 156 if (i >= cm->nentries) { 157 fputs(pad_line("", 0, WIDTH - 2 * MARGIN - 4), stdout); 158 } else { 159 display_entry(cm->menu_entries[i], 160 (i == sel) ? "\1#5" : dis ? "\2#17" : "\1#3", 161 (i == sel) ? "\1#6" : dis ? "\2#17" : "\1#4", 162 WIDTH - 2 * MARGIN - 4); 163 } 164 165 if (cm->nentries <= MENU_ROWS) { 166 printf(" \1#1\016x\017"); 167 } else if (sbtop > 0) { 168 if (y >= sbtop && y <= sbbot) 169 printf(" \1#7\016a\017"); 170 else 171 printf(" \1#1\016x\017"); 172 } else { 173 putchar(' '); /* Don't modify the scrollbar */ 174 } 175 } 176 177 static jmp_buf timeout_jump; 178 179 int mygetkey(clock_t timeout) 180 { 181 clock_t t0, t; 182 clock_t tto, to; 183 int key; 184 185 if (!totaltimeout) 186 return get_key(stdin, timeout); 187 188 for (;;) { 189 tto = min(totaltimeout, INT_MAX); 190 to = timeout ? min(tto, timeout) : tto; 191 192 t0 = times(NULL); 193 key = get_key(stdin, to); 194 t = times(NULL) - t0; 195 196 if (totaltimeout <= t) 197 longjmp(timeout_jump, 1); 198 199 totaltimeout -= t; 200 201 if (key != KEY_NONE) 202 return key; 203 204 if (timeout) { 205 if (timeout <= t) 206 return KEY_NONE; 207 208 timeout -= t; 209 } 210 } 211 } 212 213 static int ask_passwd(const char *menu_entry) 214 { 215 char user_passwd[WIDTH], *p; 216 int done; 217 int key; 218 int x; 219 int rv; 220 221 printf("\033[%d;%dH\2#11\016l", PASSWD_ROW, PASSWD_MARGIN + 1); 222 for (x = 2; x <= WIDTH - 2 * PASSWD_MARGIN - 1; x++) 223 putchar('q'); 224 225 printf("k\033[%d;%dHx", PASSWD_ROW + 1, PASSWD_MARGIN + 1); 226 for (x = 2; x <= WIDTH - 2 * PASSWD_MARGIN - 1; x++) 227 putchar(' '); 228 229 printf("x\033[%d;%dHm", PASSWD_ROW + 2, PASSWD_MARGIN + 1); 230 for (x = 2; x <= WIDTH - 2 * PASSWD_MARGIN - 1; x++) 231 putchar('q'); 232 233 printf("j\017\033[%d;%dH\2#12 %s \033[%d;%dH\2#13", 234 PASSWD_ROW, (WIDTH - (strlen(cm->messages[MSG_PASSPROMPT]) + 2)) / 2, 235 cm->messages[MSG_PASSPROMPT], PASSWD_ROW + 1, PASSWD_MARGIN + 3); 236 237 drain_keyboard(); 238 239 /* Actually allow user to type a password, then compare to the SHA1 */ 240 done = 0; 241 p = user_passwd; 242 243 while (!done) { 244 key = mygetkey(0); 245 246 switch (key) { 247 case KEY_ENTER: 248 case KEY_CTRL('J'): 249 done = 1; 250 break; 251 252 case KEY_ESC: 253 case KEY_CTRL('C'): 254 p = user_passwd; /* No password entered */ 255 done = 1; 256 break; 257 258 case KEY_BACKSPACE: 259 case KEY_DEL: 260 case KEY_DELETE: 261 if (p > user_passwd) { 262 printf("\b \b"); 263 p--; 264 } 265 break; 266 267 case KEY_CTRL('U'): 268 while (p > user_passwd) { 269 printf("\b \b"); 270 p--; 271 } 272 break; 273 274 default: 275 if (key >= ' ' && key <= 0xFF && 276 (p - user_passwd) < WIDTH - 2 * PASSWD_MARGIN - 5) { 277 *p++ = key; 278 putchar('*'); 279 } 280 break; 281 } 282 } 283 284 if (p == user_passwd) 285 return 0; /* No password entered */ 286 287 *p = '\0'; 288 289 rv = (cm->menu_master_passwd && 290 passwd_compare(cm->menu_master_passwd, user_passwd)) 291 || (menu_entry && passwd_compare(menu_entry, user_passwd)); 292 293 /* Clean up */ 294 memset(user_passwd, 0, WIDTH); 295 drain_keyboard(); 296 297 return rv; 298 } 299 300 static void draw_menu(int sel, int top, int edit_line) 301 { 302 int x, y; 303 int sbtop = 0, sbbot = 0; 304 const char *tabmsg; 305 int tabmsg_len; 306 307 if (cm->nentries > MENU_ROWS) { 308 int sblen = max(MENU_ROWS * MENU_ROWS / cm->nentries, 1); 309 sbtop = (MENU_ROWS - sblen + 1) * top / (cm->nentries - MENU_ROWS + 1); 310 sbbot = sbtop + sblen - 1; 311 sbtop += 4; 312 sbbot += 4; /* Starting row of scrollbar */ 313 } 314 315 printf("\033[%d;%dH\1#1\016l", VSHIFT + 1, HSHIFT + MARGIN + 1); 316 for (x = 2 + HSHIFT; x <= (WIDTH - 2 * MARGIN - 1) + HSHIFT; x++) 317 putchar('q'); 318 319 printf("k\033[%d;%dH\1#1x\017\1#2 %s \1#1\016x", 320 VSHIFT + 2, 321 HSHIFT + MARGIN + 1, pad_line(cm->title, 1, WIDTH - 2 * MARGIN - 4)); 322 323 printf("\033[%d;%dH\1#1t", VSHIFT + 3, HSHIFT + MARGIN + 1); 324 for (x = 2 + HSHIFT; x <= (WIDTH - 2 * MARGIN - 1) + HSHIFT; x++) 325 putchar('q'); 326 fputs("u\017", stdout); 327 328 for (y = 4 + VSHIFT; y < 4 + VSHIFT + MENU_ROWS; y++) 329 draw_row(y, sel, top, sbtop, sbbot); 330 331 printf("\033[%d;%dH\1#1\016m", y, HSHIFT + MARGIN + 1); 332 for (x = 2 + HSHIFT; x <= (WIDTH - 2 * MARGIN - 1) + HSHIFT; x++) 333 putchar('q'); 334 fputs("j\017", stdout); 335 336 if (edit_line && cm->allowedit && !cm->menu_master_passwd) 337 tabmsg = cm->messages[MSG_TAB]; 338 else 339 tabmsg = cm->messages[MSG_NOTAB]; 340 341 tabmsg_len = strlen(tabmsg); 342 343 printf("\1#8\033[%d;%dH%s", 344 TABMSG_ROW, 1 + HSHIFT + ((WIDTH - tabmsg_len) >> 1), tabmsg); 345 printf("\1#0\033[%d;1H", END_ROW); 346 } 347 348 static void clear_screen(void) 349 { 350 fputs("\033e\033%@\033)0\033(B\1#0\033[?25l\033[2J", stdout); 351 } 352 353 static void display_help(const char *text) 354 { 355 int row; 356 const char *p; 357 358 if (!text) { 359 text = ""; 360 printf("\1#0\033[%d;1H", HELPMSG_ROW); 361 } else { 362 printf("\2#16\033[%d;1H", HELPMSG_ROW); 363 } 364 365 for (p = text, row = HELPMSG_ROW; *p && row <= HELPMSGEND_ROW; p++) { 366 switch (*p) { 367 case '\r': 368 case '\f': 369 case '\v': 370 case '\033': 371 break; 372 case '\n': 373 printf("\033[K\033[%d;1H", ++row); 374 break; 375 default: 376 putchar(*p); 377 } 378 } 379 380 fputs("\033[K", stdout); 381 382 while (row <= HELPMSGEND_ROW) { 383 printf("\033[K\033[%d;1H", ++row); 384 } 385 } 386 387 static void show_fkey(int key) 388 { 389 int fkey; 390 391 while (1) { 392 switch (key) { 393 case KEY_F1: 394 fkey = 0; 395 break; 396 case KEY_F2: 397 fkey = 1; 398 break; 399 case KEY_F3: 400 fkey = 2; 401 break; 402 case KEY_F4: 403 fkey = 3; 404 break; 405 case KEY_F5: 406 fkey = 4; 407 break; 408 case KEY_F6: 409 fkey = 5; 410 break; 411 case KEY_F7: 412 fkey = 6; 413 break; 414 case KEY_F8: 415 fkey = 7; 416 break; 417 case KEY_F9: 418 fkey = 8; 419 break; 420 case KEY_F10: 421 fkey = 9; 422 break; 423 case KEY_F11: 424 fkey = 10; 425 break; 426 case KEY_F12: 427 fkey = 11; 428 break; 429 default: 430 fkey = -1; 431 break; 432 } 433 434 if (fkey == -1) 435 break; 436 437 if (cm->fkeyhelp[fkey].textname) 438 key = show_message_file(cm->fkeyhelp[fkey].textname, 439 cm->fkeyhelp[fkey].background); 440 else 441 break; 442 } 443 } 444 445 static const char *edit_cmdline(const char *input, int top) 446 { 447 static char cmdline[MAX_CMDLINE_LEN]; 448 int key, len, prev_len, cursor; 449 int redraw = 1; /* We enter with the menu already drawn */ 450 451 strlcpy(cmdline, input, MAX_CMDLINE_LEN); 452 cmdline[MAX_CMDLINE_LEN - 1] = '\0'; 453 454 len = cursor = strlen(cmdline); 455 prev_len = 0; 456 457 for (;;) { 458 if (redraw > 1) { 459 /* Clear and redraw whole screen */ 460 /* Enable ASCII on G0 and DEC VT on G1; do it in this order 461 to avoid confusing the Linux console */ 462 clear_screen(); 463 draw_menu(-1, top, 1); 464 prev_len = 0; 465 } 466 467 if (redraw > 0) { 468 /* Redraw the command line */ 469 printf("\033[?25l\033[%d;1H\1#9> \2#10%s", 470 CMDLINE_ROW, pad_line(cmdline, 0, max(len, prev_len))); 471 printf("\2#10\033[%d;3H%s\033[?25h", 472 CMDLINE_ROW, pad_line(cmdline, 0, cursor)); 473 prev_len = len; 474 redraw = 0; 475 } 476 477 key = mygetkey(0); 478 479 switch (key) { 480 case KEY_CTRL('L'): 481 redraw = 2; 482 break; 483 484 case KEY_ENTER: 485 case KEY_CTRL('J'): 486 return cmdline; 487 488 case KEY_ESC: 489 case KEY_CTRL('C'): 490 return NULL; 491 492 case KEY_BACKSPACE: 493 case KEY_DEL: 494 if (cursor) { 495 memmove(cmdline + cursor - 1, cmdline + cursor, 496 len - cursor + 1); 497 len--; 498 cursor--; 499 redraw = 1; 500 } 501 break; 502 503 case KEY_CTRL('D'): 504 case KEY_DELETE: 505 if (cursor < len) { 506 memmove(cmdline + cursor, cmdline + cursor + 1, len - cursor); 507 len--; 508 redraw = 1; 509 } 510 break; 511 512 case KEY_CTRL('U'): 513 if (len) { 514 len = cursor = 0; 515 cmdline[len] = '\0'; 516 redraw = 1; 517 } 518 break; 519 520 case KEY_CTRL('W'): 521 if (cursor) { 522 int prevcursor = cursor; 523 524 while (cursor && my_isspace(cmdline[cursor - 1])) 525 cursor--; 526 527 while (cursor && !my_isspace(cmdline[cursor - 1])) 528 cursor--; 529 530 memmove(cmdline + cursor, cmdline + prevcursor, 531 len - prevcursor + 1); 532 len -= (prevcursor - cursor); 533 redraw = 1; 534 } 535 break; 536 537 case KEY_LEFT: 538 case KEY_CTRL('B'): 539 if (cursor) { 540 cursor--; 541 redraw = 1; 542 } 543 break; 544 545 case KEY_RIGHT: 546 case KEY_CTRL('F'): 547 if (cursor < len) { 548 putchar(cmdline[cursor++]); 549 } 550 break; 551 552 case KEY_CTRL('K'): 553 if (cursor < len) { 554 cmdline[len = cursor] = '\0'; 555 redraw = 1; 556 } 557 break; 558 559 case KEY_HOME: 560 case KEY_CTRL('A'): 561 if (cursor) { 562 cursor = 0; 563 redraw = 1; 564 } 565 break; 566 567 case KEY_END: 568 case KEY_CTRL('E'): 569 if (cursor != len) { 570 cursor = len; 571 redraw = 1; 572 } 573 break; 574 575 case KEY_F1: 576 case KEY_F2: 577 case KEY_F3: 578 case KEY_F4: 579 case KEY_F5: 580 case KEY_F6: 581 case KEY_F7: 582 case KEY_F8: 583 case KEY_F9: 584 case KEY_F10: 585 case KEY_F11: 586 case KEY_F12: 587 show_fkey(key); 588 redraw = 1; 589 break; 590 591 default: 592 if (key >= ' ' && key <= 0xFF && len < MAX_CMDLINE_LEN - 1) { 593 if (cursor == len) { 594 cmdline[len] = key; 595 cmdline[++len] = '\0'; 596 cursor++; 597 putchar(key); 598 prev_len++; 599 } else { 600 memmove(cmdline + cursor + 1, cmdline + cursor, 601 len - cursor + 1); 602 cmdline[cursor++] = key; 603 len++; 604 redraw = 1; 605 } 606 } 607 break; 608 } 609 } 610 } 611 612 static void print_timeout_message(int tol, int row, const char *msg) 613 { 614 static int last_msg_len = 0; 615 char buf[256]; 616 int nc = 0, nnc, padc; 617 const char *tp = msg; 618 char tc; 619 char *tq = buf; 620 621 while ((size_t) (tq - buf) < (sizeof buf - 16) && (tc = *tp)) { 622 tp++; 623 if (tc == '#') { 624 nnc = sprintf(tq, "\2#15%d\2#14", tol); 625 tq += nnc; 626 nc += nnc - 8; /* 8 formatting characters */ 627 } else if (tc == '{') { 628 /* Deal with {singular[,dual],plural} constructs */ 629 struct { 630 const char *s, *e; 631 } tx[3]; 632 const char *tpp; 633 int n = 0; 634 635 memset(tx, 0, sizeof tx); 636 637 tx[0].s = tp; 638 639 while (*tp && *tp != '}') { 640 if (*tp == ',' && n < 2) { 641 tx[n].e = tp; 642 n++; 643 tx[n].s = tp + 1; 644 } 645 tp++; 646 } 647 tx[n].e = tp; 648 649 if (*tp) 650 tp++; /* Skip final bracket */ 651 652 if (!tx[1].s) 653 tx[1] = tx[0]; 654 if (!tx[2].s) 655 tx[2] = tx[1]; 656 657 /* Now [0] is singular, [1] is dual, and [2] is plural, 658 even if the user only specified some of them. */ 659 660 switch (tol) { 661 case 1: 662 n = 0; 663 break; 664 case 2: 665 n = 1; 666 break; 667 default: 668 n = 2; 669 break; 670 } 671 672 for (tpp = tx[n].s; tpp < tx[n].e; tpp++) { 673 if ((size_t) (tq - buf) < (sizeof buf)) { 674 *tq++ = *tpp; 675 nc++; 676 } 677 } 678 } else { 679 *tq++ = tc; 680 nc++; 681 } 682 } 683 *tq = '\0'; 684 685 if (nc >= last_msg_len) { 686 padc = 0; 687 } else { 688 padc = (last_msg_len - nc + 1) >> 1; 689 } 690 691 printf("\033[%d;%dH\2#14%*s%s%*s", row, 692 HSHIFT + 1 + ((WIDTH - nc) >> 1) - padc, 693 padc, "", buf, padc, ""); 694 695 last_msg_len = nc; 696 } 697 698 /* Set the background screen, etc. */ 699 static void prepare_screen_for_menu(void) 700 { 701 console_color_table = cm->color_table; 702 console_color_table_size = menu_color_table_size; 703 set_background(cm->menu_background); 704 } 705 706 static const char *do_hidden_menu(void) 707 { 708 int key; 709 int timeout_left, this_timeout; 710 711 clear_screen(); 712 713 if (!setjmp(timeout_jump)) { 714 timeout_left = cm->timeout; 715 716 while (!cm->timeout || timeout_left) { 717 int tol = timeout_left / CLK_TCK; 718 719 print_timeout_message(tol, HIDDEN_ROW, cm->messages[MSG_AUTOBOOT]); 720 721 this_timeout = min(timeout_left, CLK_TCK); 722 key = mygetkey(this_timeout); 723 724 if (key != KEY_NONE) { 725 /* Clear the message from the screen */ 726 print_timeout_message(0, HIDDEN_ROW, ""); 727 return hide_key[key]; /* NULL if no MENU HIDEKEY in effect */ 728 } 729 730 timeout_left -= this_timeout; 731 } 732 } 733 734 /* Clear the message from the screen */ 735 print_timeout_message(0, HIDDEN_ROW, ""); 736 737 if (cm->ontimeout) 738 return cm->ontimeout; 739 else 740 return cm->menu_entries[cm->defentry]->cmdline; /* Default entry */ 741 } 742 743 static const char *run_menu(void) 744 { 745 int key; 746 int done = 0; 747 volatile int entry = cm->curentry; 748 int prev_entry = -1; 749 volatile int top = cm->curtop; 750 int prev_top = -1; 751 int clear = 1, to_clear; 752 const char *cmdline = NULL; 753 volatile clock_t key_timeout, timeout_left, this_timeout; 754 const struct menu_entry *me; 755 bool hotkey = false; 756 757 /* Note: for both key_timeout and timeout == 0 means no limit */ 758 timeout_left = key_timeout = cm->timeout; 759 760 /* If we're in shiftkey mode, exit immediately unless a shift key 761 is pressed */ 762 if (shiftkey && !shift_is_held()) { 763 return cm->menu_entries[cm->defentry]->cmdline; 764 } else { 765 shiftkey = 0; 766 } 767 768 /* Do this before hiddenmenu handling, so we show the background */ 769 prepare_screen_for_menu(); 770 771 /* Handle hiddenmenu */ 772 if (hiddenmenu) { 773 cmdline = do_hidden_menu(); 774 if (cmdline) 775 return cmdline; 776 777 /* Otherwise display the menu now; the timeout has already been 778 cancelled, since the user pressed a key. */ 779 hiddenmenu = 0; 780 key_timeout = 0; 781 } 782 783 /* Handle both local and global timeout */ 784 if (setjmp(timeout_jump)) { 785 entry = cm->defentry; 786 787 if (top < 0 || top < entry - MENU_ROWS + 1) 788 top = max(0, entry - MENU_ROWS + 1); 789 else if (top > entry || top > max(0, cm->nentries - MENU_ROWS)) 790 top = min(entry, max(0, cm->nentries - MENU_ROWS)); 791 792 draw_menu(cm->ontimeout ? -1 : entry, top, 1); 793 cmdline = 794 cm->ontimeout ? cm->ontimeout : cm->menu_entries[entry]->cmdline; 795 done = 1; 796 } 797 798 while (!done) { 799 if (entry <= 0) { 800 entry = 0; 801 while (entry < cm->nentries && is_disabled(cm->menu_entries[entry])) 802 entry++; 803 } 804 if (entry >= cm->nentries - 1) { 805 entry = cm->nentries - 1; 806 while (entry > 0 && is_disabled(cm->menu_entries[entry])) 807 entry--; 808 } 809 810 me = cm->menu_entries[entry]; 811 812 if (top < 0 || top < entry - MENU_ROWS + 1) 813 top = max(0, entry - MENU_ROWS + 1); 814 else if (top > entry || top > max(0, cm->nentries - MENU_ROWS)) 815 top = min(entry, max(0, cm->nentries - MENU_ROWS)); 816 817 /* Start with a clear screen */ 818 if (clear) { 819 /* Clear and redraw whole screen */ 820 /* Enable ASCII on G0 and DEC VT on G1; do it in this order 821 to avoid confusing the Linux console */ 822 if (clear >= 2) 823 prepare_screen_for_menu(); 824 clear_screen(); 825 clear = 0; 826 prev_entry = prev_top = -1; 827 } 828 829 if (top != prev_top) { 830 draw_menu(entry, top, 1); 831 display_help(me->helptext); 832 } else if (entry != prev_entry) { 833 draw_row(prev_entry - top + 4 + VSHIFT, entry, top, 0, 0); 834 draw_row(entry - top + 4 + VSHIFT, entry, top, 0, 0); 835 display_help(me->helptext); 836 } 837 838 prev_entry = entry; 839 prev_top = top; 840 cm->curentry = entry; 841 cm->curtop = top; 842 843 /* Cursor movement cancels timeout */ 844 if (entry != cm->defentry) 845 key_timeout = 0; 846 847 if (key_timeout) { 848 int tol = timeout_left / CLK_TCK; 849 print_timeout_message(tol, TIMEOUT_ROW, cm->messages[MSG_AUTOBOOT]); 850 to_clear = 1; 851 } else { 852 to_clear = 0; 853 } 854 855 if (hotkey && me->immediate) { 856 /* If the hotkey was flagged immediate, simulate pressing ENTER */ 857 key = KEY_ENTER; 858 } else { 859 this_timeout = min(min(key_timeout, timeout_left), 860 (clock_t) CLK_TCK); 861 key = mygetkey(this_timeout); 862 863 if (key != KEY_NONE) { 864 timeout_left = key_timeout; 865 if (to_clear) 866 printf("\033[%d;1H\1#0\033[K", TIMEOUT_ROW); 867 } 868 } 869 870 hotkey = false; 871 872 switch (key) { 873 case KEY_NONE: /* Timeout */ 874 /* This is somewhat hacky, but this at least lets the user 875 know what's going on, and still deals with "phantom inputs" 876 e.g. on serial ports. 877 878 Warning: a timeout will boot the default entry without any 879 password! */ 880 if (key_timeout) { 881 if (timeout_left <= this_timeout) 882 longjmp(timeout_jump, 1); 883 884 timeout_left -= this_timeout; 885 } 886 break; 887 888 case KEY_CTRL('L'): 889 clear = 1; 890 break; 891 892 case KEY_ENTER: 893 case KEY_CTRL('J'): 894 key_timeout = 0; /* Cancels timeout */ 895 if (me->passwd) { 896 clear = 1; 897 done = ask_passwd(me->passwd); 898 } else { 899 done = 1; 900 } 901 cmdline = NULL; 902 if (done) { 903 switch (me->action) { 904 case MA_CMD: 905 cmdline = me->cmdline; 906 break; 907 case MA_SUBMENU: 908 case MA_GOTO: 909 case MA_EXIT: 910 done = 0; 911 clear = 2; 912 cm = me->submenu; 913 entry = cm->curentry; 914 top = cm->curtop; 915 break; 916 case MA_QUIT: 917 /* Quit menu system */ 918 done = 1; 919 clear = 1; 920 draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0); 921 break; 922 case MA_HELP: 923 key = show_message_file(me->cmdline, me->background); 924 /* If the exit was an F-key, display that help screen */ 925 show_fkey(key); 926 done = 0; 927 clear = 1; 928 break; 929 default: 930 done = 0; 931 break; 932 } 933 } 934 if (done && !me->passwd) { 935 /* Only save a new default if we don't have a password... */ 936 if (me->save && me->label) { 937 syslinux_setadv(ADV_MENUSAVE, strlen(me->label), me->label); 938 syslinux_adv_write(); 939 } 940 } 941 break; 942 943 case KEY_UP: 944 case KEY_CTRL('P'): 945 while (entry > 0) { 946 entry--; 947 if (entry < top) 948 top -= MENU_ROWS; 949 if (!is_disabled(cm->menu_entries[entry])) 950 break; 951 } 952 break; 953 954 case KEY_DOWN: 955 case KEY_CTRL('N'): 956 while (entry < cm->nentries - 1) { 957 entry++; 958 if (entry >= top + MENU_ROWS) 959 top += MENU_ROWS; 960 if (!is_disabled(cm->menu_entries[entry])) 961 break; 962 } 963 break; 964 965 case KEY_PGUP: 966 case KEY_LEFT: 967 case KEY_CTRL('B'): 968 case '<': 969 entry -= MENU_ROWS; 970 top -= MENU_ROWS; 971 while (entry > 0 && is_disabled(cm->menu_entries[entry])) { 972 entry--; 973 if (entry < top) 974 top -= MENU_ROWS; 975 } 976 break; 977 978 case KEY_PGDN: 979 case KEY_RIGHT: 980 case KEY_CTRL('F'): 981 case '>': 982 case ' ': 983 entry += MENU_ROWS; 984 top += MENU_ROWS; 985 while (entry < cm->nentries - 1 986 && is_disabled(cm->menu_entries[entry])) { 987 entry++; 988 if (entry >= top + MENU_ROWS) 989 top += MENU_ROWS; 990 } 991 break; 992 993 case '-': 994 while (entry > 0) { 995 entry--; 996 top--; 997 if (!is_disabled(cm->menu_entries[entry])) 998 break; 999 } 1000 break; 1001 1002 case '+': 1003 while (entry < cm->nentries - 1) { 1004 entry++; 1005 top++; 1006 if (!is_disabled(cm->menu_entries[entry])) 1007 break; 1008 } 1009 break; 1010 1011 case KEY_CTRL('A'): 1012 case KEY_HOME: 1013 top = entry = 0; 1014 break; 1015 1016 case KEY_CTRL('E'): 1017 case KEY_END: 1018 entry = cm->nentries - 1; 1019 top = max(0, cm->nentries - MENU_ROWS); 1020 break; 1021 1022 case KEY_F1: 1023 case KEY_F2: 1024 case KEY_F3: 1025 case KEY_F4: 1026 case KEY_F5: 1027 case KEY_F6: 1028 case KEY_F7: 1029 case KEY_F8: 1030 case KEY_F9: 1031 case KEY_F10: 1032 case KEY_F11: 1033 case KEY_F12: 1034 show_fkey(key); 1035 clear = 1; 1036 break; 1037 1038 case KEY_TAB: 1039 if (cm->allowedit && me->action == MA_CMD) { 1040 int ok = 1; 1041 1042 key_timeout = 0; /* Cancels timeout */ 1043 draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0); 1044 1045 if (cm->menu_master_passwd) { 1046 ok = ask_passwd(NULL); 1047 clear_screen(); 1048 draw_menu(-1, top, 0); 1049 } else { 1050 /* Erase [Tab] message and help text */ 1051 printf("\033[%d;1H\1#0\033[K", TABMSG_ROW); 1052 display_help(NULL); 1053 } 1054 1055 if (ok) { 1056 cmdline = edit_cmdline(me->cmdline, top); 1057 done = !!cmdline; 1058 clear = 1; /* In case we hit [Esc] and done is null */ 1059 } else { 1060 draw_row(entry - top + 4 + VSHIFT, entry, top, 0, 0); 1061 } 1062 } 1063 break; 1064 case KEY_CTRL('C'): /* Ctrl-C */ 1065 case KEY_ESC: /* Esc */ 1066 if (cm->parent) { 1067 cm = cm->parent; 1068 clear = 2; 1069 entry = cm->curentry; 1070 top = cm->curtop; 1071 } else if (cm->allowedit) { 1072 done = 1; 1073 clear = 1; 1074 key_timeout = 0; 1075 1076 draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0); 1077 1078 if (cm->menu_master_passwd) 1079 done = ask_passwd(NULL); 1080 } 1081 break; 1082 default: 1083 if (key > 0 && key < 0xFF) { 1084 key &= ~0x20; /* Upper case */ 1085 if (cm->menu_hotkeys[key]) { 1086 key_timeout = 0; 1087 entry = cm->menu_hotkeys[key]->entry; 1088 /* Should we commit at this point? */ 1089 hotkey = true; 1090 } 1091 } 1092 break; 1093 } 1094 } 1095 1096 printf("\033[?25h"); /* Show cursor */ 1097 1098 /* Return the label name so localboot and ipappend work */ 1099 return cmdline; 1100 } 1101 1102 int main(int argc, char *argv[]) 1103 { 1104 const char *cmdline; 1105 struct menu *m; 1106 int rows, cols; 1107 int i; 1108 1109 (void)argc; 1110 1111 parse_configs(argv + 1); 1112 1113 /* 1114 * We don't start the console until we have parsed the configuration 1115 * file, since the configuration file might impact the console 1116 * configuration, e.g. MENU RESOLUTION. 1117 */ 1118 start_console(); 1119 if (getscreensize(1, &rows, &cols)) { 1120 /* Unknown screen size? */ 1121 rows = 24; 1122 cols = 80; 1123 } 1124 1125 /* Some postprocessing for all menus */ 1126 for (m = menu_list; m; m = m->next) { 1127 if (!m->mparm[P_WIDTH]) 1128 m->mparm[P_WIDTH] = cols; 1129 1130 /* If anyone has specified negative parameters, consider them 1131 relative to the bottom row of the screen. */ 1132 for (i = 0; i < NPARAMS; i++) 1133 if (m->mparm[i] < 0) 1134 m->mparm[i] = max(m->mparm[i] + rows, 0); 1135 } 1136 1137 cm = start_menu; 1138 1139 if (!cm->nentries) { 1140 fputs("Initial menu has no LABEL entries!\n", stdout); 1141 return 1; /* Error! */ 1142 } 1143 1144 for (;;) { 1145 local_cursor_enable(true); 1146 cmdline = run_menu(); 1147 1148 if (clearmenu) 1149 clear_screen(); 1150 1151 local_cursor_enable(false); 1152 printf("\033[?25h\033[%d;1H\033[0m", END_ROW); 1153 1154 if (cmdline) { 1155 uint32_t type = parse_image_type(cmdline); 1156 1157 execute(cmdline, type, false); 1158 if (cm->onerror) { 1159 type = parse_image_type(cm->onerror); 1160 execute(cm->onerror, type, true); 1161 } 1162 } else { 1163 return 0; /* Exit */ 1164 } 1165 } 1166 } 1167
