com32/elflink/ldlinux/readconfig.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2004-2009 H. Peter Anvin - All Rights Reserved
   4  *   Copyright 2009-2013 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 <sys/io.h>
  15 #include <fcntl.h>
  16 #include <stdio.h>
  17 #include <stdbool.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <minmax.h>
  21 #include <alloca.h>
  22 #include <inttypes.h>
  23 #include <colortbl.h>
  24 #include <com32.h>
  25 #include <syslinux/adv.h>
  26 #include <syslinux/config.h>
  27 #include <dprintf.h>
  28 #include <ctype.h>
  29 #include <bios.h>
  30 #include <core.h>
  31 #include <fs.h>
  32 #include <syslinux/pxe_api.h>
  33
  34 #include "menu.h"
  35 #include "config.h"
  36 #include "getkey.h"
  37 #include "core.h"
  38 #include "fs.h"
  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 /* Must match enum kernel_type */
  58 static const char *const kernel_types[] = {
  59     "none",
  60     "localboot",
  61     "kernel",
  62     "linux",
  63     "boot",
  64     "bss",
  65     "pxe",
  66     "fdimage",
  67     "comboot",
  68     "com32",
  69     "config",
  70     NULL
  71 };
  72
  73 short uappendlen = 0;           //bytes in append= command
  74 short ontimeoutlen = 0;         //bytes in ontimeout command
  75 short onerrorlen = 0;           //bytes in onerror command
  76 short forceprompt = 0;          //force prompt
  77 short noescape = 0;             //no escape
  78 short nocomplete = 0;           //no label completion on TAB key
  79 short allowimplicit = 1;        //allow implicit kernels
  80 short allowoptions = 1;         //user-specified options allowed
  81 short includelevel = 1;         //nesting level
  82 short defaultlevel = 0;         //the current level of default
  83 short vkernel = 0;              //have we seen any "label" statements?
  84 extern short NoHalt;            //idle.c
  85
  86 const char *onerror = NULL;     //"onerror" command line
  87 const char *ontimeout = NULL;   //"ontimeout" command line
  88
  89 __export const char *default_cmd = NULL;        //"default" command line
  90
  91 /* Empty refstring */
  92 const char *empty_string;
  93
  94 /* Root menu, starting menu, hidden menu, and list of all menus */
  95 struct menu *root_menu, *start_menu, *hide_menu, *menu_list, *default_menu;
  96
  97 /* These are global parameters regardless of which menu we're displaying */
  98 int shiftkey = 0;               /* Only display menu if shift key pressed */
  99 int hiddenmenu = 0;
 100 long long totaltimeout = 0;
 101 unsigned int kbdtimeout = 0;
 102
 103 /* Keep track of global default */
 104 static int has_ui = 0;          /* DEFAULT only counts if UI is found */
 105 extern const char *globaldefault;
 106 static bool menusave = false;   /* True if there is any "menu save" */
 107
 108 /* Linked list of all entires, hidden or not; used by unlabel() */
 109 static struct menu_entry *all_entries;
 110 static struct menu_entry **all_entries_end = &all_entries;
 111
 112 static const struct messages messages[MSG_COUNT] = {
 113     [MSG_AUTOBOOT] = {"autoboot", "Automatic boot in # second{,s}..."},
 114     [MSG_TAB] = {"tabmsg", "Press [Tab] to edit options"},
 115     [MSG_NOTAB] = {"notabmsg", ""},
 116     [MSG_PASSPROMPT] = {"passprompt", "Password required"},
 117 };
 118
 119 #define astrdup(x) ({ char *__x = (x); \
 120                       size_t __n = strlen(__x) + 1; \
 121                       char *__p = alloca(__n); \
 122                       if ( __p ) memcpy(__p, __x, __n); \
 123                       __p; })
 124
 125 /*
 126  * Search the list of all menus for a specific label
 127  */
 128 static struct menu *find_menu(const char *label)
 129 {
 130     struct menu *m;
 131
 132     for (m = menu_list; m; m = m->next) {
 133         if (!strcmp(label, m->label))
 134             return m;
 135     }
 136
 137     return NULL;
 138 }
 139
 140 #define MAX_LINE 4096
 141
 142 /* Strip ^ from a string, returning a new reference to the same refstring
 143    if none present */
 144 static const char *strip_caret(const char *str)
 145 {
 146     const char *p, *r;
 147     char *q;
 148     int carets = 0;
 149
 150     p = str;
 151     for (;;) {
 152         p = strchr(p, '^');
 153         if (!p)
 154             break;
 155         carets++;
 156         p++;
 157     }
 158
 159     if (!carets)
 160         return refstr_get(str);
 161
 162     r = q = refstr_alloc(strlen(str) - carets);
 163     for (p = str; *p; p++)
 164         if (*p != '^')
 165             *q++ = *p;
 166
 167     *q = '\0';                  /* refstr_alloc() already did this... */
 168
 169     return r;
 170 }
 171
 172 /* Check to see if we are at a certain keyword (case insensitive) */
 173 /* Returns a pointer to the first character past the keyword */
 174 static char *looking_at(char *line, const char *kwd)
 175 {
 176     char *p = line;
 177     const char *q = kwd;
 178
 179     while (*p && *q && ((*p ^ *q) & ~0x20) == 0) {
 180         p++;
 181         q++;
 182     }
 183
 184     if (*q)
 185         return NULL;            /* Didn't see the keyword */
 186
 187     return my_isspace(*p) ? p : NULL;   /* Must be EOL or whitespace */
 188 }
 189
 190 static struct menu *new_menu(struct menu *parent,
 191                              struct menu_entry *parent_entry, const char *label)
 192 {
 193     struct menu *m = calloc(1, sizeof(struct menu));
 194     int i;
 195
 196         //dprintf("enter: menu_label = %s", label);
 197
 198     m->label = label;
 199     m->title = refstr_get(empty_string);
 200
 201     if (parent) {
 202         /* Submenu */
 203         m->parent = parent;
 204         m->parent_entry = parent_entry;
 205         parent_entry->action = MA_SUBMENU;
 206         parent_entry->submenu = m;
 207
 208         for (i = 0; i < MSG_COUNT; i++)
 209             m->messages[i] = refstr_get(parent->messages[i]);
 210
 211         memcpy(m->mparm, parent->mparm, sizeof m->mparm);
 212
 213         m->allowedit = parent->allowedit;
 214         m->timeout = parent->timeout;
 215         m->save = parent->save;
 216
 217         m->ontimeout = refstr_get(parent->ontimeout);
 218         m->onerror = refstr_get(parent->onerror);
 219         m->menu_master_passwd = refstr_get(parent->menu_master_passwd);
 220         m->menu_background = refstr_get(parent->menu_background);
 221
 222         m->color_table = copy_color_table(parent->color_table);
 223
 224         for (i = 0; i < 12; i++) {
 225             m->fkeyhelp[i].textname = refstr_get(parent->fkeyhelp[i].textname);
 226             m->fkeyhelp[i].background =
 227                 refstr_get(parent->fkeyhelp[i].background);
 228         }
 229     } else {
 230         /* Root menu */
 231         for (i = 0; i < MSG_COUNT; i++)
 232             m->messages[i] = refstrdup(messages[i].defmsg);
 233         for (i = 0; i < NPARAMS; i++)
 234             m->mparm[i] = mparm[i].value;
 235
 236         m->allowedit = true;    /* Allow edits of the command line */
 237         m->color_table = default_color_table();
 238     }
 239
 240     m->next = menu_list;
 241     menu_list = m;
 242
 243     return m;
 244 }
 245
 246 struct labeldata {
 247     const char *label;
 248     const char *kernel;
 249     enum kernel_type type;
 250     const char *append;
 251     const char *initrd;
 252     const char *menulabel;
 253     const char *passwd;
 254     char *helptext;
 255     unsigned int ipappend;
 256     unsigned int menuhide;
 257     unsigned int menudefault;
 258     unsigned int menuseparator;
 259     unsigned int menudisabled;
 260     unsigned int menuindent;
 261     enum menu_action action;
 262     int save;
 263     struct menu *submenu;
 264 };
 265
 266 /* Menu currently being parsed */
 267 static struct menu *current_menu;
 268
 269 static void clear_label_data(struct labeldata *ld)
 270 {
 271     refstr_put(ld->label);
 272     refstr_put(ld->kernel);
 273     refstr_put(ld->append);
 274     refstr_put(ld->initrd);
 275     refstr_put(ld->menulabel);
 276     refstr_put(ld->passwd);
 277
 278     memset(ld, 0, sizeof *ld);
 279 }
 280
 281 static struct menu_entry *new_entry(struct menu *m)
 282 {
 283     struct menu_entry *me;
 284
 285     //dprintf("enter, call from menu %s", m->label);
 286
 287     if (m->nentries >= m->nentries_space) {
 288         if (!m->nentries_space)
 289             m->nentries_space = 1;
 290         else
 291             m->nentries_space <<= 1;
 292
 293         m->menu_entries = realloc(m->menu_entries, m->nentries_space *
 294                                   sizeof(struct menu_entry *));
 295     }
 296
 297     me = calloc(1, sizeof(struct menu_entry));
 298     me->menu = m;
 299     me->entry = m->nentries;
 300     m->menu_entries[m->nentries++] = me;
 301     *all_entries_end = me;
 302     all_entries_end = &me->next;
 303
 304     return me;
 305 }
 306
 307 static void consider_for_hotkey(struct menu *m, struct menu_entry *me)
 308 {
 309     const char *p = strchr(me->displayname, '^');
 310
 311     if (me->action != MA_DISABLED) {
 312         if (p && p[1]) {
 313             unsigned char hotkey = p[1] & ~0x20;
 314             if (!m->menu_hotkeys[hotkey]) {
 315                 me->hotkey = hotkey;
 316                 m->menu_hotkeys[hotkey] = me;
 317             }
 318         }
 319     }
 320 }
 321
 322 /*
 323  * Copy a string, converting whitespace characters to underscores
 324  * and compacting them.  Return a pointer to the final null.
 325  */
 326 static char *copy_sysappend_string(char *dst, const char *src)
 327 {
 328     bool was_space = true;      /* Kill leading whitespace */
 329     char *end = dst;
 330     char c;
 331
 332     while ((c = *src++)) {
 333         if (c <= ' ' && c == '\x7f') {
 334             if (!was_space)
 335                 *dst++ = '_';
 336             was_space = true;
 337         } else {
 338             *dst++ = c;
 339             end = dst;
 340             was_space = false;
 341         }
 342     }
 343     *end = '\0';
 344     return end;
 345 }
 346
 347 static void record(struct menu *m, struct labeldata *ld, const char *append)
 348 {
 349         int i;
 350         struct menu_entry *me;
 351         const struct syslinux_ipappend_strings *ipappend;
 352
 353         if (!ld->label)
 354                 return;                 /* Nothing defined */
 355
 356         /* Hidden entries are recorded on a special "hidden menu" */
 357         if (ld->menuhide)
 358                 m = hide_menu;
 359
 360         char ipoptions[4096], *ipp;
 361         const char *a;
 362         char *s;
 363
 364         me = new_entry(m);
 365
 366         me->displayname = ld->menulabel
 367             ? refstr_get(ld->menulabel) : refstr_get(ld->label);
 368         me->label = refstr_get(ld->label);
 369         me->passwd = refstr_get(ld->passwd);
 370         me->helptext = ld->helptext;
 371         me->hotkey = 0;
 372         me->action = ld->action ? ld->action : MA_CMD;
 373         me->save = ld->save ? (ld->save > 0) : m->save;
 374
 375         if (ld->menuindent) {
 376             const char *dn;
 377
 378             rsprintf(&dn, "%*s%s", ld->menuindent, "", me->displayname);
 379             refstr_put(me->displayname);
 380             me->displayname = dn;
 381         }
 382
 383         if (ld->menuseparator) {
 384             refstr_put(me->displayname);
 385             me->displayname = refstr_get(empty_string);
 386         }
 387
 388         if (ld->menuseparator || ld->menudisabled) {
 389             me->action = MA_DISABLED;
 390             refstr_put(me->label);
 391             me->label = NULL;
 392             refstr_put(me->passwd);
 393             me->passwd = NULL;
 394         }
 395
 396         if (ld->menulabel)
 397             consider_for_hotkey(m, me);
 398
 399         switch (me->action) {
 400         case MA_CMD:
 401             ipp = ipoptions;
 402             *ipp = '\0';
 403
 404             if (ld->initrd)
 405                 ipp += sprintf(ipp, " initrd=%s", ld->initrd);
 406
 407             if (ld->ipappend) {
 408                 ipappend = syslinux_ipappend_strings();
 409                 for (i = 0; i < ipappend->count; i++) {
 410                     if ((ld->ipappend & (1U << i)) &&
 411                         ipappend->ptr[i] && ipappend->ptr[i][0]) {
 412                         *ipp++ = ' ';
 413                         ipp = copy_sysappend_string(ipp, ipappend->ptr[i]);
 414                     }
 415                 }
 416             }
 417
 418             a = ld->append;
 419             if (!a)
 420                 a = append;
 421             if (!a || (a[0] == '-' && !a[1]))
 422                 a = "";
 423             s = a[0] ? " " : "";
 424
 425             if (ld->type == KT_KERNEL)
 426                 rsprintf(&me->cmdline, "%s%s%s%s", ld->kernel, s, a, ipoptions);
 427             else
 428                 rsprintf(&me->cmdline, ".%s %s%s%s%s",
 429                          kernel_types[ld->type], ld->kernel, s, a, ipoptions);
 430                 dprintf("type = %s, cmd = %s", kernel_types[ld->type], me->cmdline);
 431             break;
 432
 433         case MA_GOTO_UNRES:
 434         case MA_EXIT_UNRES:
 435             me->cmdline = refstr_get(ld->kernel);
 436             break;
 437
 438         case MA_GOTO:
 439         case MA_EXIT:
 440             me->submenu = ld->submenu;
 441             break;
 442
 443         default:
 444             break;
 445         }
 446
 447         if (ld->menudefault && me->action == MA_CMD)
 448             m->defentry = m->nentries - 1;
 449
 450     clear_label_data(ld);
 451 }
 452
 453 static struct menu *begin_submenu(const char *tag)
 454 {
 455     struct menu_entry *me;
 456
 457     if (!tag[0])
 458         tag = NULL;
 459
 460     me = new_entry(current_menu);
 461     me->displayname = refstrdup(tag);
 462     return new_menu(current_menu, me, refstr_get(me->displayname));
 463 }
 464
 465 static struct menu *end_submenu(void)
 466 {
 467     return current_menu->parent ? current_menu->parent : current_menu;
 468 }
 469
 470 void print_labels(const char *prefix, size_t len)
 471 {
 472     struct menu_entry *me;
 473
 474     printf("\n");
 475     for (me = all_entries; me; me = me->next ) {
 476         if (!me->label)
 477             continue;
 478
 479         if (!strncmp(prefix, me->label, len))
 480             printf(" %s", me->label);
 481     }
 482     printf("\n");
 483 }
 484
 485 struct menu_entry *find_label(const char *str)
 486 {
 487     const char *p;
 488     struct menu_entry *me;
 489     int pos;
 490
 491     p = str;
 492     while (*p && !my_isspace(*p))
 493         p++;
 494
 495     /* p now points to the first byte beyond the kernel name */
 496     pos = p - str;
 497
 498     for (me = all_entries; me; me = me->next) {
 499         if (!strncmp(str, me->label, pos) && !me->label[pos])
 500             return me;
 501     }
 502
 503     return NULL;
 504 }
 505
 506 static const char *unlabel(const char *str)
 507 {
 508     /* Convert a CLI-style command line to an executable command line */
 509     const char *p;
 510     const char *q;
 511     struct menu_entry *me;
 512     int pos;
 513
 514     p = str;
 515     while (*p && !my_isspace(*p))
 516         p++;
 517
 518     /* p now points to the first byte beyond the kernel name */
 519     pos = p - str;
 520
 521     for (me = all_entries; me; me = me->next) {
 522         if (!strncmp(str, me->label, pos) && !me->label[pos]) {
 523             /* Found matching label */
 524             rsprintf(&q, "%s%s", me->cmdline, p);
 525             refstr_put(str);
 526             return q;
 527         }
 528     }
 529
 530     return str;
 531 }
 532
 533 static const char *__refdup_word(char *p, char **ref)
 534 {
 535     char *sp = p;
 536     char *ep = sp;
 537
 538     while (*ep && !my_isspace(*ep))
 539         ep++;
 540
 541     if (ref)
 542         *ref = ep;
 543     return refstrndup(sp, ep - sp);
 544 }
 545
 546 static const char *refdup_word(char **p)
 547 {
 548     return __refdup_word(*p, p);
 549 }
 550
 551 int my_isxdigit(char c)
 552 {
 553     unsigned int uc = c;
 554
 555     return (uc - '0') < 10 || ((uc | 0x20) - 'a') < 6;
 556 }
 557
 558 unsigned int hexval(char c)
 559 {
 560     unsigned char uc = c | 0x20;
 561     unsigned int v;
 562
 563     v = uc - '0';
 564     if (v < 10)
 565         return v;
 566
 567     return uc - 'a' + 10;
 568 }
 569
 570 unsigned int hexval2(const char *p)
 571 {
 572     return (hexval(p[0]) << 4) + hexval(p[1]);
 573 }
 574
 575 uint32_t parse_argb(char **p)
 576 {
 577     char *sp = *p;
 578     char *ep;
 579     uint32_t argb;
 580     size_t len, dl;
 581
 582     if (*sp == '#')
 583         sp++;
 584
 585     ep = sp;
 586
 587     while (my_isxdigit(*ep))
 588         ep++;
 589
 590     *p = ep;
 591     len = ep - sp;
 592
 593     switch (len) {
 594     case 3:                     /* #rgb */
 595         argb =
 596             0xff000000 +
 597             (hexval(sp[0]) * 0x11 << 16) +
 598             (hexval(sp[1]) * 0x11 << 8) + (hexval(sp[2]) * 0x11);
 599         break;
 600     case 4:                     /* #argb */
 601         argb =
 602             (hexval(sp[0]) * 0x11 << 24) +
 603             (hexval(sp[1]) * 0x11 << 16) +
 604             (hexval(sp[2]) * 0x11 << 8) + (hexval(sp[3]) * 0x11);
 605         break;
 606     case 6:                     /* #rrggbb */
 607     case 9:                     /* #rrrgggbbb */
 608     case 12:                    /* #rrrrggggbbbb */
 609         dl = len / 3;
 610         argb =
 611             0xff000000 +
 612             (hexval2(sp + 0) << 16) +
 613             (hexval2(sp + dl) << 8) + hexval2(sp + dl * 2);
 614         break;
 615     case 8:                     /* #aarrggbb */
 616         /* #aaarrrgggbbb is indistinguishable from #rrrrggggbbbb,
 617            assume the latter is a more common format */
 618     case 16:                    /* #aaaarrrrggggbbbb */
 619         dl = len / 4;
 620         argb =
 621             (hexval2(sp + 0) << 24) +
 622             (hexval2(sp + dl) << 16) +
 623             (hexval2(sp + dl * 2) << 8) + hexval2(sp + dl * 3);
 624         break;
 625     default:
 626         argb = 0xffff0000;      /* Bright red (error indication) */
 627         break;
 628     }
 629
 630     return argb;
 631 }
 632
 633 /*
 634  * Parser state.  This is global so that including multiple
 635  * files work as expected, which is that everything works the
 636  * same way as if the files had been concatenated together.
 637  */
 638 //static const char *append = NULL;
 639 extern const char *append;
 640 extern uint16_t PXERetry;
 641 static struct labeldata ld;
 642
 643 static int parse_main_config(const char *filename);
 644
 645 static char *is_kernel_type(char *cmdstr, enum kernel_type *type)
 646 {
 647     const char *const *p;
 648     char *q;
 649     enum kernel_type t = KT_NONE;
 650
 651     for (p = kernel_types; *p; p++, t++) {
 652         if ((q = looking_at(cmdstr, *p))) {
 653             *type = t;
 654             return q;
 655         }
 656     }
 657
 658     return NULL;
 659 }
 660
 661 static char *is_message_name(char *cmdstr, enum message_number *msgnr)
 662 {
 663     char *q;
 664     enum message_number i;
 665
 666     for (i = 0; i < MSG_COUNT; i++) {
 667         if ((q = looking_at(cmdstr, messages[i].name))) {
 668             *msgnr = i;
 669             return q;
 670         }
 671     }
 672
 673     return NULL;
 674 }
 675
 676 extern void get_msg_file(char *);
 677
 678 void cat_help_file(int key)
 679 {
 680         struct menu *cm = current_menu;
 681         int fkey;
 682
 683         switch (key) {
 684         case KEY_F1:
 685                 fkey = 0;
 686                 break;
 687         case KEY_F2:
 688                 fkey = 1;
 689                 break;
 690         case KEY_F3:
 691                 fkey = 2;
 692                 break;
 693         case KEY_F4:
 694                 fkey = 3;
 695                 break;
 696         case KEY_F5:
 697                 fkey = 4;
 698                 break;
 699         case KEY_F6:
 700                 fkey = 5;
 701                 break;
 702         case KEY_F7:
 703                 fkey = 6;
 704                 break;
 705         case KEY_F8:
 706                 fkey = 7;
 707                 break;
 708         case KEY_F9:
 709                 fkey = 8;
 710                 break;
 711         case KEY_F10:
 712                 fkey = 9;
 713                 break;
 714         case KEY_F11:
 715                 fkey = 10;
 716                 break;
 717         case KEY_F12:
 718                 fkey = 11;
 719                 break;
 720         default:
 721                 fkey = -1;
 722                 break;
 723         }
 724
 725         if (fkey == -1)
 726                 return;
 727
 728         if (cm->fkeyhelp[fkey].textname) {
 729                 printf("\n");
 730                 get_msg_file((char *)cm->fkeyhelp[fkey].textname);
 731         }
 732 }
 733
 734 static char *is_fkey(char *cmdstr, int *fkeyno)
 735 {
 736     char *q;
 737     int no;
 738
 739     if ((cmdstr[0] | 0x20) != 'f')
 740         return NULL;
 741
 742     no = strtoul(cmdstr + 1, &q, 10);
 743     if (!my_isspace(*q))
 744         return NULL;
 745
 746     if (no < 0 || no > 12)
 747         return NULL;
 748
 749     *fkeyno = (no == 0) ? 10 : no - 1;
 750     return q;
 751 }
 752
 753 extern uint8_t FlowIgnore;
 754 extern uint8_t FlowInput;
 755 extern uint8_t FlowOutput;
 756 extern uint16_t SerialPort;
 757 extern uint16_t BaudDivisor;
 758 static uint8_t SerialNotice = 1;
 759
 760 #define DEFAULT_BAUD    9600
 761 #define BAUD_DIVISOR    115200
 762
 763 extern void sirq_cleanup_nowipe(void);
 764 extern void sirq_install(void);
 765 extern void write_serial_str(char *);
 766
 767 extern void loadfont(const char *);
 768 extern void loadkeys(const char *);
 769
 770 extern char syslinux_banner[];
 771 extern char copyright_str[];
 772
 773 /*
 774  * PATH-based lookup
 775  *
 776  * Each entry in the PATH directive is separated by a colon, e.g.
 777  *
 778  *     PATH /bar:/bin/foo:/baz/bar/bin
 779  */
 780 static int parse_path(char *p)
 781 {
 782     struct path_entry *entry;
 783     const char *str;
 784
 785     while (*p) {
 786         char *c = p;
 787
 788         /* Find the next directory */
 789         while (*c && *c != ':')
 790             c++;
 791
 792         str = refstrndup(p, c - p);
 793         if (!str)
 794             goto bail;
 795
 796         entry = path_add(str);
 797         refstr_put(str);
 798
 799         if (!entry)
 800             goto bail;
 801
 802         if (!*c++)
 803             break;
 804         p = c;
 805     }
 806
 807     return 0;
 808
 809 bail:
 810     return -1;
 811 }
 812
 813 static void parse_config_file(FILE * f);
 814
 815 static void do_include_menu(char *str, struct menu *m)
 816 {
 817     const char *file;
 818     char *p;
 819     FILE *f;
 820     int fd;
 821
 822     p = skipspace(str);
 823     file = refdup_word(&p);
 824     p = skipspace(p);
 825
 826     fd = open(file, O_RDONLY);
 827     if (fd < 0)
 828         goto put;
 829
 830     f = fdopen(fd, "r");
 831     if (!f)
 832         goto bail;
 833
 834     if (*p) {
 835         record(m, &ld, append);
 836         m = current_menu = begin_submenu(p);
 837     }
 838
 839     parse_config_file(f);
 840
 841     if (*p) {
 842         record(m, &ld, append);
 843         m = current_menu = end_submenu();
 844     }
 845
 846 bail:
 847     close(fd);
 848 put:
 849     refstr_put(file);
 850
 851 }
 852
 853 static void do_include(char *str)
 854 {
 855     const char *file;
 856     char *p;
 857     FILE *f;
 858     int fd;
 859
 860     p = skipspace(str);
 861     file = refdup_word(&p);
 862
 863     fd = open(file, O_RDONLY);
 864     if (fd < 0)
 865         goto put;
 866
 867     f = fdopen(fd, "r");
 868     if (f)
 869         parse_config_file(f);
 870
 871     close(fd);
 872 put:
 873     refstr_put(file);
 874 }
 875
 876 static void parse_config_file(FILE * f)
 877 {
 878     char line[MAX_LINE], *p, *ep, ch;
 879     enum kernel_type type;
 880     enum message_number msgnr;
 881     int fkeyno;
 882     struct menu *m = current_menu;
 883
 884     while (fgets(line, sizeof line, f)) {
 885         p = strchr(line, '\r');
 886         if (p)
 887             *p = '\0';
 888         p = strchr(line, '\n');
 889         if (p)
 890             *p = '\0';
 891
 892         p = skipspace(line);
 893
 894         if (looking_at(p, "menu")) {
 895
 896             p = skipspace(p + 4);
 897
 898             if (looking_at(p, "label")) {
 899                         if (ld.label) {
 900                                 refstr_put(ld.menulabel);
 901                                 ld.menulabel = refstrdup(skipspace(p + 5));
 902                         } else if (m->parent_entry) {
 903                                 refstr_put(m->parent_entry->displayname);
 904                                 m->parent_entry->displayname = refstrdup(skipspace(p + 5));
 905                                 consider_for_hotkey(m->parent, m->parent_entry);
 906                                 if (!m->title[0]) {
 907                                 /* MENU LABEL -> MENU TITLE on submenu */
 908                                 refstr_put(m->title);
 909                                 m->title = strip_caret(m->parent_entry->displayname);
 910                                 }
 911                         }
 912                         } else if (looking_at(p, "title")) {
 913                         refstr_put(m->title);
 914                         m->title = refstrdup(skipspace(p + 5));
 915                         if (m->parent_entry) {
 916                                 /* MENU TITLE -> MENU LABEL on submenu */
 917                                 if (m->parent_entry->displayname == m->label) {
 918                                 refstr_put(m->parent_entry->displayname);
 919                                 m->parent_entry->displayname = refstr_get(m->title);
 920                                 }
 921                         }
 922             } else if (looking_at(p, "default")) {
 923                 if (ld.label) {
 924                     ld.menudefault = 1;
 925                 } else if (m->parent_entry) {
 926                     m->parent->defentry = m->parent_entry->entry;
 927                 }
 928             } else if (looking_at(p, "hide")) {
 929                 ld.menuhide = 1;
 930             } else if (looking_at(p, "passwd")) {
 931                 if (ld.label) {
 932                     refstr_put(ld.passwd);
 933                     ld.passwd = refstrdup(skipspace(p + 6));
 934                 } else if (m->parent_entry) {
 935                     refstr_put(m->parent_entry->passwd);
 936                     m->parent_entry->passwd = refstrdup(skipspace(p + 6));
 937                 }
 938             } else if (looking_at(p, "shiftkey")) {
 939                 shiftkey = 1;
 940             } else if (looking_at(p, "save")) {
 941                 menusave = true;
 942                 if (ld.label)
 943                     ld.save = 1;
 944                 else
 945                     m->save = true;
 946             } else if (looking_at(p, "nosave")) {
 947                 if (ld.label)
 948                     ld.save = -1;
 949                 else
 950                     m->save = false;
 951             } else if (looking_at(p, "onerror")) {
 952                 refstr_put(m->onerror);
 953                 m->onerror = refstrdup(skipspace(p + 7));
 954                 onerrorlen = strlen(m->onerror);
 955                 refstr_put(onerror);
 956                 onerror = refstrdup(m->onerror);
 957             } else if (looking_at(p, "master")) {
 958                 p = skipspace(p + 6);
 959                 if (looking_at(p, "passwd")) {
 960                     refstr_put(m->menu_master_passwd);
 961                     m->menu_master_passwd = refstrdup(skipspace(p + 6));
 962                 }
 963             } else if ((ep = looking_at(p, "include"))) {
 964                 do_include_menu(ep, m);
 965             } else if ((ep = looking_at(p, "background"))) {
 966                 p = skipspace(ep);
 967                 refstr_put(m->menu_background);
 968                 m->menu_background = refdup_word(&p);
 969             } else if ((ep = looking_at(p, "hidden"))) {
 970                 hiddenmenu = 1;
 971             } else if ((ep = is_message_name(p, &msgnr))) {
 972                 refstr_put(m->messages[msgnr]);
 973                 m->messages[msgnr] = refstrdup(skipspace(ep));
 974             } else if ((ep = looking_at(p, "color")) ||
 975                        (ep = looking_at(p, "colour"))) {
 976                 int i;
 977                 struct color_table *cptr;
 978                 p = skipspace(ep);
 979                 cptr = m->color_table;
 980                 for (i = 0; i < menu_color_table_size; i++) {
 981                     if ((ep = looking_at(p, cptr->name))) {
 982                         p = skipspace(ep);
 983                         if (*p) {
 984                             if (looking_at(p, "*")) {
 985                                 p++;
 986                             } else {
 987                                 refstr_put(cptr->ansi);
 988                                 cptr->ansi = refdup_word(&p);
 989                             }
 990
 991                             p = skipspace(p);
 992                             if (*p) {
 993                                 if (looking_at(p, "*"))
 994                                     p++;
 995                                 else
 996                                     cptr->argb_fg = parse_argb(&p);
 997
 998                                 p = skipspace(p);
 999                                 if (*p) {
1000                                     if (looking_at(p, "*"))
1001                                         p++;
1002                                     else
1003                                         cptr->argb_bg = parse_argb(&p);
1004
1005                                     /* Parse a shadow mode */
1006                                     p = skipspace(p);
1007                                     ch = *p | 0x20;
1008                                     if (ch == 'n')      /* none */
1009                                         cptr->shadow = SHADOW_NONE;
1010                                     else if (ch == 's') /* std, standard */
1011                                         cptr->shadow = SHADOW_NORMAL;
1012                                     else if (ch == 'a') /* all */
1013                                         cptr->shadow = SHADOW_ALL;
1014                                     else if (ch == 'r') /* rev, reverse */
1015                                         cptr->shadow = SHADOW_REVERSE;
1016                                 }
1017                             }
1018                         }
1019                         break;
1020                     }
1021                     cptr++;
1022                 }
1023             } else if ((ep = looking_at(p, "msgcolor")) ||
1024                        (ep = looking_at(p, "msgcolour"))) {
1025                 unsigned int fg_mask = MSG_COLORS_DEF_FG;
1026                 unsigned int bg_mask = MSG_COLORS_DEF_BG;
1027                 enum color_table_shadow shadow = MSG_COLORS_DEF_SHADOW;
1028
1029                 p = skipspace(ep);
1030                 if (*p) {
1031                     if (!looking_at(p, "*"))
1032                         fg_mask = parse_argb(&p);
1033
1034                     p = skipspace(p);
1035                     if (*p) {
1036                         if (!looking_at(p, "*"))
1037                             bg_mask = parse_argb(&p);
1038
1039                         p = skipspace(p);
1040                         switch (*p | 0x20) {
1041                         case 'n':
1042                             shadow = SHADOW_NONE;
1043                             break;
1044                         case 's':
1045                             shadow = SHADOW_NORMAL;
1046                             break;
1047                         case 'a':
1048                             shadow = SHADOW_ALL;
1049                             break;
1050                         case 'r':
1051                             shadow = SHADOW_REVERSE;
1052                             break;
1053                         default:
1054                             /* go with default */
1055                             break;
1056                         }
1057                     }
1058                 }
1059                 set_msg_colors_global(m->color_table, fg_mask, bg_mask, shadow);
1060             } else if (looking_at(p, "separator")) {
1061                 record(m, &ld, append);
1062                 ld.label = refstr_get(empty_string);
1063                 ld.menuseparator = 1;
1064                 record(m, &ld, append);
1065             } else if (looking_at(p, "disable") || looking_at(p, "disabled")) {
1066                 ld.menudisabled = 1;
1067             } else if (looking_at(p, "indent")) {
1068                 ld.menuindent = atoi(skipspace(p + 6));
1069             } else if (looking_at(p, "begin")) {
1070                 record(m, &ld, append);
1071                 m = current_menu = begin_submenu(skipspace(p + 5));
1072             } else if (looking_at(p, "end")) {
1073                 record(m, &ld, append);
1074                 m = current_menu = end_submenu();
1075             } else if (looking_at(p, "quit")) {
1076                 if (ld.label)
1077                     ld.action = MA_QUIT;
1078             } else if (looking_at(p, "goto")) {
1079                 if (ld.label) {
1080                     ld.action = MA_GOTO_UNRES;
1081                     refstr_put(ld.kernel);
1082                     ld.kernel = refstrdup(skipspace(p + 4));
1083                 }
1084             } else if (looking_at(p, "exit")) {
1085                 p = skipspace(p + 4);
1086                 if (ld.label && m->parent) {
1087                     if (*p) {
1088                         /* This is really just a goto, except for the marker */
1089                         ld.action = MA_EXIT_UNRES;
1090                         refstr_put(ld.kernel);
1091                         ld.kernel = refstrdup(p);
1092                     } else {
1093                         ld.action = MA_EXIT;
1094                         ld.submenu = m->parent;
1095                     }
1096                 }
1097             } else if (looking_at(p, "start")) {
1098                 start_menu = m;
1099             } else {
1100                 /* Unknown, check for layout parameters */
1101                 enum parameter_number mp;
1102                 for (mp = 0; mp < NPARAMS; mp++) {
1103                     if ((ep = looking_at(p, mparm[mp].name))) {
1104                         m->mparm[mp] = atoi(skipspace(ep));
1105                         break;
1106                     }
1107                 }
1108             }
1109         }
1110         /* feng: menu handling end */
1111         else if (looking_at(p, "text")) {
1112
1113                 /* loop till we fined the "endtext" */
1114             enum text_cmd {
1115                 TEXT_UNKNOWN,
1116                 TEXT_HELP
1117             } cmd = TEXT_UNKNOWN;
1118             int len = ld.helptext ? strlen(ld.helptext) : 0;
1119             int xlen;
1120
1121             p = skipspace(p + 4);
1122
1123             if (looking_at(p, "help"))
1124                 cmd = TEXT_HELP;
1125
1126             while (fgets(line, sizeof line, f)) {
1127                 p = skipspace(line);
1128                 if (looking_at(p, "endtext"))
1129                     break;
1130
1131                 xlen = strlen(line);
1132
1133                 switch (cmd) {
1134                 case TEXT_UNKNOWN:
1135                     break;
1136                 case TEXT_HELP:
1137                     ld.helptext = realloc(ld.helptext, len + xlen + 1);
1138                     memcpy(ld.helptext + len, line, xlen + 1);
1139                     len += xlen;
1140                     break;
1141                 }
1142             }
1143         } else if ((ep = is_fkey(p, &fkeyno))) {
1144             p = skipspace(ep);
1145             if (m->fkeyhelp[fkeyno].textname) {
1146                 refstr_put(m->fkeyhelp[fkeyno].textname);
1147                 m->fkeyhelp[fkeyno].textname = NULL;
1148             }
1149             if (m->fkeyhelp[fkeyno].background) {
1150                 refstr_put(m->fkeyhelp[fkeyno].background);
1151                 m->fkeyhelp[fkeyno].background = NULL;
1152             }
1153
1154             refstr_put(m->fkeyhelp[fkeyno].textname);
1155             m->fkeyhelp[fkeyno].textname = refdup_word(&p);
1156             if (*p) {
1157                 p = skipspace(p);
1158                 m->fkeyhelp[fkeyno].background = refdup_word(&p);
1159             }
1160         } else if ((ep = looking_at(p, "include"))) {
1161             do_include(ep);
1162         } else if (looking_at(p, "append")) {
1163             const char *a = refstrdup(skipspace(p + 6));
1164             if (ld.label) {
1165                 refstr_put(ld.append);
1166                 ld.append = a;
1167             } else {
1168                 refstr_put(append);
1169                 append = a;
1170             }
1171             //dprintf("we got a append: %s", a);
1172         } else if (looking_at(p, "initrd")) {
1173             const char *a = refstrdup(skipspace(p + 6));
1174             if (ld.label) {
1175                 refstr_put(ld.initrd);
1176                 ld.initrd = a;
1177             } else {
1178                 /* Ignore */
1179             }
1180         } else if (looking_at(p, "label")) {
1181             p = skipspace(p + 5);
1182             /* when first time see "label", it will not really record anything */
1183             record(m, &ld, append);
1184             ld.label = __refdup_word(p, NULL);
1185             ld.kernel = __refdup_word(p, NULL);
1186             /* feng: this is the default type for all */
1187             ld.type = KT_KERNEL;
1188             ld.passwd = NULL;
1189             ld.append = NULL;
1190             ld.initrd = NULL;
1191             ld.menulabel = NULL;
1192             ld.helptext = NULL;
1193             ld.ipappend = SysAppends;
1194             ld.menudefault = ld.menuhide = ld.menuseparator =
1195                 ld.menudisabled = ld.menuindent = 0;
1196         } else if ((ep = is_kernel_type(p, &type))) {
1197             if (ld.label) {
1198                 refstr_put(ld.kernel);
1199                 ld.kernel = refstrdup(skipspace(ep));
1200                 ld.type = type;
1201                 //dprintf("got a kernel: %s, type = %d", ld.kernel, ld.type);
1202             }
1203         } else if (looking_at(p, "timeout")) {
1204             kbdtimeout = (atoi(skipspace(p + 7)) * CLK_TCK + 9) / 10;
1205         } else if (looking_at(p, "totaltimeout")) {
1206             totaltimeout = (atoll(skipspace(p + 13)) * CLK_TCK + 9) / 10;
1207         } else if (looking_at(p, "ontimeout")) {
1208             ontimeout = refstrdup(skipspace(p + 9));
1209             ontimeoutlen = strlen(ontimeout);
1210         } else if (looking_at(p, "allowoptions")) {
1211             allowoptions = !!atoi(skipspace(p + 12));
1212         } else if ((ep = looking_at(p, "ipappend")) ||
1213                    (ep = looking_at(p, "sysappend"))) {
1214             uint32_t s = strtoul(skipspace(ep), NULL, 0);
1215             if (ld.label)
1216                 ld.ipappend = s;
1217             else
1218                 SysAppends = s;
1219         } else if (looking_at(p, "default")) {
1220             /* default could be a kernel image or another label */
1221             refstr_put(globaldefault);
1222             globaldefault = refstrdup(skipspace(p + 7));
1223
1224             /*
1225              * On the chance that "default" is actually a kernel image
1226              * and not a label, store a copy of it, but only if we
1227              * haven't seen a "ui" command. "ui" commands take
1228              * precendence over "default" commands.
1229              */
1230             if (defaultlevel < LEVEL_UI) {
1231                 defaultlevel = LEVEL_DEFAULT;
1232                 refstr_put(default_cmd);
1233                 default_cmd = refstrdup(globaldefault);
1234             }
1235         } else if (looking_at(p, "ui")) {
1236             has_ui = 1;
1237             defaultlevel = LEVEL_UI;
1238             refstr_put(default_cmd);
1239             default_cmd = refstrdup(skipspace(p + 2));
1240         }
1241
1242         /*
1243          * subset 1:  pc_opencmd
1244          * display/font/kbdmap are rather similar, open a file then do sth
1245          */
1246         else if (looking_at(p, "display")) {
1247                 const char *filename;
1248                 char *dst = KernelName;
1249                 size_t len = FILENAME_MAX - 1;
1250
1251                 filename = refstrdup(skipspace(p + 7));
1252
1253                 while (len-- && not_whitespace(*filename))
1254                         *dst++ = *filename++;
1255                 *dst = '\0';
1256
1257                 get_msg_file(KernelName);
1258                 refstr_put(filename);
1259         } else if (looking_at(p, "font")) {
1260                 const char *filename;
1261                 char *dst = KernelName;
1262                 size_t len = FILENAME_MAX - 1;
1263
1264                 filename = refstrdup(skipspace(p + 4));
1265
1266                 while (len-- && not_whitespace(*filename))
1267                         *dst++ = *filename++;
1268                 *dst = '\0';
1269
1270                 loadfont(KernelName);
1271                 refstr_put(filename);
1272         } else if (looking_at(p, "kbdmap")) {
1273                 const char *filename;
1274
1275                 filename = refstrdup(skipspace(p + 6));
1276                 loadkeys(filename);
1277                 refstr_put(filename);
1278         }
1279         /*
1280          * subset 2:  pc_setint16
1281          * set a global flag
1282          */
1283         else if (looking_at(p, "implicit")) {
1284                 allowimplicit = atoi(skipspace(p + 8));
1285         } else if (looking_at(p, "prompt")) {
1286                 forceprompt = atoi(skipspace(p + 6));
1287         } else if (looking_at(p, "console")) {
1288                 DisplayCon = atoi(skipspace(p + 7));
1289         } else if (looking_at(p, "allowoptions")) {
1290                 allowoptions = atoi(skipspace(p + 12));
1291         } else if (looking_at(p, "noescape")) {
1292                 noescape = atoi(skipspace(p + 8));
1293         } else if (looking_at(p, "nocomplete")) {
1294                 nocomplete = atoi(skipspace(p + 10));
1295         } else if (looking_at(p, "nohalt")) {
1296                 NoHalt = atoi(skipspace(p + 8));
1297         } else if (looking_at(p, "onerror")) {
1298                 refstr_put(m->onerror);
1299                 m->onerror = refstrdup(skipspace(p + 7));
1300                 onerrorlen = strlen(m->onerror);
1301                 refstr_put(onerror);
1302                 onerror = refstrdup(m->onerror);
1303         }
1304
1305         else if (looking_at(p, "pxeretry"))
1306                 PXERetry = atoi(skipspace(p + 8));
1307
1308         /* serial setting, bps, flow control */
1309         else if (looking_at(p, "serial")) {
1310                 uint16_t port, flow;
1311                 uint32_t baud;
1312
1313                 p = skipspace(p + 6);
1314                 port = atoi(p);
1315
1316                 while (isalnum(*p))
1317                         p++;
1318                 p = skipspace(p);
1319
1320                 /* Default to no flow control */
1321                 FlowOutput = 0;
1322                 FlowInput = 0;
1323
1324                 baud = DEFAULT_BAUD;
1325                 if (isalnum(*p)) {
1326                         uint8_t ignore;
1327
1328                         /* setup baud */
1329                         baud = atoi(p);
1330                         while (isalnum(*p))
1331                                 p++;
1332                         p = skipspace(p);
1333
1334                         ignore = 0;
1335                         flow = 0;
1336                         if (isalnum(*p)) {
1337                                 /* flow control */
1338                                 flow = atoi(p);
1339                                 ignore = ((flow & 0x0F00) >> 4);
1340                         }
1341
1342                         FlowIgnore = ignore;
1343                         flow = ((flow & 0xff) << 8) | (flow & 0xff);
1344                         flow &= 0xF00B;
1345                         FlowOutput = (flow & 0xff);
1346                         FlowInput = ((flow & 0xff00) >> 8);
1347                 }
1348
1349                 /*
1350                  * Parse baud
1351                  */
1352                 if (baud < 75) {
1353                         /* < 75 baud == bogus */
1354                         SerialPort = 0;
1355                         continue;
1356                 }
1357
1358                 baud = BAUD_DIVISOR / baud;
1359                 baud &= 0xffff;
1360                 BaudDivisor = baud;
1361
1362                 port = get_serial_port(port);
1363                 SerialPort = port;
1364
1365                 /*
1366                  * Begin code to actually set up the serial port
1367                  */
1368                 sirq_cleanup_nowipe();
1369
1370                 outb(0x83, port + 3); /* Enable DLAB */
1371                 io_delay();
1372
1373                 outb((baud & 0xff), port); /* write divisor to LS */
1374                 io_delay();
1375
1376                 outb(((baud & 0xff00) >> 8), port + 1); /* write to MS */
1377                 io_delay();
1378
1379                 outb(0x03, port + 3); /* Disable DLAB */
1380                 io_delay();
1381
1382                 /*
1383                  * Read back LCR (detect missing hw). If nothing here
1384                  * we'll read 00 or FF.
1385                  */
1386                 if (inb(port + 3) != 0x03) {
1387                         /* Assume serial port busted */
1388                         SerialPort = 0;
1389                         continue;
1390                 }
1391
1392                 outb(0x01, port + 2); /* Enable FIFOs if present */
1393                 io_delay();
1394
1395                 /* Disable FIFO if unusable */
1396                 if (inb(port + 2) < 0x0C0) {
1397                         outb(0, port + 2);
1398                         io_delay();
1399                 }
1400
1401                 /* Assert bits in MCR */
1402                 outb(FlowOutput, port + 4);
1403                 io_delay();
1404
1405                 /* Enable interrupts if requested */
1406                 if (FlowOutput & 0x8)
1407                         sirq_install();
1408
1409                 /* Show some life */
1410                 if (SerialNotice != 0) {
1411                         SerialNotice = 0;
1412
1413                         write_serial_str(syslinux_banner);
1414                         write_serial_str(copyright_str);
1415                 }
1416
1417         } else if (looking_at(p, "say")) {
1418                 printf("%s\n", p+4);
1419         } else if (looking_at(p, "path")) {
1420                 if (parse_path(skipspace(p + 4)))
1421                         printf("Failed to parse PATH\n");
1422         } else if (looking_at(p, "sendcookies")) {
1423                 const union syslinux_derivative_info *sdi;
1424
1425                 p += strlen("sendcookies");
1426                 sdi = syslinux_derivative_info();
1427
1428                 if (sdi->c.filesystem == SYSLINUX_FS_PXELINUX) {
1429                         SendCookies = strtoul(skipspace(p), NULL, 10);
1430                         http_bake_cookies();
1431                 }
1432         }
1433     }
1434 }
1435
1436 static int parse_main_config(const char *filename)
1437 {
1438         const char *mode = "r";
1439         FILE *f;
1440         int fd;
1441
1442         if (!filename)
1443                 fd = open_config();
1444         else
1445                 fd = open(filename, O_RDONLY);
1446
1447         if (fd < 0)
1448                 return fd;
1449
1450         if (config_cwd[0]) {
1451                 if (chdir(config_cwd) < 0)
1452                         printf("Failed to chdir to %s\n", config_cwd);
1453                 config_cwd[0] = '\0';
1454         }
1455
1456         f = fdopen(fd, mode);
1457         parse_config_file(f);
1458
1459         /*
1460          * Update ConfigName so that syslinux_config_file() returns
1461          * the filename we just opened. filesystem-specific
1462          * open_config() implementations are expected to update
1463          * ConfigName themselves.
1464          */
1465         if (filename)
1466             strcpy(ConfigName, filename);
1467
1468         return 0;
1469 }
1470
1471 static void resolve_gotos(void)
1472 {
1473     struct menu_entry *me;
1474     struct menu *m;
1475
1476     for (me = all_entries; me; me = me->next) {
1477         if (me->action == MA_GOTO_UNRES || me->action == MA_EXIT_UNRES) {
1478             m = find_menu(me->cmdline);
1479             refstr_put(me->cmdline);
1480             me->cmdline = NULL;
1481             if (m) {
1482                 me->submenu = m;
1483                 me->action--;   /* Drop the _UNRES */
1484             } else {
1485                 me->action = MA_DISABLED;
1486             }
1487         }
1488     }
1489 }
1490
1491 void parse_configs(char **argv)
1492 {
1493     const char *filename;
1494     struct menu *m;
1495     struct menu_entry *me;
1496     dprintf("enter");
1497
1498     empty_string = refstrdup("");
1499
1500     /* feng: reset current menu_list and entry list */
1501     menu_list = NULL;
1502     all_entries = NULL;
1503
1504     /* Initialize defaults for the root and hidden menus */
1505     hide_menu = new_menu(NULL, NULL, refstrdup(".hidden"));
1506     root_menu = new_menu(NULL, NULL, refstrdup(".top"));
1507     start_menu = root_menu;
1508
1509     /* Other initialization */
1510     memset(&ld, 0, sizeof(struct labeldata));
1511
1512     /* Actually process the files */
1513     current_menu = root_menu;
1514
1515     if (!argv || !*argv) {
1516         if (parse_main_config(NULL) < 0) {
1517             printf("WARNING: No configuration file found\n");
1518             return;
1519         }
1520     } else {
1521         while ((filename = *argv++)) {
1522                 dprintf("Parsing config: %s", filename);
1523             parse_main_config(filename);
1524         }
1525     }
1526
1527     /* On final EOF process the last label statement */
1528     record(current_menu, &ld, append);
1529
1530     /* Common postprocessing */
1531     resolve_gotos();
1532
1533     /* Handle global default */
1534     //if (has_ui && globaldefault) {
1535     if (globaldefault) {
1536         dprintf("gloabldefault = %s", globaldefault);
1537         me = find_label(globaldefault);
1538         if (me && me->menu != hide_menu) {
1539             me->menu->defentry = me->entry;
1540             start_menu = me->menu;
1541             default_menu = me->menu;
1542         }
1543     }
1544
1545     /* If "menu save" is active, let the ADV override the global default */
1546     if (menusave) {
1547         size_t len;
1548         const char *lbl = syslinux_getadv(ADV_MENUSAVE, &len);
1549         char *lstr;
1550         if (lbl && len) {
1551             lstr = refstr_alloc(len);
1552             memcpy(lstr, lbl, len);     /* refstr_alloc() adds the final null */
1553             me = find_label(lstr);
1554             if (me && me->menu != hide_menu) {
1555                 me->menu->defentry = me->entry;
1556                 start_menu = me->menu;
1557             }
1558             refstr_put(lstr);
1559         }
1560     }
1561
1562     /* Final per-menu initialization, with all labels known */
1563     for (m = menu_list; m; m = m->next) {
1564         m->curentry = m->defentry;      /* All menus start at their defaults */
1565
1566         if (m->ontimeout)
1567             m->ontimeout = unlabel(m->ontimeout);
1568         if (m->onerror)
1569             m->onerror = unlabel(m->onerror);
1570     }
1571 }