com32/menu/menumain.c

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