com32/menu/menumain.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2004-2008 H. Peter Anvin - All Rights Reserved
   4  *   Copyright 2009-2011 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 inline int shift_is_held(void)
 613 {
 614     uint8_t shift_bits = *(uint8_t *) 0x417;
 615
 616     return !!(shift_bits & 0x5d);       /* Caps/Scroll/Alt/Shift */
 617 }
 618
 619 static void print_timeout_message(int tol, int row, const char *msg)
 620 {
 621     static int last_msg_len = 0;
 622     char buf[256];
 623     int nc = 0, nnc, padc;
 624     const char *tp = msg;
 625     char tc;
 626     char *tq = buf;
 627
 628     while ((size_t) (tq - buf) < (sizeof buf - 16) && (tc = *tp)) {
 629         tp++;
 630         if (tc == '#') {
 631             nnc = sprintf(tq, "\2#15%d\2#14", tol);
 632             tq += nnc;
 633             nc += nnc - 8;      /* 8 formatting characters */
 634         } else if (tc == '{') {
 635             /* Deal with {singular[,dual],plural} constructs */
 636             struct {
 637                 const char *s, *e;
 638             } tx[3];
 639             const char *tpp;
 640             int n = 0;
 641
 642             memset(tx, 0, sizeof tx);
 643
 644             tx[0].s = tp;
 645
 646             while (*tp && *tp != '}') {
 647                 if (*tp == ',' && n < 2) {
 648                     tx[n].e = tp;
 649                     n++;
 650                     tx[n].s = tp + 1;
 651                 }
 652                 tp++;
 653             }
 654             tx[n].e = tp;
 655
 656             if (*tp)
 657                 tp++;           /* Skip final bracket */
 658
 659             if (!tx[1].s)
 660                 tx[1] = tx[0];
 661             if (!tx[2].s)
 662                 tx[2] = tx[1];
 663
 664             /* Now [0] is singular, [1] is dual, and [2] is plural,
 665                even if the user only specified some of them. */
 666
 667             switch (tol) {
 668             case 1:
 669                 n = 0;
 670                 break;
 671             case 2:
 672                 n = 1;
 673                 break;
 674             default:
 675                 n = 2;
 676                 break;
 677             }
 678
 679             for (tpp = tx[n].s; tpp < tx[n].e; tpp++) {
 680                 if ((size_t) (tq - buf) < (sizeof buf)) {
 681                     *tq++ = *tpp;
 682                     nc++;
 683                 }
 684             }
 685         } else {
 686             *tq++ = tc;
 687             nc++;
 688         }
 689     }
 690     *tq = '\0';
 691
 692     if (nc >= last_msg_len) {
 693         padc = 0;
 694     } else {
 695         padc = (last_msg_len - nc + 1) >> 1;
 696     }
 697
 698     printf("\033[%d;%dH\2#14%*s%s%*s", row,
 699            HSHIFT + 1 + ((WIDTH - nc) >> 1) - padc,
 700            padc, "", buf, padc, "");
 701
 702     last_msg_len = nc;
 703 }
 704
 705 /* Set the background screen, etc. */
 706 static void prepare_screen_for_menu(void)
 707 {
 708     console_color_table = cm->color_table;
 709     console_color_table_size = menu_color_table_size;
 710     set_background(cm->menu_background);
 711 }
 712
 713 static const char *do_hidden_menu(void)
 714 {
 715     int key;
 716     int timeout_left, this_timeout;
 717
 718     clear_screen();
 719
 720     if (!setjmp(timeout_jump)) {
 721         timeout_left = cm->timeout;
 722
 723         while (!cm->timeout || timeout_left) {
 724             int tol = timeout_left / CLK_TCK;
 725
 726             print_timeout_message(tol, HIDDEN_ROW, cm->messages[MSG_AUTOBOOT]);
 727
 728             this_timeout = min(timeout_left, CLK_TCK);
 729             key = mygetkey(this_timeout);
 730
 731             if (key != KEY_NONE) {
 732                 /* Clear the message from the screen */
 733                 print_timeout_message(0, HIDDEN_ROW, "");
 734                 return hide_key[key]; /* NULL if no MENU HIDEKEY in effect */
 735             }
 736
 737             timeout_left -= this_timeout;
 738         }
 739     }
 740
 741     /* Clear the message from the screen */
 742     print_timeout_message(0, HIDDEN_ROW, "");
 743
 744     if (cm->ontimeout)
 745         return cm->ontimeout;
 746     else
 747         return cm->menu_entries[cm->defentry]->cmdline; /* Default entry */
 748 }
 749
 750 static const char *run_menu(void)
 751 {
 752     int key;
 753     int done = 0;
 754     volatile int entry = cm->curentry;
 755     int prev_entry = -1;
 756     volatile int top = cm->curtop;
 757     int prev_top = -1;
 758     int clear = 1, to_clear;
 759     const char *cmdline = NULL;
 760     volatile clock_t key_timeout, timeout_left, this_timeout;
 761     const struct menu_entry *me;
 762     bool hotkey = false;
 763
 764     /* Note: for both key_timeout and timeout == 0 means no limit */
 765     timeout_left = key_timeout = cm->timeout;
 766
 767     /* If we're in shiftkey mode, exit immediately unless a shift key
 768        is pressed */
 769     if (shiftkey && !shift_is_held()) {
 770         return cm->menu_entries[cm->defentry]->cmdline;
 771     } else {
 772         shiftkey = 0;
 773     }
 774
 775     /* Do this before hiddenmenu handling, so we show the background */
 776     prepare_screen_for_menu();
 777
 778     /* Handle hiddenmenu */
 779     if (hiddenmenu) {
 780         cmdline = do_hidden_menu();
 781         if (cmdline)
 782             return cmdline;
 783
 784         /* Otherwise display the menu now; the timeout has already been
 785            cancelled, since the user pressed a key. */
 786         hiddenmenu = 0;
 787         key_timeout = 0;
 788     }
 789
 790     /* Handle both local and global timeout */
 791     if (setjmp(timeout_jump)) {
 792         entry = cm->defentry;
 793
 794         if (top < 0 || top < entry - MENU_ROWS + 1)
 795             top = max(0, entry - MENU_ROWS + 1);
 796         else if (top > entry || top > max(0, cm->nentries - MENU_ROWS))
 797             top = min(entry, max(0, cm->nentries - MENU_ROWS));
 798
 799         draw_menu(cm->ontimeout ? -1 : entry, top, 1);
 800         cmdline =
 801             cm->ontimeout ? cm->ontimeout : cm->menu_entries[entry]->cmdline;
 802         done = 1;
 803     }
 804
 805     while (!done) {
 806         if (entry <= 0) {
 807             entry = 0;
 808             while (entry < cm->nentries && is_disabled(cm->menu_entries[entry]))
 809                 entry++;
 810         }
 811         if (entry >= cm->nentries - 1) {
 812             entry = cm->nentries - 1;
 813             while (entry > 0 && is_disabled(cm->menu_entries[entry]))
 814                 entry--;
 815         }
 816
 817         me = cm->menu_entries[entry];
 818
 819         if (top < 0 || top < entry - MENU_ROWS + 1)
 820             top = max(0, entry - MENU_ROWS + 1);
 821         else if (top > entry || top > max(0, cm->nentries - MENU_ROWS))
 822             top = min(entry, max(0, cm->nentries - MENU_ROWS));
 823
 824         /* Start with a clear screen */
 825         if (clear) {
 826             /* Clear and redraw whole screen */
 827             /* Enable ASCII on G0 and DEC VT on G1; do it in this order
 828                to avoid confusing the Linux console */
 829             if (clear >= 2)
 830                 prepare_screen_for_menu();
 831             clear_screen();
 832             clear = 0;
 833             prev_entry = prev_top = -1;
 834         }
 835
 836         if (top != prev_top) {
 837             draw_menu(entry, top, 1);
 838             display_help(me->helptext);
 839         } else if (entry != prev_entry) {
 840             draw_row(prev_entry - top + 4 + VSHIFT, entry, top, 0, 0);
 841             draw_row(entry - top + 4 + VSHIFT, entry, top, 0, 0);
 842             display_help(me->helptext);
 843         }
 844
 845         prev_entry = entry;
 846         prev_top = top;
 847         cm->curentry = entry;
 848         cm->curtop = top;
 849
 850         /* Cursor movement cancels timeout */
 851         if (entry != cm->defentry)
 852             key_timeout = 0;
 853
 854         if (key_timeout) {
 855             int tol = timeout_left / CLK_TCK;
 856             print_timeout_message(tol, TIMEOUT_ROW, cm->messages[MSG_AUTOBOOT]);
 857             to_clear = 1;
 858         } else {
 859             to_clear = 0;
 860         }
 861
 862         if (hotkey && me->immediate) {
 863             /* If the hotkey was flagged immediate, simulate pressing ENTER */
 864             key = KEY_ENTER;
 865         } else {
 866             this_timeout = min(min(key_timeout, timeout_left),
 867                                (clock_t) CLK_TCK);
 868             key = mygetkey(this_timeout);
 869
 870             if (key != KEY_NONE) {
 871                 timeout_left = key_timeout;
 872                 if (to_clear)
 873                     printf("\033[%d;1H\1#0\033[K", TIMEOUT_ROW);
 874             }
 875         }
 876
 877         hotkey = false;
 878
 879         switch (key) {
 880         case KEY_NONE:          /* Timeout */
 881             /* This is somewhat hacky, but this at least lets the user
 882                know what's going on, and still deals with "phantom inputs"
 883                e.g. on serial ports.
 884
 885                Warning: a timeout will boot the default entry without any
 886                password! */
 887             if (key_timeout) {
 888                 if (timeout_left <= this_timeout)
 889                     longjmp(timeout_jump, 1);
 890
 891                 timeout_left -= this_timeout;
 892             }
 893             break;
 894
 895         case KEY_CTRL('L'):
 896             clear = 1;
 897             break;
 898
 899         case KEY_ENTER:
 900         case KEY_CTRL('J'):
 901             key_timeout = 0;    /* Cancels timeout */
 902             if (me->passwd) {
 903                 clear = 1;
 904                 done = ask_passwd(me->passwd);
 905             } else {
 906                 done = 1;
 907             }
 908             cmdline = NULL;
 909             if (done) {
 910                 switch (me->action) {
 911                 case MA_CMD:
 912                     cmdline = me->cmdline;
 913                     break;
 914                 case MA_SUBMENU:
 915                 case MA_GOTO:
 916                 case MA_EXIT:
 917                     done = 0;
 918                     clear = 2;
 919                     cm = me->submenu;
 920                     entry = cm->curentry;
 921                     top = cm->curtop;
 922                     break;
 923                 case MA_QUIT:
 924                     /* Quit menu system */
 925                     done = 1;
 926                     clear = 1;
 927                     draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0);
 928                     break;
 929                 case MA_HELP:
 930                     key = show_message_file(me->cmdline, me->background);
 931                     /* If the exit was an F-key, display that help screen */
 932                     show_fkey(key);
 933                     done = 0;
 934                     clear = 1;
 935                     break;
 936                 default:
 937                     done = 0;
 938                     break;
 939                 }
 940             }
 941             if (done && !me->passwd) {
 942                 /* Only save a new default if we don't have a password... */
 943                 if (me->save && me->label) {
 944                     syslinux_setadv(ADV_MENUSAVE, strlen(me->label), me->label);
 945                     syslinux_adv_write();
 946                 }
 947             }
 948             break;
 949
 950         case KEY_UP:
 951         case KEY_CTRL('P'):
 952             while (entry > 0) {
 953                 entry--;
 954                 if (entry < top)
 955                     top -= MENU_ROWS;
 956                 if (!is_disabled(cm->menu_entries[entry]))
 957                     break;
 958             }
 959             break;
 960
 961         case KEY_DOWN:
 962         case KEY_CTRL('N'):
 963             while (entry < cm->nentries - 1) {
 964                 entry++;
 965                 if (entry >= top + MENU_ROWS)
 966                     top += MENU_ROWS;
 967                 if (!is_disabled(cm->menu_entries[entry]))
 968                     break;
 969             }
 970             break;
 971
 972         case KEY_PGUP:
 973         case KEY_LEFT:
 974         case KEY_CTRL('B'):
 975         case '<':
 976             entry -= MENU_ROWS;
 977             top -= MENU_ROWS;
 978             while (entry > 0 && is_disabled(cm->menu_entries[entry])) {
 979                 entry--;
 980                 if (entry < top)
 981                     top -= MENU_ROWS;
 982             }
 983             break;
 984
 985         case KEY_PGDN:
 986         case KEY_RIGHT:
 987         case KEY_CTRL('F'):
 988         case '>':
 989         case ' ':
 990             entry += MENU_ROWS;
 991             top += MENU_ROWS;
 992             while (entry < cm->nentries - 1
 993                    && is_disabled(cm->menu_entries[entry])) {
 994                 entry++;
 995                 if (entry >= top + MENU_ROWS)
 996                     top += MENU_ROWS;
 997             }
 998             break;
 999
1000         case '-':
1001             while (entry > 0) {
1002                 entry--;
1003                 top--;
1004                 if (!is_disabled(cm->menu_entries[entry]))
1005                     break;
1006             }
1007             break;
1008
1009         case '+':
1010             while (entry < cm->nentries - 1) {
1011                 entry++;
1012                 top++;
1013                 if (!is_disabled(cm->menu_entries[entry]))
1014                     break;
1015             }
1016             break;
1017
1018         case KEY_CTRL('A'):
1019         case KEY_HOME:
1020             top = entry = 0;
1021             break;
1022
1023         case KEY_CTRL('E'):
1024         case KEY_END:
1025             entry = cm->nentries - 1;
1026             top = max(0, cm->nentries - MENU_ROWS);
1027             break;
1028
1029         case KEY_F1:
1030         case KEY_F2:
1031         case KEY_F3:
1032         case KEY_F4:
1033         case KEY_F5:
1034         case KEY_F6:
1035         case KEY_F7:
1036         case KEY_F8:
1037         case KEY_F9:
1038         case KEY_F10:
1039         case KEY_F11:
1040         case KEY_F12:
1041             show_fkey(key);
1042             clear = 1;
1043             break;
1044
1045         case KEY_TAB:
1046             if (cm->allowedit && me->action == MA_CMD) {
1047                 int ok = 1;
1048
1049                 key_timeout = 0;        /* Cancels timeout */
1050                 draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0);
1051
1052                 if (cm->menu_master_passwd) {
1053                     ok = ask_passwd(NULL);
1054                     clear_screen();
1055                     draw_menu(-1, top, 0);
1056                 } else {
1057                     /* Erase [Tab] message and help text */
1058                     printf("\033[%d;1H\1#0\033[K", TABMSG_ROW);
1059                     display_help(NULL);
1060                 }
1061
1062                 if (ok) {
1063                     cmdline = edit_cmdline(me->cmdline, top);
1064                     done = !!cmdline;
1065                     clear = 1;  /* In case we hit [Esc] and done is null */
1066                 } else {
1067                     draw_row(entry - top + 4 + VSHIFT, entry, top, 0, 0);
1068                 }
1069             }
1070             break;
1071         case KEY_CTRL('C'):     /* Ctrl-C */
1072         case KEY_ESC:           /* Esc */
1073             if (cm->parent) {
1074                 cm = cm->parent;
1075                 clear = 2;
1076                 entry = cm->curentry;
1077                 top = cm->curtop;
1078             } else if (cm->allowedit) {
1079                 done = 1;
1080                 clear = 1;
1081                 key_timeout = 0;
1082
1083                 draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0);
1084
1085                 if (cm->menu_master_passwd)
1086                     done = ask_passwd(NULL);
1087             }
1088             break;
1089         default:
1090             if (key > 0 && key < 0xFF) {
1091                 key &= ~0x20;   /* Upper case */
1092                 if (cm->menu_hotkeys[key]) {
1093                     key_timeout = 0;
1094                     entry = cm->menu_hotkeys[key]->entry;
1095                     /* Should we commit at this point? */
1096                     hotkey = true;
1097                 }
1098             }
1099             break;
1100         }
1101     }
1102
1103     printf("\033[?25h");        /* Show cursor */
1104
1105     /* Return the label name so localboot and ipappend work */
1106     return cmdline;
1107 }
1108
1109 int main(int argc, char *argv[])
1110 {
1111     const char *cmdline;
1112     struct menu *m;
1113     int rows, cols;
1114     int i;
1115
1116     (void)argc;
1117
1118     parse_configs(argv + 1);
1119
1120     /*
1121      * We don't start the console until we have parsed the configuration
1122      * file, since the configuration file might impact the console
1123      * configuration, e.g. MENU RESOLUTION.
1124      */
1125     start_console();
1126     if (getscreensize(1, &rows, &cols)) {
1127         /* Unknown screen size? */
1128         rows = 24;
1129         cols = 80;
1130     }
1131
1132     /* Some postprocessing for all menus */
1133     for (m = menu_list; m; m = m->next) {
1134         if (!m->mparm[P_WIDTH])
1135             m->mparm[P_WIDTH] = cols;
1136
1137         /* If anyone has specified negative parameters, consider them
1138            relative to the bottom row of the screen. */
1139         for (i = 0; i < NPARAMS; i++)
1140             if (m->mparm[i] < 0)
1141                 m->mparm[i] = max(m->mparm[i] + rows, 0);
1142     }
1143
1144     cm = start_menu;
1145
1146     if (!cm->nentries) {
1147         fputs("Initial menu has no LABEL entries!\n", stdout);
1148         return 1;               /* Error! */
1149     }
1150
1151     for (;;) {
1152         local_cursor_enable(true);
1153         cmdline = run_menu();
1154
1155         if (clearmenu)
1156             clear_screen();
1157
1158         local_cursor_enable(false);
1159         printf("\033[?25h\033[%d;1H\033[0m", END_ROW);
1160
1161         if (cmdline) {
1162             uint32_t type = parse_image_type(cmdline);
1163
1164             execute(cmdline, type, false);
1165             if (cm->onerror) {
1166                 type = parse_image_type(cm->onerror);
1167                 execute(cm->onerror, type, true);
1168             }
1169         } else {
1170             return 0;           /* Exit */
1171         }
1172     }
1173 }