com32/menu/readconfig.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2004-2009 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 #include <stdio.h>
  15 #include <stdbool.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <ctype.h>
  19 #include <minmax.h>
  20 #include <alloca.h>
  21 #include <inttypes.h>
  22 #include <colortbl.h>
  23 #include <com32.h>
  24 #include <syslinux/adv.h>
  25 #include <syslinux/config.h>
  26
  27 #include "menu.h"
  28
  29 /* Empty refstring */
  30 const char *empty_string;
  31
  32 /* Root menu, starting menu, hidden menu, and list of all menus */
  33 struct menu *root_menu, *start_menu, *hide_menu, *menu_list;
  34
  35 /* These are global parameters regardless of which menu we're displaying */
  36 int shiftkey = 0;               /* Only display menu if shift key pressed */
  37 int hiddenmenu = 0;
  38 int clearmenu = 0;
  39 long long totaltimeout = 0;
  40 const char *hide_key[KEY_MAX];
  41
  42 /* Keep track of global default */
  43 static int has_ui = 0;          /* DEFAULT only counts if UI is found */
  44 static const char *globaldefault = NULL;
  45 static bool menusave = false;   /* True if there is any "menu save" */
  46
  47 /* Linked list of all entires, hidden or not; used by unlabel() */
  48 static struct menu_entry *all_entries;
  49 static struct menu_entry **all_entries_end = &all_entries;
  50
  51 static const struct messages messages[MSG_COUNT] = {
  52     [MSG_AUTOBOOT] = {"autoboot", "Automatic boot in # second{,s}..."},
  53     [MSG_TAB] = {"tabmsg", "Press [Tab] to edit options"},
  54     [MSG_NOTAB] = {"notabmsg", ""},
  55     [MSG_PASSPROMPT] = {"passprompt", "Password required"},
  56 };
  57
  58 #define astrdup(x) ({ char *__x = (x); \
  59                       size_t __n = strlen(__x) + 1; \
  60                       char *__p = alloca(__n); \
  61                       if ( __p ) memcpy(__p, __x, __n); \
  62                       __p; })
  63
  64 /* Must match enum kernel_type */
  65 static const char *const kernel_types[] = {
  66     "none",
  67     "localboot",
  68     "kernel",
  69     "linux",
  70     "boot",
  71     "bss",
  72     "pxe",
  73     "fdimage",
  74     "comboot",
  75     "com32",
  76     "config",
  77     NULL
  78 };
  79
  80 /*
  81  * Search the list of all menus for a specific label
  82  */
  83 static struct menu *find_menu(const char *label)
  84 {
  85     struct menu *m;
  86
  87     for (m = menu_list; m; m = m->next) {
  88         if (!strcmp(label, m->label))
  89             return m;
  90     }
  91
  92     return NULL;
  93 }
  94
  95 #define MAX_LINE 4096
  96
  97 /* Strip ^ from a string, returning a new reference to the same refstring
  98    if none present */
  99 static const char *strip_caret(const char *str)
 100 {
 101     const char *p, *r;
 102     char *q;
 103     int carets = 0;
 104
 105     p = str;
 106     for (;;) {
 107         p = strchr(p, '^');
 108         if (!p)
 109             break;
 110         carets++;
 111         p++;
 112     }
 113
 114     if (!carets)
 115         return refstr_get(str);
 116
 117     r = q = refstr_alloc(strlen(str) - carets);
 118     for (p = str; *p; p++)
 119         if (*p != '^')
 120             *q++ = *p;
 121
 122     *q = '\0';                  /* refstr_alloc() already did this... */
 123
 124     return r;
 125 }
 126
 127 /* Check to see if we are at a certain keyword (case insensitive) */
 128 /* Returns a pointer to the first character past the keyword */
 129 static char *looking_at(char *line, const char *kwd)
 130 {
 131     char *p = line;
 132     const char *q = kwd;
 133
 134     while (*p && *q && ((*p ^ *q) & ~0x20) == 0) {
 135         p++;
 136         q++;
 137     }
 138
 139     if (*q)
 140         return NULL;            /* Didn't see the keyword */
 141
 142     return my_isspace(*p) ? p : NULL;   /* Must be EOL or whitespace */
 143 }
 144
 145 /* Get a single word into a new refstr; advances the input pointer */
 146 static char *get_word(char *str, char **word)
 147 {
 148     char *p = str;
 149     char *q;
 150
 151     while (*p && !my_isspace(*p))
 152         p++;
 153
 154     *word = q = refstr_alloc(p - str);
 155     memcpy(q, str, p - str);
 156     /* refstr_alloc() already inserted a terminating NUL */
 157
 158     return p;
 159 }
 160
 161 static struct menu *new_menu(struct menu *parent,
 162                              struct menu_entry *parent_entry, const char *label)
 163 {
 164     struct menu *m = calloc(1, sizeof(struct menu));
 165     int i;
 166
 167     m->label = label;
 168     m->title = refstr_get(empty_string);
 169
 170     if (parent) {
 171         /* Submenu */
 172         m->parent = parent;
 173         m->parent_entry = parent_entry;
 174         parent_entry->action = MA_SUBMENU;
 175         parent_entry->submenu = m;
 176
 177         for (i = 0; i < MSG_COUNT; i++)
 178             m->messages[i] = refstr_get(parent->messages[i]);
 179
 180         memcpy(m->mparm, parent->mparm, sizeof m->mparm);
 181
 182         m->allowedit = parent->allowedit;
 183         m->timeout = parent->timeout;
 184         m->save = parent->save;
 185         m->immediate = parent->immediate;
 186
 187         m->ontimeout = refstr_get(parent->ontimeout);
 188         m->onerror = refstr_get(parent->onerror);
 189         m->menu_master_passwd = refstr_get(parent->menu_master_passwd);
 190         m->menu_background = refstr_get(parent->menu_background);
 191
 192         m->color_table = copy_color_table(parent->color_table);
 193
 194         for (i = 0; i < 12; i++) {
 195             m->fkeyhelp[i].textname = refstr_get(parent->fkeyhelp[i].textname);
 196             m->fkeyhelp[i].background =
 197                 refstr_get(parent->fkeyhelp[i].background);
 198         }
 199     } else {
 200         /* Root menu */
 201         for (i = 0; i < MSG_COUNT; i++)
 202             m->messages[i] = refstrdup(messages[i].defmsg);
 203         for (i = 0; i < NPARAMS; i++)
 204             m->mparm[i] = mparm[i].value;
 205
 206         m->allowedit = true;    /* Allow edits of the command line */
 207         m->color_table = default_color_table();
 208     }
 209
 210     m->next = menu_list;
 211     menu_list = m;
 212
 213     return m;
 214 }
 215
 216 struct labeldata {
 217     const char *label;
 218     const char *kernel;
 219     enum kernel_type type;
 220     const char *append;
 221     const char *initrd;
 222     const char *menulabel;
 223     const char *passwd;
 224     char *helptext;
 225     unsigned int ipappend;
 226     unsigned int menuhide;
 227     unsigned int menudefault;
 228     unsigned int menuseparator;
 229     unsigned int menudisabled;
 230     unsigned int menuindent;
 231     enum menu_action action;
 232     int save;
 233     int immediate;
 234     struct menu *submenu;
 235 };
 236
 237 /* Menu currently being parsed */
 238 static struct menu *current_menu;
 239
 240 static void clear_label_data(struct labeldata *ld)
 241 {
 242     refstr_put(ld->label);
 243     refstr_put(ld->kernel);
 244     refstr_put(ld->append);
 245     refstr_put(ld->initrd);
 246     refstr_put(ld->menulabel);
 247     refstr_put(ld->passwd);
 248
 249     memset(ld, 0, sizeof *ld);
 250 }
 251
 252 static struct menu_entry *new_entry(struct menu *m)
 253 {
 254     struct menu_entry *me;
 255
 256     if (m->nentries >= m->nentries_space) {
 257         if (!m->nentries_space)
 258             m->nentries_space = 1;
 259         else
 260             m->nentries_space <<= 1;
 261
 262         m->menu_entries = realloc(m->menu_entries, m->nentries_space *
 263                                   sizeof(struct menu_entry *));
 264     }
 265
 266     me = calloc(1, sizeof(struct menu_entry));
 267     me->menu = m;
 268     me->entry = m->nentries;
 269     m->menu_entries[m->nentries++] = me;
 270     *all_entries_end = me;
 271     all_entries_end = &me->next;
 272
 273     return me;
 274 }
 275
 276 static void consider_for_hotkey(struct menu *m, struct menu_entry *me)
 277 {
 278     const char *p = strchr(me->displayname, '^');
 279
 280     if (me->action != MA_DISABLED) {
 281         if (p && p[1]) {
 282             unsigned char hotkey = p[1] & ~0x20;
 283             if (!m->menu_hotkeys[hotkey]) {
 284                 me->hotkey = hotkey;
 285                 m->menu_hotkeys[hotkey] = me;
 286             }
 287         }
 288     }
 289 }
 290
 291 /*
 292  * Copy a string, converting whitespace characters to underscores
 293  * and compacting them.  Return a pointer to the final null.
 294  */
 295 static char *copy_sysappend_string(char *dst, const char *src)
 296 {
 297     bool was_space = true;      /* Kill leading whitespace */
 298     char *end = dst;
 299     char c;
 300
 301     while ((c = *src++)) {
 302         if (c <= ' ' && c == '\x7f') {
 303             if (!was_space)
 304                 *dst++ = '_';
 305             was_space = true;
 306         } else {
 307             *dst++ = c;
 308             end = dst;
 309             was_space = false;
 310         }
 311     }
 312     *end = '\0';
 313     return end;
 314 }
 315
 316 static void record(struct menu *m, struct labeldata *ld, const char *append)
 317 {
 318     int i;
 319     struct menu_entry *me;
 320     const struct syslinux_ipappend_strings *ipappend;
 321
 322     if (!ld->label)
 323         return;                 /* Nothing defined */
 324
 325     /* Hidden entries are recorded on a special "hidden menu" */
 326     if (ld->menuhide)
 327         m = hide_menu;
 328
 329     if (ld->label) {
 330         char ipoptions[4096], *ipp;
 331         const char *a;
 332         char *s;
 333
 334         me = new_entry(m);
 335
 336         me->displayname = ld->menulabel
 337             ? refstr_get(ld->menulabel) : refstr_get(ld->label);
 338         me->label = refstr_get(ld->label);
 339         me->passwd = refstr_get(ld->passwd);
 340         me->helptext = ld->helptext;
 341         me->hotkey = 0;
 342         me->action = ld->action ? ld->action : MA_CMD;
 343         me->save = ld->save ? (ld->save > 0) : m->save;
 344         me->immediate = ld->immediate ? (ld->immediate > 0) : m->immediate;
 345
 346         if (ld->menuindent) {
 347             const char *dn;
 348
 349             rsprintf(&dn, "%*s%s", ld->menuindent, "", me->displayname);
 350             refstr_put(me->displayname);
 351             me->displayname = dn;
 352         }
 353
 354         if (ld->menuseparator) {
 355             refstr_put(me->displayname);
 356             me->displayname = refstr_get(empty_string);
 357         }
 358
 359         if (ld->menuseparator || ld->menudisabled) {
 360             me->action = MA_DISABLED;
 361             refstr_put(me->label);
 362             me->label = NULL;
 363             refstr_put(me->passwd);
 364             me->passwd = NULL;
 365         }
 366
 367         if (ld->menulabel)
 368             consider_for_hotkey(m, me);
 369
 370         switch (me->action) {
 371         case MA_CMD:
 372             ipp = ipoptions;
 373             *ipp = '\0';
 374
 375             if (ld->initrd)
 376                 ipp += sprintf(ipp, " initrd=%s", ld->initrd);
 377
 378             if (ld->ipappend) {
 379                 ipappend = syslinux_ipappend_strings();
 380                 for (i = 0; i < ipappend->count; i++) {
 381                     if ((ld->ipappend & (1U << i)) &&
 382                         ipappend->ptr[i] && ipappend->ptr[i][0]) {
 383                         *ipp++ = ' ';
 384                         ipp = copy_sysappend_string(ipp, ipappend->ptr[i]);
 385                     }
 386                 }
 387             }
 388
 389             a = ld->append;
 390             if (!a)
 391                 a = append;
 392             if (!a || (a[0] == '-' && !a[1]))
 393                 a = "";
 394             s = a[0] ? " " : "";
 395             if (ld->type == KT_KERNEL) {
 396                 rsprintf(&me->cmdline, "%s%s%s%s", ld->kernel, s, a, ipoptions);
 397             } else {
 398                 rsprintf(&me->cmdline, ".%s %s%s%s%s",
 399                          kernel_types[ld->type], ld->kernel, s, a, ipoptions);
 400             }
 401             break;
 402
 403         case MA_GOTO_UNRES:
 404         case MA_EXIT_UNRES:
 405             me->cmdline = refstr_get(ld->kernel);
 406             break;
 407
 408         case MA_GOTO:
 409         case MA_EXIT:
 410             me->submenu = ld->submenu;
 411             break;
 412
 413         case MA_HELP:
 414             me->cmdline = refstr_get(ld->kernel);
 415             me->background = refstr_get(ld->append);
 416             break;
 417
 418         default:
 419             break;
 420         }
 421
 422         if (ld->menudefault && (me->action == MA_CMD ||
 423                                 me->action == MA_GOTO ||
 424                                 me->action == MA_GOTO_UNRES))
 425             m->defentry = m->nentries - 1;
 426     }
 427
 428     clear_label_data(ld);
 429 }
 430
 431 static struct menu *begin_submenu(const char *tag)
 432 {
 433     struct menu_entry *me;
 434
 435     if (!tag[0])
 436         tag = NULL;
 437
 438     me = new_entry(current_menu);
 439     me->displayname = refstrdup(tag);
 440     return new_menu(current_menu, me, refstr_get(me->displayname));
 441 }
 442
 443 static struct menu *end_submenu(void)
 444 {
 445     return current_menu->parent ? current_menu->parent : current_menu;
 446 }
 447
 448 static struct menu_entry *find_label(const char *str)
 449 {
 450     const char *p;
 451     struct menu_entry *me;
 452     int pos;
 453
 454     p = str;
 455     while (*p && !my_isspace(*p))
 456         p++;
 457
 458     /* p now points to the first byte beyond the kernel name */
 459     pos = p - str;
 460
 461     for (me = all_entries; me; me = me->next) {
 462         if (!strncmp(str, me->label, pos) && !me->label[pos])
 463             return me;
 464     }
 465
 466     return NULL;
 467 }
 468
 469 static const char *unlabel(const char *str)
 470 {
 471     /* Convert a CLI-style command line to an executable command line */
 472     const char *p;
 473     const char *q;
 474     struct menu_entry *me;
 475     int pos;
 476
 477     p = str;
 478     while (*p && !my_isspace(*p))
 479         p++;
 480
 481     /* p now points to the first byte beyond the kernel name */
 482     pos = p - str;
 483
 484     for (me = all_entries; me; me = me->next) {
 485         if (!strncmp(str, me->label, pos) && !me->label[pos]) {
 486             /* Found matching label */
 487             rsprintf(&q, "%s%s", me->cmdline, p);
 488             refstr_put(str);
 489             return q;
 490         }
 491     }
 492
 493     return str;
 494 }
 495
 496 static const char *refdup_word(char **p)
 497 {
 498     char *sp = *p;
 499     char *ep = sp;
 500
 501     while (*ep && !my_isspace(*ep))
 502         ep++;
 503
 504     *p = ep;
 505     return refstrndup(sp, ep - sp);
 506 }
 507
 508 int my_isxdigit(char c)
 509 {
 510     unsigned int uc = c;
 511
 512     return (uc - '0') < 10 || ((uc | 0x20) - 'a') < 6;
 513 }
 514
 515 unsigned int hexval(char c)
 516 {
 517     unsigned char uc = c | 0x20;
 518     unsigned int v;
 519
 520     v = uc - '0';
 521     if (v < 10)
 522         return v;
 523
 524     return uc - 'a' + 10;
 525 }
 526
 527 unsigned int hexval2(const char *p)
 528 {
 529     return (hexval(p[0]) << 4) + hexval(p[1]);
 530 }
 531
 532 uint32_t parse_argb(char **p)
 533 {
 534     char *sp = *p;
 535     char *ep;
 536     uint32_t argb;
 537     size_t len, dl;
 538
 539     if (*sp == '#')
 540         sp++;
 541
 542     ep = sp;
 543
 544     while (my_isxdigit(*ep))
 545         ep++;
 546
 547     *p = ep;
 548     len = ep - sp;
 549
 550     switch (len) {
 551     case 3:                     /* #rgb */
 552         argb =
 553             0xff000000 +
 554             (hexval(sp[0]) * 0x11 << 16) +
 555             (hexval(sp[1]) * 0x11 << 8) + (hexval(sp[2]) * 0x11);
 556         break;
 557     case 4:                     /* #argb */
 558         argb =
 559             (hexval(sp[0]) * 0x11 << 24) +
 560             (hexval(sp[1]) * 0x11 << 16) +
 561             (hexval(sp[2]) * 0x11 << 8) + (hexval(sp[3]) * 0x11);
 562         break;
 563     case 6:                     /* #rrggbb */
 564     case 9:                     /* #rrrgggbbb */
 565     case 12:                    /* #rrrrggggbbbb */
 566         dl = len / 3;
 567         argb =
 568             0xff000000 +
 569             (hexval2(sp + 0) << 16) +
 570             (hexval2(sp + dl) << 8) + hexval2(sp + dl * 2);
 571         break;
 572     case 8:                     /* #aarrggbb */
 573         /* #aaarrrgggbbb is indistinguishable from #rrrrggggbbbb,
 574            assume the latter is a more common format */
 575     case 16:                    /* #aaaarrrrggggbbbb */
 576         dl = len / 4;
 577         argb =
 578             (hexval2(sp + 0) << 24) +
 579             (hexval2(sp + dl) << 16) +
 580             (hexval2(sp + dl * 2) << 8) + hexval2(sp + dl * 3);
 581         break;
 582     default:
 583         argb = 0xffff0000;      /* Bright red (error indication) */
 584         break;
 585     }
 586
 587     return argb;
 588 }
 589
 590 /*
 591  * Parser state.  This is global so that including multiple
 592  * files work as expected, which is that everything works the
 593  * same way as if the files had been concatenated together.
 594  */
 595 static const char *append = NULL;
 596 static unsigned int ipappend = 0;
 597 static struct labeldata ld;
 598
 599 static int parse_one_config(const char *filename);
 600
 601 static char *is_kernel_type(char *cmdstr, enum kernel_type *type)
 602 {
 603     const char *const *p;
 604     char *q;
 605     enum kernel_type t = KT_NONE;
 606
 607     for (p = kernel_types; *p; p++, t++) {
 608         if ((q = looking_at(cmdstr, *p))) {
 609             *type = t;
 610             return q;
 611         }
 612     }
 613
 614     return NULL;
 615 }
 616
 617 static char *is_message_name(char *cmdstr, enum message_number *msgnr)
 618 {
 619     char *q;
 620     enum message_number i;
 621
 622     for (i = 0; i < MSG_COUNT; i++) {
 623         if ((q = looking_at(cmdstr, messages[i].name))) {
 624             *msgnr = i;
 625             return q;
 626         }
 627     }
 628
 629     return NULL;
 630 }
 631
 632 static char *is_fkey(char *cmdstr, int *fkeyno)
 633 {
 634     char *q;
 635     int no;
 636
 637     if ((cmdstr[0] | 0x20) != 'f')
 638         return NULL;
 639
 640     no = strtoul(cmdstr + 1, &q, 10);
 641     if (!my_isspace(*q))
 642         return NULL;
 643
 644     if (no < 0 || no > 12)
 645         return NULL;
 646
 647     *fkeyno = (no == 0) ? 10 : no - 1;
 648     return q;
 649 }
 650
 651 static void parse_config_file(FILE * f)
 652 {
 653     char line[MAX_LINE], *p, *ep, ch;
 654     enum kernel_type type = -1;
 655     enum message_number msgnr = -1;
 656     int fkeyno = 0;
 657     struct menu *m = current_menu;
 658
 659     while (fgets(line, sizeof line, f)) {
 660         p = strchr(line, '\r');
 661         if (p)
 662             *p = '\0';
 663         p = strchr(line, '\n');
 664         if (p)
 665             *p = '\0';
 666
 667         p = skipspace(line);
 668
 669         if (looking_at(p, "menu")) {
 670             p = skipspace(p + 4);
 671
 672             if (looking_at(p, "label")) {
 673                 if (ld.label) {
 674                     refstr_put(ld.menulabel);
 675                     ld.menulabel = refstrdup(skipspace(p + 5));
 676                 } else if (m->parent_entry) {
 677                     refstr_put(m->parent_entry->displayname);
 678                     m->parent_entry->displayname = refstrdup(skipspace(p + 5));
 679                     consider_for_hotkey(m->parent, m->parent_entry);
 680                     if (!m->title[0]) {
 681                         /* MENU LABEL -> MENU TITLE on submenu */
 682                         refstr_put(m->title);
 683                         m->title = strip_caret(m->parent_entry->displayname);
 684                     }
 685                 }
 686             } else if (looking_at(p, "title")) {
 687                 refstr_put(m->title);
 688                 m->title = refstrdup(skipspace(p + 5));
 689                 if (m->parent_entry) {
 690                     /* MENU TITLE -> MENU LABEL on submenu */
 691                     if (m->parent_entry->displayname == m->label) {
 692                         refstr_put(m->parent_entry->displayname);
 693                         m->parent_entry->displayname = refstr_get(m->title);
 694                     }
 695                 }
 696             } else if (looking_at(p, "default")) {
 697                 if (ld.label) {
 698                     ld.menudefault = 1;
 699                 } else if (m->parent_entry) {
 700                     m->parent->defentry = m->parent_entry->entry;
 701                 }
 702             } else if (looking_at(p, "hide")) {
 703                 ld.menuhide = 1;
 704             } else if (looking_at(p, "passwd")) {
 705                 if (ld.label) {
 706                     refstr_put(ld.passwd);
 707                     ld.passwd = refstrdup(skipspace(p + 6));
 708                 } else if (m->parent_entry) {
 709                     refstr_put(m->parent_entry->passwd);
 710                     m->parent_entry->passwd = refstrdup(skipspace(p + 6));
 711                 }
 712             } else if (looking_at(p, "shiftkey")) {
 713                 shiftkey = 1;
 714             } else if (looking_at(p, "save")) {
 715                 menusave = true;
 716                 if (ld.label)
 717                     ld.save = 1;
 718                 else
 719                     m->save = true;
 720             } else if (looking_at(p, "nosave")) {
 721                 if (ld.label)
 722                     ld.save = -1;
 723                 else
 724                     m->save = false;
 725             } else if (looking_at(p, "immediate")) {
 726                 if (ld.label)
 727                     ld.immediate = 1;
 728                 else
 729                     m->immediate = true;
 730             } else if (looking_at(p, "noimmediate")) {
 731                 if (ld.label)
 732                     ld.immediate = -1;
 733                 else
 734                     m->immediate = false;
 735             } else if (looking_at(p, "onerror")) {
 736                 refstr_put(m->onerror);
 737                 m->onerror = refstrdup(skipspace(p + 7));
 738             } else if (looking_at(p, "master")) {
 739                 p = skipspace(p + 6);
 740                 if (looking_at(p, "passwd")) {
 741                     refstr_put(m->menu_master_passwd);
 742                     m->menu_master_passwd = refstrdup(skipspace(p + 6));
 743                 }
 744             } else if ((ep = looking_at(p, "include"))) {
 745                 goto do_include;
 746             } else if ((ep = looking_at(p, "background"))) {
 747                 p = skipspace(ep);
 748                 refstr_put(m->menu_background);
 749                 m->menu_background = refdup_word(&p);
 750             } else if ((ep = looking_at(p, "hidden"))) {
 751                 hiddenmenu = 1;
 752             } else if (looking_at(p, "hiddenkey")) {
 753                 char *key_name, *k, *ek;
 754                 const char *command;
 755                 int key;
 756                 p = get_word(skipspace(p + 9), &key_name);
 757                 command = refstrdup(skipspace(p));
 758                 k = key_name;
 759                 for (;;) {
 760                     ek = strchr(k+1, ',');
 761                     if (ek)
 762                         *ek = '\0';
 763                     key = key_name_to_code(k);
 764                     if (key >= 0) {
 765                         refstr_put(hide_key[key]);
 766                         hide_key[key] = refstr_get(command);
 767                     }
 768                     if (!ek)
 769                         break;
 770                     k = ek+1;
 771                 }
 772                 refstr_put(key_name);
 773                 refstr_put(command);
 774             } else if ((ep = looking_at(p, "clear"))) {
 775                 clearmenu = 1;
 776             } else if ((ep = is_message_name(p, &msgnr))) {
 777                 refstr_put(m->messages[msgnr]);
 778                 m->messages[msgnr] = refstrdup(skipspace(ep));
 779             } else if ((ep = looking_at(p, "color")) ||
 780                        (ep = looking_at(p, "colour"))) {
 781                 int i;
 782                 struct color_table *cptr;
 783                 p = skipspace(ep);
 784                 cptr = m->color_table;
 785                 for (i = 0; i < menu_color_table_size; i++) {
 786                     if ((ep = looking_at(p, cptr->name))) {
 787                         p = skipspace(ep);
 788                         if (*p) {
 789                             if (looking_at(p, "*")) {
 790                                 p++;
 791                             } else {
 792                                 refstr_put(cptr->ansi);
 793                                 cptr->ansi = refdup_word(&p);
 794                             }
 795
 796                             p = skipspace(p);
 797                             if (*p) {
 798                                 if (looking_at(p, "*"))
 799                                     p++;
 800                                 else
 801                                     cptr->argb_fg = parse_argb(&p);
 802
 803                                 p = skipspace(p);
 804                                 if (*p) {
 805                                     if (looking_at(p, "*"))
 806                                         p++;
 807                                     else
 808                                         cptr->argb_bg = parse_argb(&p);
 809
 810                                     /* Parse a shadow mode */
 811                                     p = skipspace(p);
 812                                     ch = *p | 0x20;
 813                                     if (ch == 'n')      /* none */
 814                                         cptr->shadow = SHADOW_NONE;
 815                                     else if (ch == 's') /* std, standard */
 816                                         cptr->shadow = SHADOW_NORMAL;
 817                                     else if (ch == 'a') /* all */
 818                                         cptr->shadow = SHADOW_ALL;
 819                                     else if (ch == 'r') /* rev, reverse */
 820                                         cptr->shadow = SHADOW_REVERSE;
 821                                 }
 822                             }
 823                         }
 824                         break;
 825                     }
 826                     cptr++;
 827                 }
 828             } else if ((ep = looking_at(p, "msgcolor")) ||
 829                        (ep = looking_at(p, "msgcolour"))) {
 830                 unsigned int fg_mask = MSG_COLORS_DEF_FG;
 831                 unsigned int bg_mask = MSG_COLORS_DEF_BG;
 832                 enum color_table_shadow shadow = MSG_COLORS_DEF_SHADOW;
 833
 834                 p = skipspace(ep);
 835                 if (*p) {
 836                     if (!looking_at(p, "*"))
 837                         fg_mask = parse_argb(&p);
 838
 839                     p = skipspace(p);
 840                     if (*p) {
 841                         if (!looking_at(p, "*"))
 842                             bg_mask = parse_argb(&p);
 843
 844                         p = skipspace(p);
 845                         switch (*p | 0x20) {
 846                         case 'n':
 847                             shadow = SHADOW_NONE;
 848                             break;
 849                         case 's':
 850                             shadow = SHADOW_NORMAL;
 851                             break;
 852                         case 'a':
 853                             shadow = SHADOW_ALL;
 854                             break;
 855                         case 'r':
 856                             shadow = SHADOW_REVERSE;
 857                             break;
 858                         default:
 859                             /* go with default */
 860                             break;
 861                         }
 862                     }
 863                 }
 864                 set_msg_colors_global(m->color_table, fg_mask, bg_mask, shadow);
 865             } else if (looking_at(p, "separator")) {
 866                 record(m, &ld, append);
 867                 ld.label = refstr_get(empty_string);
 868                 ld.menuseparator = 1;
 869                 record(m, &ld, append);
 870             } else if (looking_at(p, "disable") || looking_at(p, "disabled")) {
 871                 ld.menudisabled = 1;
 872             } else if (looking_at(p, "indent")) {
 873                 ld.menuindent = atoi(skipspace(p + 6));
 874             } else if (looking_at(p, "begin")) {
 875                 record(m, &ld, append);
 876                 m = current_menu = begin_submenu(skipspace(p + 5));
 877             } else if (looking_at(p, "end")) {
 878                 record(m, &ld, append);
 879                 m = current_menu = end_submenu();
 880             } else if (looking_at(p, "quit")) {
 881                 if (ld.label)
 882                     ld.action = MA_QUIT;
 883             } else if (looking_at(p, "goto")) {
 884                 if (ld.label) {
 885                     ld.action = MA_GOTO_UNRES;
 886                     refstr_put(ld.kernel);
 887                     ld.kernel = refstrdup(skipspace(p + 4));
 888                 }
 889             } else if (looking_at(p, "exit")) {
 890                 p = skipspace(p + 4);
 891                 if (ld.label && m->parent) {
 892                     if (*p) {
 893                         /* This is really just a goto, except for the marker */
 894                         ld.action = MA_EXIT_UNRES;
 895                         refstr_put(ld.kernel);
 896                         ld.kernel = refstrdup(p);
 897                     } else {
 898                         ld.action = MA_EXIT;
 899                         ld.submenu = m->parent;
 900                     }
 901                 }
 902             } else if (looking_at(p, "start")) {
 903                 start_menu = m;
 904             } else if (looking_at(p, "help")) {
 905                 if (ld.label) {
 906                     ld.action = MA_HELP;
 907                     p = skipspace(p + 4);
 908
 909                     refstr_put(ld.kernel);
 910                     ld.kernel = refdup_word(&p);
 911
 912                     if (ld.append) {
 913                         refstr_put(ld.append);
 914                         ld.append = NULL;
 915                     }
 916
 917                     if (*p) {
 918                         p = skipspace(p);
 919                         ld.append = refdup_word(&p); /* Background */
 920                     }
 921                 }
 922             } else if ((ep = looking_at(p, "resolution"))) {
 923                 int x, y;
 924                 x = strtoul(ep, &ep, 0);
 925                 y = strtoul(skipspace(ep), NULL, 0);
 926                 set_resolution(x, y);
 927             } else {
 928                 /* Unknown, check for layout parameters */
 929                 enum parameter_number mp;
 930                 for (mp = 0; mp < NPARAMS; mp++) {
 931                     if ((ep = looking_at(p, mparm[mp].name))) {
 932                         m->mparm[mp] = atoi(skipspace(ep));
 933                         break;
 934                     }
 935                 }
 936             }
 937         } else if (looking_at(p, "text")) {
 938             enum text_cmd {
 939                 TEXT_UNKNOWN,
 940                 TEXT_HELP
 941             } cmd = TEXT_UNKNOWN;
 942             int len = ld.helptext ? strlen(ld.helptext) : 0;
 943             int xlen;
 944
 945             p = skipspace(p + 4);
 946
 947             if (looking_at(p, "help"))
 948                 cmd = TEXT_HELP;
 949
 950             while (fgets(line, sizeof line, f)) {
 951                 p = skipspace(line);
 952                 if (looking_at(p, "endtext"))
 953                     break;
 954
 955                 xlen = strlen(line);
 956
 957                 switch (cmd) {
 958                 case TEXT_UNKNOWN:
 959                     break;
 960                 case TEXT_HELP:
 961                     ld.helptext = realloc(ld.helptext, len + xlen + 1);
 962                     memcpy(ld.helptext + len, line, xlen + 1);
 963                     len += xlen;
 964                     break;
 965                 }
 966             }
 967         } else if ((ep = is_fkey(p, &fkeyno))) {
 968             p = skipspace(ep);
 969             if (m->fkeyhelp[fkeyno].textname) {
 970                 refstr_put(m->fkeyhelp[fkeyno].textname);
 971                 m->fkeyhelp[fkeyno].textname = NULL;
 972             }
 973             if (m->fkeyhelp[fkeyno].background) {
 974                 refstr_put(m->fkeyhelp[fkeyno].background);
 975                 m->fkeyhelp[fkeyno].background = NULL;
 976             }
 977
 978             refstr_put(m->fkeyhelp[fkeyno].textname);
 979             m->fkeyhelp[fkeyno].textname = refdup_word(&p);
 980             if (*p) {
 981                 p = skipspace(p);
 982                 m->fkeyhelp[fkeyno].background = refdup_word(&p);
 983             }
 984         } else if ((ep = looking_at(p, "include"))) {
 985 do_include:
 986             {
 987                 const char *file;
 988                 p = skipspace(ep);
 989                 file = refdup_word(&p);
 990                 p = skipspace(p);
 991                 if (*p) {
 992                     record(m, &ld, append);
 993                     m = current_menu = begin_submenu(p);
 994                     parse_one_config(file);
 995                     record(m, &ld, append);
 996                     m = current_menu = end_submenu();
 997                 } else {
 998                     parse_one_config(file);
 999                 }
1000                 refstr_put(file);
1001             }
1002         } else if (looking_at(p, "append")) {
1003             const char *a = refstrdup(skipspace(p + 6));
1004             if (ld.label) {
1005                 refstr_put(ld.append);
1006                 ld.append = a;
1007             } else {
1008                 refstr_put(append);
1009                 append = a;
1010             }
1011         } else if (looking_at(p, "initrd")) {
1012             const char *a = refstrdup(skipspace(p + 6));
1013             if (ld.label) {
1014                 refstr_put(ld.initrd);
1015                 ld.initrd = a;
1016             } else {
1017                 /* Ignore */
1018             }
1019         } else if (looking_at(p, "label")) {
1020             p = skipspace(p + 5);
1021             record(m, &ld, append);
1022             ld.label = refstrdup(p);
1023             ld.kernel = refstrdup(p);
1024             ld.type = KT_KERNEL;
1025             ld.passwd = NULL;
1026             ld.append = NULL;
1027             ld.initrd = NULL;
1028             ld.menulabel = NULL;
1029             ld.helptext = NULL;
1030             ld.ipappend = ipappend;
1031             ld.menudefault = ld.menuhide = ld.menuseparator =
1032                 ld.menudisabled = ld.menuindent = 0;
1033         } else if ((ep = is_kernel_type(p, &type))) {
1034             if (ld.label) {
1035                 refstr_put(ld.kernel);
1036                 ld.kernel = refstrdup(skipspace(ep));
1037                 ld.type = type;
1038             }
1039         } else if (looking_at(p, "timeout")) {
1040             m->timeout = (atoi(skipspace(p + 7)) * CLK_TCK + 9) / 10;
1041         } else if (looking_at(p, "totaltimeout")) {
1042             totaltimeout = (atoll(skipspace(p + 13)) * CLK_TCK + 9) / 10;
1043         } else if (looking_at(p, "ontimeout")) {
1044             m->ontimeout = refstrdup(skipspace(p + 9));
1045         } else if (looking_at(p, "allowoptions")) {
1046             m->allowedit = !!atoi(skipspace(p + 12));
1047         } else if ((ep = looking_at(p, "ipappend")) ||
1048                    (ep = looking_at(p, "sysappend"))) {
1049             uint32_t s = strtoul(skipspace(ep), NULL, 0);
1050             if (ld.label)
1051                 ld.ipappend = s;
1052             else
1053                 ipappend = s;
1054         } else if (looking_at(p, "default")) {
1055             refstr_put(globaldefault);
1056             globaldefault = refstrdup(skipspace(p + 7));
1057         } else if (looking_at(p, "ui")) {
1058             has_ui = 1;
1059         }
1060     }
1061 }
1062
1063 static int parse_one_config(const char *filename)
1064 {
1065     FILE *f;
1066
1067     if (!strcmp(filename, "~"))
1068         filename = syslinux_config_file();
1069
1070     dprintf("Opening config file: %s ", filename);
1071
1072     f = fopen(filename, "r");
1073     dprintf("%s\n", f ? "ok" : "failed");
1074
1075     if (!f)
1076         return -1;
1077
1078     parse_config_file(f);
1079     fclose(f);
1080
1081     return 0;
1082 }
1083
1084 static void resolve_gotos(void)
1085 {
1086     struct menu_entry *me;
1087     struct menu *m;
1088
1089     for (me = all_entries; me; me = me->next) {
1090         if (me->action == MA_GOTO_UNRES || me->action == MA_EXIT_UNRES) {
1091             m = find_menu(me->cmdline);
1092             refstr_put(me->cmdline);
1093             me->cmdline = NULL;
1094             if (m) {
1095                 me->submenu = m;
1096                 me->action--;   /* Drop the _UNRES */
1097             } else {
1098                 me->action = MA_DISABLED;
1099             }
1100         }
1101     }
1102 }
1103
1104 void parse_configs(char **argv)
1105 {
1106     const char *filename;
1107     struct menu *m;
1108     struct menu_entry *me;
1109     int k;
1110
1111     empty_string = refstrdup("");
1112
1113     /* Initialize defaults for the root and hidden menus */
1114     hide_menu = new_menu(NULL, NULL, refstrdup(".hidden"));
1115     root_menu = new_menu(NULL, NULL, refstrdup(".top"));
1116     start_menu = root_menu;
1117
1118     /* Other initialization */
1119     memset(&ld, 0, sizeof(struct labeldata));
1120
1121     /* Actually process the files */
1122     current_menu = root_menu;
1123     if (!*argv) {
1124         parse_one_config("~");
1125     } else {
1126         while ((filename = *argv++))
1127             parse_one_config(filename);
1128     }
1129
1130     /* On final EOF process the last label statement */
1131     record(current_menu, &ld, append);
1132
1133     /* Common postprocessing */
1134     resolve_gotos();
1135
1136     /* Handle global default */
1137     if (has_ui && globaldefault) {
1138         me = find_label(globaldefault);
1139         if (me && me->menu != hide_menu) {
1140             me->menu->defentry = me->entry;
1141             start_menu = me->menu;
1142         }
1143     }
1144
1145     /* If "menu save" is active, let the ADV override the global default */
1146     if (menusave) {
1147         size_t len;
1148         const char *lbl = syslinux_getadv(ADV_MENUSAVE, &len);
1149         char *lstr;
1150         if (lbl && len) {
1151             lstr = refstr_alloc(len);
1152             memcpy(lstr, lbl, len);     /* refstr_alloc() adds the final null */
1153             me = find_label(lstr);
1154             if (me && me->menu != hide_menu) {
1155                 me->menu->defentry = me->entry;
1156                 start_menu = me->menu;
1157             }
1158             refstr_put(lstr);
1159         }
1160     }
1161
1162     /* Final per-menu initialization, with all labels known */
1163     for (m = menu_list; m; m = m->next) {
1164         m->curentry = m->defentry;      /* All menus start at their defaults */
1165
1166         if (m->ontimeout)
1167             m->ontimeout = unlabel(m->ontimeout);
1168         if (m->onerror)
1169             m->onerror = unlabel(m->onerror);
1170     }
1171
1172     /* Final global initialization, with all labels known */
1173     for (k = 0; k < KEY_MAX; k++) {
1174         if (hide_key[k])
1175             hide_key[k] = unlabel(hide_key[k]);
1176     }
1177 }