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(char *);
 768 extern void loadkeys(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 bail:
 872     close(fd);
 873 put:
 874     refstr_put(file);
 875 }
 876
 877 static void parse_config_file(FILE * f)
 878 {
 879     char line[MAX_LINE], *p, *ep, ch;
 880     enum kernel_type type;
 881     enum message_number msgnr;
 882     int fkeyno;
 883     struct menu *m = current_menu;
 884
 885     while (fgets(line, sizeof line, f)) {
 886         p = strchr(line, '\r');
 887         if (p)
 888             *p = '\0';
 889         p = strchr(line, '\n');
 890         if (p)
 891             *p = '\0';
 892
 893         p = skipspace(line);
 894
 895         if (looking_at(p, "menu")) {
 896
 897             p = skipspace(p + 4);
 898
 899             if (looking_at(p, "label")) {
 900                         if (ld.label) {
 901                                 refstr_put(ld.menulabel);
 902                                 ld.menulabel = refstrdup(skipspace(p + 5));
 903                         } else if (m->parent_entry) {
 904                                 refstr_put(m->parent_entry->displayname);
 905                                 m->parent_entry->displayname = refstrdup(skipspace(p + 5));
 906                                 consider_for_hotkey(m->parent, m->parent_entry);
 907                                 if (!m->title[0]) {
 908                                 /* MENU LABEL -> MENU TITLE on submenu */
 909                                 refstr_put(m->title);
 910                                 m->title = strip_caret(m->parent_entry->displayname);
 911                                 }
 912                         }
 913                         } else if (looking_at(p, "title")) {
 914                         refstr_put(m->title);
 915                         m->title = refstrdup(skipspace(p + 5));
 916                         if (m->parent_entry) {
 917                                 /* MENU TITLE -> MENU LABEL on submenu */
 918                                 if (m->parent_entry->displayname == m->label) {
 919                                 refstr_put(m->parent_entry->displayname);
 920                                 m->parent_entry->displayname = refstr_get(m->title);
 921                                 }
 922                         }
 923             } else if (looking_at(p, "default")) {
 924                 if (ld.label) {
 925                     ld.menudefault = 1;
 926                 } else if (m->parent_entry) {
 927                     m->parent->defentry = m->parent_entry->entry;
 928                 }
 929             } else if (looking_at(p, "hide")) {
 930                 ld.menuhide = 1;
 931             } else if (looking_at(p, "passwd")) {
 932                 if (ld.label) {
 933                     refstr_put(ld.passwd);
 934                     ld.passwd = refstrdup(skipspace(p + 6));
 935                 } else if (m->parent_entry) {
 936                     refstr_put(m->parent_entry->passwd);
 937                     m->parent_entry->passwd = refstrdup(skipspace(p + 6));
 938                 }
 939             } else if (looking_at(p, "shiftkey")) {
 940                 shiftkey = 1;
 941             } else if (looking_at(p, "save")) {
 942                 menusave = true;
 943                 if (ld.label)
 944                     ld.save = 1;
 945                 else
 946                     m->save = true;
 947             } else if (looking_at(p, "nosave")) {
 948                 if (ld.label)
 949                     ld.save = -1;
 950                 else
 951                     m->save = false;
 952             } else if (looking_at(p, "onerror")) {
 953                 refstr_put(m->onerror);
 954                 m->onerror = refstrdup(skipspace(p + 7));
 955                 onerrorlen = strlen(m->onerror);
 956                 refstr_put(onerror);
 957                 onerror = refstrdup(m->onerror);
 958             } else if (looking_at(p, "master")) {
 959                 p = skipspace(p + 6);
 960                 if (looking_at(p, "passwd")) {
 961                     refstr_put(m->menu_master_passwd);
 962                     m->menu_master_passwd = refstrdup(skipspace(p + 6));
 963                 }
 964             } else if ((ep = looking_at(p, "include"))) {
 965                 do_include_menu(ep, m);
 966             } else if ((ep = looking_at(p, "background"))) {
 967                 p = skipspace(ep);
 968                 refstr_put(m->menu_background);
 969                 m->menu_background = refdup_word(&p);
 970             } else if ((ep = looking_at(p, "hidden"))) {
 971                 hiddenmenu = 1;
 972             } else if ((ep = is_message_name(p, &msgnr))) {
 973                 refstr_put(m->messages[msgnr]);
 974                 m->messages[msgnr] = refstrdup(skipspace(ep));
 975             } else if ((ep = looking_at(p, "color")) ||
 976                        (ep = looking_at(p, "colour"))) {
 977                 int i;
 978                 struct color_table *cptr;
 979                 p = skipspace(ep);
 980                 cptr = m->color_table;
 981                 for (i = 0; i < menu_color_table_size; i++) {
 982                     if ((ep = looking_at(p, cptr->name))) {
 983                         p = skipspace(ep);
 984                         if (*p) {
 985                             if (looking_at(p, "*")) {
 986                                 p++;
 987                             } else {
 988                                 refstr_put(cptr->ansi);
 989                                 cptr->ansi = refdup_word(&p);
 990                             }
 991
 992                             p = skipspace(p);
 993                             if (*p) {
 994                                 if (looking_at(p, "*"))
 995                                     p++;
 996                                 else
 997                                     cptr->argb_fg = parse_argb(&p);
 998
 999                                 p = skipspace(p);
1000                                 if (*p) {
1001                                     if (looking_at(p, "*"))
1002                                         p++;
1003                                     else
1004                                         cptr->argb_bg = parse_argb(&p);
1005
1006                                     /* Parse a shadow mode */
1007                                     p = skipspace(p);
1008                                     ch = *p | 0x20;
1009                                     if (ch == 'n')      /* none */
1010                                         cptr->shadow = SHADOW_NONE;
1011                                     else if (ch == 's') /* std, standard */
1012                                         cptr->shadow = SHADOW_NORMAL;
1013                                     else if (ch == 'a') /* all */
1014                                         cptr->shadow = SHADOW_ALL;
1015                                     else if (ch == 'r') /* rev, reverse */
1016                                         cptr->shadow = SHADOW_REVERSE;
1017                                 }
1018                             }
1019                         }
1020                         break;
1021                     }
1022                     cptr++;
1023                 }
1024             } else if ((ep = looking_at(p, "msgcolor")) ||
1025                        (ep = looking_at(p, "msgcolour"))) {
1026                 unsigned int fg_mask = MSG_COLORS_DEF_FG;
1027                 unsigned int bg_mask = MSG_COLORS_DEF_BG;
1028                 enum color_table_shadow shadow = MSG_COLORS_DEF_SHADOW;
1029
1030                 p = skipspace(ep);
1031                 if (*p) {
1032                     if (!looking_at(p, "*"))
1033                         fg_mask = parse_argb(&p);
1034
1035                     p = skipspace(p);
1036                     if (*p) {
1037                         if (!looking_at(p, "*"))
1038                             bg_mask = parse_argb(&p);
1039
1040                         p = skipspace(p);
1041                         switch (*p | 0x20) {
1042                         case 'n':
1043                             shadow = SHADOW_NONE;
1044                             break;
1045                         case 's':
1046                             shadow = SHADOW_NORMAL;
1047                             break;
1048                         case 'a':
1049                             shadow = SHADOW_ALL;
1050                             break;
1051                         case 'r':
1052                             shadow = SHADOW_REVERSE;
1053                             break;
1054                         default:
1055                             /* go with default */
1056                             break;
1057                         }
1058                     }
1059                 }
1060                 set_msg_colors_global(m->color_table, fg_mask, bg_mask, shadow);
1061             } else if (looking_at(p, "separator")) {
1062                 record(m, &ld, append);
1063                 ld.label = refstr_get(empty_string);
1064                 ld.menuseparator = 1;
1065                 record(m, &ld, append);
1066             } else if (looking_at(p, "disable") || looking_at(p, "disabled")) {
1067                 ld.menudisabled = 1;
1068             } else if (looking_at(p, "indent")) {
1069                 ld.menuindent = atoi(skipspace(p + 6));
1070             } else if (looking_at(p, "begin")) {
1071                 record(m, &ld, append);
1072                 m = current_menu = begin_submenu(skipspace(p + 5));
1073             } else if (looking_at(p, "end")) {
1074                 record(m, &ld, append);
1075                 m = current_menu = end_submenu();
1076             } else if (looking_at(p, "quit")) {
1077                 if (ld.label)
1078                     ld.action = MA_QUIT;
1079             } else if (looking_at(p, "goto")) {
1080                 if (ld.label) {
1081                     ld.action = MA_GOTO_UNRES;
1082                     refstr_put(ld.kernel);
1083                     ld.kernel = refstrdup(skipspace(p + 4));
1084                 }
1085             } else if (looking_at(p, "exit")) {
1086                 p = skipspace(p + 4);
1087                 if (ld.label && m->parent) {
1088                     if (*p) {
1089                         /* This is really just a goto, except for the marker */
1090                         ld.action = MA_EXIT_UNRES;
1091                         refstr_put(ld.kernel);
1092                         ld.kernel = refstrdup(p);
1093                     } else {
1094                         ld.action = MA_EXIT;
1095                         ld.submenu = m->parent;
1096                     }
1097                 }
1098             } else if (looking_at(p, "start")) {
1099                 start_menu = m;
1100             } else {
1101                 /* Unknown, check for layout parameters */
1102                 enum parameter_number mp;
1103                 for (mp = 0; mp < NPARAMS; mp++) {
1104                     if ((ep = looking_at(p, mparm[mp].name))) {
1105                         m->mparm[mp] = atoi(skipspace(ep));
1106                         break;
1107                     }
1108                 }
1109             }
1110         }
1111         /* feng: menu handling end */
1112         else if (looking_at(p, "text")) {
1113
1114                 /* loop till we fined the "endtext" */
1115             enum text_cmd {
1116                 TEXT_UNKNOWN,
1117                 TEXT_HELP
1118             } cmd = TEXT_UNKNOWN;
1119             int len = ld.helptext ? strlen(ld.helptext) : 0;
1120             int xlen;
1121
1122             p = skipspace(p + 4);
1123
1124             if (looking_at(p, "help"))
1125                 cmd = TEXT_HELP;
1126
1127             while (fgets(line, sizeof line, f)) {
1128                 p = skipspace(line);
1129                 if (looking_at(p, "endtext"))
1130                     break;
1131
1132                 xlen = strlen(line);
1133
1134                 switch (cmd) {
1135                 case TEXT_UNKNOWN:
1136                     break;
1137                 case TEXT_HELP:
1138                     ld.helptext = realloc(ld.helptext, len + xlen + 1);
1139                     memcpy(ld.helptext + len, line, xlen + 1);
1140                     len += xlen;
1141                     break;
1142                 }
1143             }
1144         } else if ((ep = is_fkey(p, &fkeyno))) {
1145             p = skipspace(ep);
1146             if (m->fkeyhelp[fkeyno].textname) {
1147                 refstr_put(m->fkeyhelp[fkeyno].textname);
1148                 m->fkeyhelp[fkeyno].textname = NULL;
1149             }
1150             if (m->fkeyhelp[fkeyno].background) {
1151                 refstr_put(m->fkeyhelp[fkeyno].background);
1152                 m->fkeyhelp[fkeyno].background = NULL;
1153             }
1154
1155             refstr_put(m->fkeyhelp[fkeyno].textname);
1156             m->fkeyhelp[fkeyno].textname = refdup_word(&p);
1157             if (*p) {
1158                 p = skipspace(p);
1159                 m->fkeyhelp[fkeyno].background = refdup_word(&p);
1160             }
1161         } else if ((ep = looking_at(p, "include"))) {
1162             do_include(ep);
1163         } else if (looking_at(p, "append")) {
1164             const char *a = refstrdup(skipspace(p + 6));
1165             if (ld.label) {
1166                 refstr_put(ld.append);
1167                 ld.append = a;
1168             } else {
1169                 refstr_put(append);
1170                 append = a;
1171             }
1172             //dprintf("we got a append: %s", a);
1173         } else if (looking_at(p, "initrd")) {
1174             const char *a = refstrdup(skipspace(p + 6));
1175             if (ld.label) {
1176                 refstr_put(ld.initrd);
1177                 ld.initrd = a;
1178             } else {
1179                 /* Ignore */
1180             }
1181         } else if (looking_at(p, "label")) {
1182             p = skipspace(p + 5);
1183             /* when first time see "label", it will not really record anything */
1184             record(m, &ld, append);
1185             ld.label = __refdup_word(p, NULL);
1186             ld.kernel = __refdup_word(p, NULL);
1187             /* feng: this is the default type for all */
1188             ld.type = KT_KERNEL;
1189             ld.passwd = NULL;
1190             ld.append = NULL;
1191             ld.initrd = NULL;
1192             ld.menulabel = NULL;
1193             ld.helptext = NULL;
1194             ld.ipappend = SysAppends;
1195             ld.menudefault = ld.menuhide = ld.menuseparator =
1196                 ld.menudisabled = ld.menuindent = 0;
1197         } else if ((ep = is_kernel_type(p, &type))) {
1198             if (ld.label) {
1199                 refstr_put(ld.kernel);
1200                 ld.kernel = refstrdup(skipspace(ep));
1201                 ld.type = type;
1202                 //dprintf("got a kernel: %s, type = %d", ld.kernel, ld.type);
1203             }
1204         } else if (looking_at(p, "timeout")) {
1205             kbdtimeout = (atoi(skipspace(p + 7)) * CLK_TCK + 9) / 10;
1206         } else if (looking_at(p, "totaltimeout")) {
1207             totaltimeout = (atoll(skipspace(p + 13)) * CLK_TCK + 9) / 10;
1208         } else if (looking_at(p, "ontimeout")) {
1209             ontimeout = refstrdup(skipspace(p + 9));
1210             ontimeoutlen = strlen(ontimeout);
1211         } else if (looking_at(p, "allowoptions")) {
1212             allowoptions = !!atoi(skipspace(p + 12));
1213         } else if ((ep = looking_at(p, "ipappend")) ||
1214                    (ep = looking_at(p, "sysappend"))) {
1215             uint32_t s = strtoul(skipspace(ep), NULL, 0);
1216             if (ld.label)
1217                 ld.ipappend = s;
1218             else
1219                 SysAppends = s;
1220         } else if (looking_at(p, "default")) {
1221             /* default could be a kernel image or another label */
1222             refstr_put(globaldefault);
1223             globaldefault = refstrdup(skipspace(p + 7));
1224
1225             /*
1226              * On the chance that "default" is actually a kernel image
1227              * and not a label, store a copy of it, but only if we
1228              * haven't seen a "ui" command. "ui" commands take
1229              * precendence over "default" commands.
1230              */
1231             if (defaultlevel < LEVEL_UI) {
1232                 defaultlevel = LEVEL_DEFAULT;
1233                 refstr_put(default_cmd);
1234                 default_cmd = refstrdup(globaldefault);
1235             }
1236         } else if (looking_at(p, "ui")) {
1237             has_ui = 1;
1238             defaultlevel = LEVEL_UI;
1239             refstr_put(default_cmd);
1240             default_cmd = refstrdup(skipspace(p + 2));
1241         }
1242
1243         /*
1244          * subset 1:  pc_opencmd
1245          * display/font/kbdmap are rather similar, open a file then do sth
1246          */
1247         else if (looking_at(p, "display")) {
1248                 const char *filename;
1249                 char *dst = KernelName;
1250                 size_t len = FILENAME_MAX - 1;
1251
1252                 filename = refstrdup(skipspace(p + 7));
1253
1254                 while (len-- && not_whitespace(*filename))
1255                         *dst++ = *filename++;
1256                 *dst = '\0';
1257
1258                 get_msg_file(KernelName);
1259                 refstr_put(filename);
1260         } else if (looking_at(p, "font")) {
1261                 const char *filename;
1262                 char *dst = KernelName;
1263                 size_t len = FILENAME_MAX - 1;
1264
1265                 filename = refstrdup(skipspace(p + 4));
1266
1267                 while (len-- && not_whitespace(*filename))
1268                         *dst++ = *filename++;
1269                 *dst = '\0';
1270
1271                 loadfont(KernelName);
1272                 refstr_put(filename);
1273         } else if (looking_at(p, "kbdmap")) {
1274                 const char *filename;
1275
1276                 filename = refstrdup(skipspace(p + 6));
1277                 loadkeys(filename);
1278                 refstr_put(filename);
1279         }
1280         /*
1281          * subset 2:  pc_setint16
1282          * set a global flag
1283          */
1284         else if (looking_at(p, "implicit")) {
1285                 allowimplicit = atoi(skipspace(p + 8));
1286         } else if (looking_at(p, "prompt")) {
1287                 forceprompt = atoi(skipspace(p + 6));
1288         } else if (looking_at(p, "console")) {
1289                 DisplayCon = atoi(skipspace(p + 7));
1290         } else if (looking_at(p, "allowoptions")) {
1291                 allowoptions = atoi(skipspace(p + 12));
1292         } else if (looking_at(p, "noescape")) {
1293                 noescape = atoi(skipspace(p + 8));
1294         } else if (looking_at(p, "nocomplete")) {
1295                 nocomplete = atoi(skipspace(p + 10));
1296         } else if (looking_at(p, "nohalt")) {
1297                 NoHalt = atoi(skipspace(p + 8));
1298         } else if (looking_at(p, "onerror")) {
1299                 refstr_put(m->onerror);
1300                 m->onerror = refstrdup(skipspace(p + 7));
1301                 onerrorlen = strlen(m->onerror);
1302                 refstr_put(onerror);
1303                 onerror = refstrdup(m->onerror);
1304         }
1305
1306         else if (looking_at(p, "pxeretry"))
1307                 PXERetry = atoi(skipspace(p + 8));
1308
1309         /* serial setting, bps, flow control */
1310         else if (looking_at(p, "serial")) {
1311                 uint16_t port, flow;
1312                 uint32_t baud;
1313
1314                 p = skipspace(p + 6);
1315                 port = atoi(p);
1316
1317                 while (isalnum(*p))
1318                         p++;
1319                 p = skipspace(p);
1320
1321                 /* Default to no flow control */
1322                 FlowOutput = 0;
1323                 FlowInput = 0;
1324
1325                 baud = DEFAULT_BAUD;
1326                 if (isalnum(*p)) {
1327                         uint8_t ignore;
1328
1329                         /* setup baud */
1330                         baud = atoi(p);
1331                         while (isalnum(*p))
1332                                 p++;
1333                         p = skipspace(p);
1334
1335                         ignore = 0;
1336                         flow = 0;
1337                         if (isalnum(*p)) {
1338                                 /* flow control */
1339                                 flow = atoi(p);
1340                                 ignore = ((flow & 0x0F00) >> 4);
1341                         }
1342
1343                         FlowIgnore = ignore;
1344                         flow = ((flow & 0xff) << 8) | (flow & 0xff);
1345                         flow &= 0xF00B;
1346                         FlowOutput = (flow & 0xff);
1347                         FlowInput = ((flow & 0xff00) >> 8);
1348                 }
1349
1350                 /*
1351                  * Parse baud
1352                  */
1353                 if (baud < 75) {
1354                         /* < 75 baud == bogus */
1355                         SerialPort = 0;
1356                         continue;
1357                 }
1358
1359                 baud = BAUD_DIVISOR / baud;
1360                 baud &= 0xffff;
1361                 BaudDivisor = baud;
1362
1363                 port = get_serial_port(port);
1364                 SerialPort = port;
1365
1366                 /*
1367                  * Begin code to actually set up the serial port
1368                  */
1369                 sirq_cleanup_nowipe();
1370
1371                 outb(0x83, port + 3); /* Enable DLAB */
1372                 io_delay();
1373
1374                 outb((baud & 0xff), port); /* write divisor to LS */
1375                 io_delay();
1376
1377                 outb(((baud & 0xff00) >> 8), port + 1); /* write to MS */
1378                 io_delay();
1379
1380                 outb(0x03, port + 3); /* Disable DLAB */
1381                 io_delay();
1382
1383                 /*
1384                  * Read back LCR (detect missing hw). If nothing here
1385                  * we'll read 00 or FF.
1386                  */
1387                 if (inb(port + 3) != 0x03) {
1388                         /* Assume serial port busted */
1389                         SerialPort = 0;
1390                         continue;
1391                 }
1392
1393                 outb(0x01, port + 2); /* Enable FIFOs if present */
1394                 io_delay();
1395
1396                 /* Disable FIFO if unusable */
1397                 if (inb(port + 2) < 0x0C0) {
1398                         outb(0, port + 2);
1399                         io_delay();
1400                 }
1401
1402                 /* Assert bits in MCR */
1403                 outb(FlowOutput, port + 4);
1404                 io_delay();
1405
1406                 /* Enable interrupts if requested */
1407                 if (FlowOutput & 0x8)
1408                         sirq_install();
1409
1410                 /* Show some life */
1411                 if (SerialNotice != 0) {
1412                         SerialNotice = 0;
1413
1414                         write_serial_str(syslinux_banner);
1415                         write_serial_str(copyright_str);
1416                 }
1417
1418         } else if (looking_at(p, "say")) {
1419                 printf("%s\n", p+4);
1420         } else if (looking_at(p, "path")) {
1421                 if (parse_path(skipspace(p + 4)))
1422                         printf("Failed to parse PATH\n");
1423         } else if (looking_at(p, "sendcookies")) {
1424                 const union syslinux_derivative_info *sdi;
1425
1426                 p += strlen("sendcookies");
1427                 sdi = syslinux_derivative_info();
1428
1429                 if (sdi->c.filesystem == SYSLINUX_FS_PXELINUX) {
1430                         SendCookies = strtoul(skipspace(p), NULL, 10);
1431                         http_bake_cookies();
1432                 }
1433         }
1434     }
1435 }
1436
1437 static int parse_main_config(const char *filename)
1438 {
1439         const char *mode = "r";
1440         FILE *f;
1441         int fd;
1442
1443         if (!filename)
1444                 fd = open_config();
1445         else
1446                 fd = open(filename, O_RDONLY);
1447
1448         if (fd < 0)
1449                 return fd;
1450
1451         if (config_cwd[0]) {
1452                 if (chdir(config_cwd) < 0)
1453                         printf("Failed to chdir to %s\n", config_cwd);
1454                 config_cwd[0] = '\0';
1455         }
1456
1457         f = fdopen(fd, mode);
1458         parse_config_file(f);
1459
1460         /*
1461          * Update ConfigName so that syslinux_config_file() returns
1462          * the filename we just opened. filesystem-specific
1463          * open_config() implementations are expected to update
1464          * ConfigName themselves.
1465          */
1466         if (filename)
1467             strcpy(ConfigName, filename);
1468
1469         return 0;
1470 }
1471
1472 static void resolve_gotos(void)
1473 {
1474     struct menu_entry *me;
1475     struct menu *m;
1476
1477     for (me = all_entries; me; me = me->next) {
1478         if (me->action == MA_GOTO_UNRES || me->action == MA_EXIT_UNRES) {
1479             m = find_menu(me->cmdline);
1480             refstr_put(me->cmdline);
1481             me->cmdline = NULL;
1482             if (m) {
1483                 me->submenu = m;
1484                 me->action--;   /* Drop the _UNRES */
1485             } else {
1486                 me->action = MA_DISABLED;
1487             }
1488         }
1489     }
1490 }
1491
1492 void parse_configs(char **argv)
1493 {
1494     const char *filename;
1495     struct menu *m;
1496     struct menu_entry *me;
1497     dprintf("enter");
1498
1499     empty_string = refstrdup("");
1500
1501     /* feng: reset current menu_list and entry list */
1502     menu_list = NULL;
1503     all_entries = NULL;
1504
1505     /* Initialize defaults for the root and hidden menus */
1506     hide_menu = new_menu(NULL, NULL, refstrdup(".hidden"));
1507     root_menu = new_menu(NULL, NULL, refstrdup(".top"));
1508     start_menu = root_menu;
1509
1510     /* Other initialization */
1511     memset(&ld, 0, sizeof(struct labeldata));
1512
1513     /* Actually process the files */
1514     current_menu = root_menu;
1515
1516     if (!argv || !*argv) {
1517         if (parse_main_config(NULL) < 0) {
1518             printf("WARNING: No configuration file found\n");
1519             return;
1520         }
1521     } else {
1522         while ((filename = *argv++)) {
1523                 dprintf("Parsing config: %s", filename);
1524             parse_main_config(filename);
1525         }
1526     }
1527
1528     /* On final EOF process the last label statement */
1529     record(current_menu, &ld, append);
1530
1531     /* Common postprocessing */
1532     resolve_gotos();
1533
1534     /* Handle global default */
1535     //if (has_ui && globaldefault) {
1536     if (globaldefault) {
1537         dprintf("gloabldefault = %s", globaldefault);
1538         me = find_label(globaldefault);
1539         if (me && me->menu != hide_menu) {
1540             me->menu->defentry = me->entry;
1541             start_menu = me->menu;
1542             default_menu = me->menu;
1543         }
1544     }
1545
1546     /* If "menu save" is active, let the ADV override the global default */
1547     if (menusave) {
1548         size_t len;
1549         const char *lbl = syslinux_getadv(ADV_MENUSAVE, &len);
1550         char *lstr;
1551         if (lbl && len) {
1552             lstr = refstr_alloc(len);
1553             memcpy(lstr, lbl, len);     /* refstr_alloc() adds the final null */
1554             me = find_label(lstr);
1555             if (me && me->menu != hide_menu) {
1556                 me->menu->defentry = me->entry;
1557                 start_menu = me->menu;
1558             }
1559             refstr_put(lstr);
1560         }
1561     }
1562
1563     /* Final per-menu initialization, with all labels known */
1564     for (m = menu_list; m; m = m->next) {
1565         m->curentry = m->defentry;      /* All menus start at their defaults */
1566
1567         if (m->ontimeout)
1568             m->ontimeout = unlabel(m->ontimeout);
1569         if (m->onerror)
1570             m->onerror = unlabel(m->onerror);
1571     }
1572 }