source: bootcd/isolinux/syslinux-6.03/com32/elflink/ldlinux/readconfig.c

/* ----------------------------------------------------------------------- *
 *
 *   Copyright 2004-2009 H. Peter Anvin - All Rights Reserved
 *   Copyright 2009-2013 Intel Corporation; author: H. Peter Anvin
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 *   Boston MA 02110-1301, USA; either version 2 of the License, or
 *   (at your option) any later version; incorporated herein by reference.
 *
 * ----------------------------------------------------------------------- */

#include <sys/io.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <minmax.h>
#include <alloca.h>
#include <inttypes.h>
#include <colortbl.h>
#include <com32.h>
#include <syslinux/adv.h>
#include <syslinux/config.h>
#include <dprintf.h>
#include <ctype.h>
#include <bios.h>
#include <core.h>
#include <fs.h>
#include <syslinux/pxe_api.h>

#include "menu.h"
#include "config.h"
#include "getkey.h"
#include "core.h"
#include "fs.h"

const struct menu_parameter mparm[NPARAMS] = {
    [P_WIDTH] = {"width", 0},
    [P_MARGIN] = {"margin", 10},
    [P_PASSWD_MARGIN] = {"passwordmargin", 3},
    [P_MENU_ROWS] = {"rows", 12},
    [P_TABMSG_ROW] = {"tabmsgrow", 18},
    [P_CMDLINE_ROW] = {"cmdlinerow", 18},
    [P_END_ROW] = {"endrow", -1},
    [P_PASSWD_ROW] = {"passwordrow", 11},
    [P_TIMEOUT_ROW] = {"timeoutrow", 20},
    [P_HELPMSG_ROW] = {"helpmsgrow", 22},
    [P_HELPMSGEND_ROW] = {"helpmsgendrow", -1},
    [P_HSHIFT] = {"hshift", 0},
    [P_VSHIFT] = {"vshift", 0},
    [P_HIDDEN_ROW] = {"hiddenrow", -2},
};

/* Must match enum kernel_type */
static const char *const kernel_types[] = {
    "none",
    "localboot",
    "kernel",
    "linux",
    "boot",
    "bss",
    "pxe",
    "fdimage",
    "comboot",
    "com32",
    "config",
    NULL
};

short uappendlen = 0;           //bytes in append= command
short ontimeoutlen = 0;         //bytes in ontimeout command
short onerrorlen = 0;           //bytes in onerror command
short forceprompt = 0;          //force prompt
short noescape = 0;             //no escape
short nocomplete = 0;           //no label completion on TAB key
short allowimplicit = 1;        //allow implicit kernels
short allowoptions = 1;         //user-specified options allowed
short includelevel = 1;         //nesting level
short defaultlevel = 0;         //the current level of default
short vkernel = 0;              //have we seen any "label" statements?
extern short NoHalt;            //idle.c

const char *onerror = NULL;     //"onerror" command line
const char *ontimeout = NULL;   //"ontimeout" command line

__export const char *default_cmd = NULL;        //"default" command line

/* Empty refstring */
const char *empty_string;

/* Root menu, starting menu, hidden menu, and list of all menus */
struct menu *root_menu, *start_menu, *hide_menu, *menu_list, *default_menu;

/* These are global parameters regardless of which menu we're displaying */
int shiftkey = 0;               /* Only display menu if shift key pressed */
int hiddenmenu = 0;
long long totaltimeout = 0;
unsigned int kbdtimeout = 0;

/* Keep track of global default */
static int has_ui = 0;          /* DEFAULT only counts if UI is found */
extern const char *globaldefault;
static bool menusave = false;   /* True if there is any "menu save" */

/* Linked list of all entires, hidden or not; used by unlabel() */
static struct menu_entry *all_entries;
static struct menu_entry **all_entries_end = &all_entries;

static const struct messages messages[MSG_COUNT] = {
    [MSG_AUTOBOOT] = {"autoboot", "Automatic boot in # second{,s}..."},
    [MSG_TAB] = {"tabmsg", "Press [Tab] to edit options"},
    [MSG_NOTAB] = {"notabmsg", ""},
    [MSG_PASSPROMPT] = {"passprompt", "Password required"},
};

#define astrdup(x) ({ char *__x = (x); \
                      size_t __n = strlen(__x) + 1; \
                      char *__p = alloca(__n); \
                      if ( __p ) memcpy(__p, __x, __n); \
                      __p; })

/*
 * Search the list of all menus for a specific label
 */
static struct menu *find_menu(const char *label)
{
    struct menu *m;

    for (m = menu_list; m; m = m->next) {
        if (!strcmp(label, m->label))
            return m;
    }

    return NULL;
}

#define MAX_LINE 4096

/* Strip ^ from a string, returning a new reference to the same refstring
   if none present */
static const char *strip_caret(const char *str)
{
    const char *p, *r;
    char *q;
    int carets = 0;

    p = str;
    for (;;) {
        p = strchr(p, '^');
        if (!p)
            break;
        carets++;
        p++;
    }

    if (!carets)
        return refstr_get(str);

    r = q = refstr_alloc(strlen(str) - carets);
    for (p = str; *p; p++)
        if (*p != '^')
            *q++ = *p;

    *q = '\0';                  /* refstr_alloc() already did this... */

    return r;
}

/* Check to see if we are at a certain keyword (case insensitive) */
/* Returns a pointer to the first character past the keyword */
static char *looking_at(char *line, const char *kwd)
{
    char *p = line;
    const char *q = kwd;

    while (*p && *q && ((*p ^ *q) & ~0x20) == 0) {
        p++;
        q++;
    }

    if (*q)
        return NULL;            /* Didn't see the keyword */

    return my_isspace(*p) ? p : NULL;   /* Must be EOL or whitespace */
}

static struct menu *new_menu(struct menu *parent,
                             struct menu_entry *parent_entry, const char *label)
{
    struct menu *m = calloc(1, sizeof(struct menu));
    int i;
        
        //dprintf("enter: menu_label = %s", label);

    m->label = label;
    m->title = refstr_get(empty_string);

    if (parent) {
        /* Submenu */
        m->parent = parent;
        m->parent_entry = parent_entry;
        parent_entry->action = MA_SUBMENU;
        parent_entry->submenu = m;

        for (i = 0; i < MSG_COUNT; i++)
            m->messages[i] = refstr_get(parent->messages[i]);

        memcpy(m->mparm, parent->mparm, sizeof m->mparm);

        m->allowedit = parent->allowedit;
        m->timeout = parent->timeout;
        m->save = parent->save;

        m->ontimeout = refstr_get(parent->ontimeout);
        m->onerror = refstr_get(parent->onerror);
        m->menu_master_passwd = refstr_get(parent->menu_master_passwd);
        m->menu_background = refstr_get(parent->menu_background);

        m->color_table = copy_color_table(parent->color_table);

        for (i = 0; i < 12; i++) {
            m->fkeyhelp[i].textname = refstr_get(parent->fkeyhelp[i].textname);
            m->fkeyhelp[i].background =
                refstr_get(parent->fkeyhelp[i].background);
        }
    } else {
        /* Root menu */
        for (i = 0; i < MSG_COUNT; i++)
            m->messages[i] = refstrdup(messages[i].defmsg);
        for (i = 0; i < NPARAMS; i++)
            m->mparm[i] = mparm[i].value;

        m->allowedit = true;    /* Allow edits of the command line */
        m->color_table = default_color_table();
    }

    m->next = menu_list;
    menu_list = m;

    return m;
}

struct labeldata {
    const char *label;
    const char *kernel;
    enum kernel_type type;
    const char *append;
    const char *initrd;
    const char *menulabel;
    const char *passwd;
    char *helptext;
    unsigned int ipappend;
    unsigned int menuhide;
    unsigned int menudefault;
    unsigned int menuseparator;
    unsigned int menudisabled;
    unsigned int menuindent;
    enum menu_action action;
    int save;
    struct menu *submenu;
};

/* Menu currently being parsed */
static struct menu *current_menu;

static void clear_label_data(struct labeldata *ld)
{
    refstr_put(ld->label);
    refstr_put(ld->kernel);
    refstr_put(ld->append);
    refstr_put(ld->initrd);
    refstr_put(ld->menulabel);
    refstr_put(ld->passwd);

    memset(ld, 0, sizeof *ld);
}

static struct menu_entry *new_entry(struct menu *m)
{
    struct menu_entry *me;

    //dprintf("enter, call from menu %s", m->label);

    if (m->nentries >= m->nentries_space) {
        if (!m->nentries_space)
            m->nentries_space = 1;
        else
            m->nentries_space <<= 1;

        m->menu_entries = realloc(m->menu_entries, m->nentries_space *
                                  sizeof(struct menu_entry *));
    }

    me = calloc(1, sizeof(struct menu_entry));
    me->menu = m;
    me->entry = m->nentries;
    m->menu_entries[m->nentries++] = me;
    *all_entries_end = me;
    all_entries_end = &me->next;

    return me;
}

static void consider_for_hotkey(struct menu *m, struct menu_entry *me)
{
    const char *p = strchr(me->displayname, '^');

    if (me->action != MA_DISABLED) {
        if (p && p[1]) {
            unsigned char hotkey = p[1] & ~0x20;
            if (!m->menu_hotkeys[hotkey]) {
                me->hotkey = hotkey;
                m->menu_hotkeys[hotkey] = me;
            }
        }
    }
}

/*
 * Copy a string, converting whitespace characters to underscores
 * and compacting them.  Return a pointer to the final null.
 */
static char *copy_sysappend_string(char *dst, const char *src)
{
    bool was_space = true;      /* Kill leading whitespace */
    char *end = dst;
    char c;

    while ((c = *src++)) {
        if (c <= ' ' && c == '\x7f') {
            if (!was_space)
                *dst++ = '_';
            was_space = true;
        } else {
            *dst++ = c;
            end = dst;
            was_space = false;
        }
    }
    *end = '\0';
    return end;
}

static void record(struct menu *m, struct labeldata *ld, const char *append)
{
        int i;
        struct menu_entry *me;
        const struct syslinux_ipappend_strings *ipappend;

        if (!ld->label)
                return;                 /* Nothing defined */

        /* Hidden entries are recorded on a special "hidden menu" */
        if (ld->menuhide)
                m = hide_menu;

        char ipoptions[4096], *ipp;
        const char *a;
        char *s;

        me = new_entry(m);

        me->displayname = ld->menulabel
            ? refstr_get(ld->menulabel) : refstr_get(ld->label);
        me->label = refstr_get(ld->label);
        me->passwd = refstr_get(ld->passwd);
        me->helptext = ld->helptext;
        me->hotkey = 0;
        me->action = ld->action ? ld->action : MA_CMD;
        me->save = ld->save ? (ld->save > 0) : m->save;

        if (ld->menuindent) {
            const char *dn;

            rsprintf(&dn, "%*s%s", ld->menuindent, "", me->displayname);
            refstr_put(me->displayname);
            me->displayname = dn;
        }

        if (ld->menuseparator) {
            refstr_put(me->displayname);
            me->displayname = refstr_get(empty_string);
        }

        if (ld->menuseparator || ld->menudisabled) {
            me->action = MA_DISABLED;
            refstr_put(me->label);
            me->label = NULL;
            refstr_put(me->passwd);
            me->passwd = NULL;
        }

        if (ld->menulabel)
            consider_for_hotkey(m, me);

        switch (me->action) {
        case MA_CMD:
            ipp = ipoptions;
            *ipp = '\0';

            if (ld->initrd)
                ipp += sprintf(ipp, " initrd=%s", ld->initrd);

            if (ld->ipappend) {
                ipappend = syslinux_ipappend_strings();
                for (i = 0; i < ipappend->count; i++) {
                    if ((ld->ipappend & (1U << i)) &&
                        ipappend->ptr[i] && ipappend->ptr[i][0]) {
                        *ipp++ = ' ';
                        ipp = copy_sysappend_string(ipp, ipappend->ptr[i]);
                    }
                }
            }

            a = ld->append;
            if (!a)
                a = append;
            if (!a || (a[0] == '-' && !a[1]))
                a = "";
            s = a[0] ? " " : "";

            if (ld->type == KT_KERNEL)
                rsprintf(&me->cmdline, "%s%s%s%s", ld->kernel, s, a, ipoptions);
            else
                rsprintf(&me->cmdline, ".%s %s%s%s%s",
                         kernel_types[ld->type], ld->kernel, s, a, ipoptions);
                dprintf("type = %s, cmd = %s", kernel_types[ld->type], me->cmdline);
            break;

        case MA_GOTO_UNRES:
        case MA_EXIT_UNRES:
            me->cmdline = refstr_get(ld->kernel);
            break;

        case MA_GOTO:
        case MA_EXIT:
            me->submenu = ld->submenu;
            break;

        default:
            break;
        }

        if (ld->menudefault && me->action == MA_CMD)
            m->defentry = m->nentries - 1;

    clear_label_data(ld);
}

static struct menu *begin_submenu(const char *tag)
{
    struct menu_entry *me;

    if (!tag[0])
        tag = NULL;

    me = new_entry(current_menu);
    me->displayname = refstrdup(tag);
    return new_menu(current_menu, me, refstr_get(me->displayname));
}

static struct menu *end_submenu(void)
{
    return current_menu->parent ? current_menu->parent : current_menu;
}

void print_labels(const char *prefix, size_t len)
{
    struct menu_entry *me;

    printf("\n");
    for (me = all_entries; me; me = me->next ) {
        if (!me->label)
            continue;

        if (!strncmp(prefix, me->label, len))
            printf(" %s", me->label);
    }
    printf("\n");
}

struct menu_entry *find_label(const char *str)
{
    const char *p;
    struct menu_entry *me;
    int pos;

    p = str;
    while (*p && !my_isspace(*p))
        p++;

    /* p now points to the first byte beyond the kernel name */
    pos = p - str;

    for (me = all_entries; me; me = me->next) {
        if (!strncmp(str, me->label, pos) && !me->label[pos])
            return me;
    }

    return NULL;
}

static const char *unlabel(const char *str)
{
    /* Convert a CLI-style command line to an executable command line */
    const char *p;
    const char *q;
    struct menu_entry *me;
    int pos;

    p = str;
    while (*p && !my_isspace(*p))
        p++;

    /* p now points to the first byte beyond the kernel name */
    pos = p - str;

    for (me = all_entries; me; me = me->next) {
        if (!strncmp(str, me->label, pos) && !me->label[pos]) {
            /* Found matching label */
            rsprintf(&q, "%s%s", me->cmdline, p);
            refstr_put(str);
            return q;
        }
    }

    return str;
}

static const char *__refdup_word(char *p, char **ref)
{
    char *sp = p;
    char *ep = sp;

    while (*ep && !my_isspace(*ep))
        ep++;

    if (ref)
        *ref = ep;
    return refstrndup(sp, ep - sp);
}

static const char *refdup_word(char **p)
{
    return __refdup_word(*p, p);
}

int my_isxdigit(char c)
{
    unsigned int uc = c;

    return (uc - '0') < 10 || ((uc | 0x20) - 'a') < 6;
}

unsigned int hexval(char c)
{
    unsigned char uc = c | 0x20;
    unsigned int v;

    v = uc - '0';
    if (v < 10)
        return v;

    return uc - 'a' + 10;
}

unsigned int hexval2(const char *p)
{
    return (hexval(p[0]) << 4) + hexval(p[1]);
}

uint32_t parse_argb(char **p)
{
    char *sp = *p;
    char *ep;
    uint32_t argb;
    size_t len, dl;

    if (*sp == '#')
        sp++;

    ep = sp;

    while (my_isxdigit(*ep))
        ep++;

    *p = ep;
    len = ep - sp;

    switch (len) {
    case 3:                     /* #rgb */
        argb =
            0xff000000 +
            (hexval(sp[0]) * 0x11 << 16) +
            (hexval(sp[1]) * 0x11 << 8) + (hexval(sp[2]) * 0x11);
        break;
    case 4:                     /* #argb */
        argb =
            (hexval(sp[0]) * 0x11 << 24) +
            (hexval(sp[1]) * 0x11 << 16) +
            (hexval(sp[2]) * 0x11 << 8) + (hexval(sp[3]) * 0x11);
        break;
    case 6:                     /* #rrggbb */
    case 9:                     /* #rrrgggbbb */
    case 12:                    /* #rrrrggggbbbb */
        dl = len / 3;
        argb =
            0xff000000 +
            (hexval2(sp + 0) << 16) +
            (hexval2(sp + dl) << 8) + hexval2(sp + dl * 2);
        break;
    case 8:                     /* #aarrggbb */
        /* #aaarrrgggbbb is indistinguishable from #rrrrggggbbbb,
           assume the latter is a more common format */
    case 16:                    /* #aaaarrrrggggbbbb */
        dl = len / 4;
        argb =
            (hexval2(sp + 0) << 24) +
            (hexval2(sp + dl) << 16) +
            (hexval2(sp + dl * 2) << 8) + hexval2(sp + dl * 3);
        break;
    default:
        argb = 0xffff0000;      /* Bright red (error indication) */
        break;
    }

    return argb;
}

/*
 * Parser state.  This is global so that including multiple
 * files work as expected, which is that everything works the
 * same way as if the files had been concatenated together.
 */
//static const char *append = NULL;
extern const char *append;
extern uint16_t PXERetry;
static struct labeldata ld;

static int parse_main_config(const char *filename);

static char *is_kernel_type(char *cmdstr, enum kernel_type *type)
{
    const char *const *p;
    char *q;
    enum kernel_type t = KT_NONE;

    for (p = kernel_types; *p; p++, t++) {
        if ((q = looking_at(cmdstr, *p))) {
            *type = t;
            return q;
        }
    }

    return NULL;
}

static char *is_message_name(char *cmdstr, enum message_number *msgnr)
{
    char *q;
    enum message_number i;

    for (i = 0; i < MSG_COUNT; i++) {
        if ((q = looking_at(cmdstr, messages[i].name))) {
            *msgnr = i;
            return q;
        }
    }

    return NULL;
}

extern void get_msg_file(char *);

void cat_help_file(int key)
{
        struct menu *cm = current_menu;
        int fkey;

        switch (key) {
        case KEY_F1:
                fkey = 0;
                break;
        case KEY_F2:
                fkey = 1;
                break;
        case KEY_F3:
                fkey = 2;
                break;
        case KEY_F4:
                fkey = 3;
                break;
        case KEY_F5:
                fkey = 4;
                break;
        case KEY_F6:
                fkey = 5;
                break;
        case KEY_F7:
                fkey = 6;
                break;
        case KEY_F8:
                fkey = 7;
                break;
        case KEY_F9:
                fkey = 8;
                break;
        case KEY_F10:
                fkey = 9;
                break;
        case KEY_F11:
                fkey = 10;
                break;
        case KEY_F12:
                fkey = 11;
                break;
        default:
                fkey = -1;
                break;
        }

        if (fkey == -1)
                return;

        if (cm->fkeyhelp[fkey].textname) {
                printf("\n");
                get_msg_file((char *)cm->fkeyhelp[fkey].textname);
        }
}

static char *is_fkey(char *cmdstr, int *fkeyno)
{
    char *q;
    int no;

    if ((cmdstr[0] | 0x20) != 'f')
        return NULL;

    no = strtoul(cmdstr + 1, &q, 10);
    if (!my_isspace(*q))
        return NULL;

    if (no < 0 || no > 12)
        return NULL;

    *fkeyno = (no == 0) ? 10 : no - 1;
    return q;
}

extern uint8_t FlowIgnore;
extern uint8_t FlowInput;
extern uint8_t FlowOutput;
extern uint16_t SerialPort;
extern uint16_t BaudDivisor;
static uint8_t SerialNotice = 1;

#define DEFAULT_BAUD    9600
#define BAUD_DIVISOR    115200

extern void sirq_cleanup_nowipe(void);
extern void sirq_install(void);
extern void write_serial_str(char *);

extern void loadfont(const char *);
extern void loadkeys(const char *);

extern char syslinux_banner[];
extern char copyright_str[];

/*
 * PATH-based lookup
 *
 * Each entry in the PATH directive is separated by a colon, e.g.
 *
 *     PATH /bar:/bin/foo:/baz/bar/bin
 */
static int parse_path(char *p)
{
    struct path_entry *entry;
    const char *str;

    while (*p) {
        char *c = p;

        /* Find the next directory */
        while (*c && *c != ':')
            c++;

        str = refstrndup(p, c - p);
        if (!str)
            goto bail;

        entry = path_add(str);
        refstr_put(str);

        if (!entry)
            goto bail;

        if (!*c++)
            break;
        p = c;
    }

    return 0;

bail:
    return -1;
}

static void parse_config_file(FILE * f);

static void do_include_menu(char *str, struct menu *m)
{
    const char *file;
    char *p;
    FILE *f;
    int fd;

    p = skipspace(str);
    file = refdup_word(&p);
    p = skipspace(p);

    fd = open(file, O_RDONLY);
    if (fd < 0)
        goto put;

    f = fdopen(fd, "r");
    if (!f)
        goto bail;

    if (*p) {
        record(m, &ld, append);
        m = current_menu = begin_submenu(p);
    }

    parse_config_file(f);

    if (*p) {
        record(m, &ld, append);
        m = current_menu = end_submenu();
    }

bail:
    close(fd);
put:
    refstr_put(file);

}

static void do_include(char *str)
{
    const char *file;
    char *p;
    FILE *f;
    int fd;

    p = skipspace(str);
    file = refdup_word(&p);

    fd = open(file, O_RDONLY);
    if (fd < 0)
        goto put;

    f = fdopen(fd, "r");
    if (f)
        parse_config_file(f);

    close(fd);
put:
    refstr_put(file);
}

static void parse_config_file(FILE * f)
{
    char line[MAX_LINE], *p, *ep, ch;
    enum kernel_type type;
    enum message_number msgnr;
    int fkeyno;
    struct menu *m = current_menu;

    while (fgets(line, sizeof line, f)) {
        p = strchr(line, '\r');
        if (p)
            *p = '\0';
        p = strchr(line, '\n');
        if (p)
            *p = '\0';

        p = skipspace(line);

        if (looking_at(p, "menu")) {

            p = skipspace(p + 4);

            if (looking_at(p, "label")) {
                        if (ld.label) {
                                refstr_put(ld.menulabel);
                                ld.menulabel = refstrdup(skipspace(p + 5));
                        } else if (m->parent_entry) {
                                refstr_put(m->parent_entry->displayname);
                                m->parent_entry->displayname = refstrdup(skipspace(p + 5));
                                consider_for_hotkey(m->parent, m->parent_entry);
                                if (!m->title[0]) {
                                /* MENU LABEL -> MENU TITLE on submenu */
                                refstr_put(m->title);
                                m->title = strip_caret(m->parent_entry->displayname);
                                }
                        }
                        } else if (looking_at(p, "title")) {
                        refstr_put(m->title);
                        m->title = refstrdup(skipspace(p + 5));
                        if (m->parent_entry) {
                                /* MENU TITLE -> MENU LABEL on submenu */
                                if (m->parent_entry->displayname == m->label) {
                                refstr_put(m->parent_entry->displayname);
                                m->parent_entry->displayname = refstr_get(m->title);
                                }
                        }
            } else if (looking_at(p, "default")) {
                if (ld.label) {
                    ld.menudefault = 1;
                } else if (m->parent_entry) {
                    m->parent->defentry = m->parent_entry->entry;
                }
            } else if (looking_at(p, "hide")) {
                ld.menuhide = 1;
            } else if (looking_at(p, "passwd")) {
                if (ld.label) {
                    refstr_put(ld.passwd);
                    ld.passwd = refstrdup(skipspace(p + 6));
                } else if (m->parent_entry) {
                    refstr_put(m->parent_entry->passwd);
                    m->parent_entry->passwd = refstrdup(skipspace(p + 6));
                }
            } else if (looking_at(p, "shiftkey")) {
                shiftkey = 1;
            } else if (looking_at(p, "save")) {
                menusave = true;
                if (ld.label)
                    ld.save = 1;
                else
                    m->save = true;
            } else if (looking_at(p, "nosave")) {
                if (ld.label)
                    ld.save = -1;
                else
                    m->save = false;
            } else if (looking_at(p, "onerror")) {
                refstr_put(m->onerror);
                m->onerror = refstrdup(skipspace(p + 7));
                onerrorlen = strlen(m->onerror);
                refstr_put(onerror);
                onerror = refstrdup(m->onerror);
            } else if (looking_at(p, "master")) {
                p = skipspace(p + 6);
                if (looking_at(p, "passwd")) {
                    refstr_put(m->menu_master_passwd);
                    m->menu_master_passwd = refstrdup(skipspace(p + 6));
                }
            } else if ((ep = looking_at(p, "include"))) {
                do_include_menu(ep, m);
            } else if ((ep = looking_at(p, "background"))) {
                p = skipspace(ep);
                refstr_put(m->menu_background);
                m->menu_background = refdup_word(&p);
            } else if ((ep = looking_at(p, "hidden"))) {
                hiddenmenu = 1;
            } else if ((ep = is_message_name(p, &msgnr))) {
                refstr_put(m->messages[msgnr]);
                m->messages[msgnr] = refstrdup(skipspace(ep));
            } else if ((ep = looking_at(p, "color")) ||
                       (ep = looking_at(p, "colour"))) {
                int i;
                struct color_table *cptr;
                p = skipspace(ep);
                cptr = m->color_table;
                for (i = 0; i < menu_color_table_size; i++) {
                    if ((ep = looking_at(p, cptr->name))) {
                        p = skipspace(ep);
                        if (*p) {
                            if (looking_at(p, "*")) {
                                p++;
                            } else {
                                refstr_put(cptr->ansi);
                                cptr->ansi = refdup_word(&p);
                            }

                            p = skipspace(p);
                            if (*p) {
                                if (looking_at(p, "*"))
                                    p++;
                                else
                                    cptr->argb_fg = parse_argb(&p);

                                p = skipspace(p);
                                if (*p) {
                                    if (looking_at(p, "*"))
                                        p++;
                                    else
                                        cptr->argb_bg = parse_argb(&p);

                                    /* Parse a shadow mode */
                                    p = skipspace(p);
                                    ch = *p | 0x20;
                                    if (ch == 'n')      /* none */
                                        cptr->shadow = SHADOW_NONE;
                                    else if (ch == 's') /* std, standard */
                                        cptr->shadow = SHADOW_NORMAL;
                                    else if (ch == 'a') /* all */
                                        cptr->shadow = SHADOW_ALL;
                                    else if (ch == 'r') /* rev, reverse */
                                        cptr->shadow = SHADOW_REVERSE;
                                }
                            }
                        }
                        break;
                    }
                    cptr++;
                }
            } else if ((ep = looking_at(p, "msgcolor")) ||
                       (ep = looking_at(p, "msgcolour"))) {
                unsigned int fg_mask = MSG_COLORS_DEF_FG;
                unsigned int bg_mask = MSG_COLORS_DEF_BG;
                enum color_table_shadow shadow = MSG_COLORS_DEF_SHADOW;

                p = skipspace(ep);
                if (*p) {
                    if (!looking_at(p, "*"))
                        fg_mask = parse_argb(&p);

                    p = skipspace(p);
                    if (*p) {
                        if (!looking_at(p, "*"))
                            bg_mask = parse_argb(&p);

                        p = skipspace(p);
                        switch (*p | 0x20) {
                        case 'n':
                            shadow = SHADOW_NONE;
                            break;
                        case 's':
                            shadow = SHADOW_NORMAL;
                            break;
                        case 'a':
                            shadow = SHADOW_ALL;
                            break;
                        case 'r':
                            shadow = SHADOW_REVERSE;
                            break;
                        default:
                            /* go with default */
                            break;
                        }
                    }
                }
                set_msg_colors_global(m->color_table, fg_mask, bg_mask, shadow);
            } else if (looking_at(p, "separator")) {
                record(m, &ld, append);
                ld.label = refstr_get(empty_string);
                ld.menuseparator = 1;
                record(m, &ld, append);
            } else if (looking_at(p, "disable") || looking_at(p, "disabled")) {
                ld.menudisabled = 1;
            } else if (looking_at(p, "indent")) {
                ld.menuindent = atoi(skipspace(p + 6));
            } else if (looking_at(p, "begin")) {
                record(m, &ld, append);
                m = current_menu = begin_submenu(skipspace(p + 5));
            } else if (looking_at(p, "end")) {
                record(m, &ld, append);
                m = current_menu = end_submenu();
            } else if (looking_at(p, "quit")) {
                if (ld.label)
                    ld.action = MA_QUIT;
            } else if (looking_at(p, "goto")) {
                if (ld.label) {
                    ld.action = MA_GOTO_UNRES;
                    refstr_put(ld.kernel);
                    ld.kernel = refstrdup(skipspace(p + 4));
                }
            } else if (looking_at(p, "exit")) {
                p = skipspace(p + 4);
                if (ld.label && m->parent) {
                    if (*p) {
                        /* This is really just a goto, except for the marker */
                        ld.action = MA_EXIT_UNRES;
                        refstr_put(ld.kernel);
                        ld.kernel = refstrdup(p);
                    } else {
                        ld.action = MA_EXIT;
                        ld.submenu = m->parent;
                    }
                }
            } else if (looking_at(p, "start")) {
                start_menu = m;
            } else {
                /* Unknown, check for layout parameters */
                enum parameter_number mp;
                for (mp = 0; mp < NPARAMS; mp++) {
                    if ((ep = looking_at(p, mparm[mp].name))) {
                        m->mparm[mp] = atoi(skipspace(ep));
                        break;
                    }
                }
            }
        }
        /* feng: menu handling end */   
        else if (looking_at(p, "text")) {

                /* loop till we fined the "endtext" */
            enum text_cmd {
                TEXT_UNKNOWN,
                TEXT_HELP
            } cmd = TEXT_UNKNOWN;
            int len = ld.helptext ? strlen(ld.helptext) : 0;
            int xlen;

            p = skipspace(p + 4);

            if (looking_at(p, "help"))
                cmd = TEXT_HELP;

            while (fgets(line, sizeof line, f)) {
                p = skipspace(line);
                if (looking_at(p, "endtext"))
                    break;

                xlen = strlen(line);

                switch (cmd) {
                case TEXT_UNKNOWN:
                    break;
                case TEXT_HELP:
                    ld.helptext = realloc(ld.helptext, len + xlen + 1);
                    memcpy(ld.helptext + len, line, xlen + 1);
                    len += xlen;
                    break;
                }
            }
        } else if ((ep = is_fkey(p, &fkeyno))) {
            p = skipspace(ep);
            if (m->fkeyhelp[fkeyno].textname) {
                refstr_put(m->fkeyhelp[fkeyno].textname);
                m->fkeyhelp[fkeyno].textname = NULL;
            }
            if (m->fkeyhelp[fkeyno].background) {
                refstr_put(m->fkeyhelp[fkeyno].background);
                m->fkeyhelp[fkeyno].background = NULL;
            }

            refstr_put(m->fkeyhelp[fkeyno].textname);
            m->fkeyhelp[fkeyno].textname = refdup_word(&p);
            if (*p) {
                p = skipspace(p);
                m->fkeyhelp[fkeyno].background = refdup_word(&p);
            }
        } else if ((ep = looking_at(p, "include"))) {
            do_include(ep);
        } else if (looking_at(p, "append")) {
            const char *a = refstrdup(skipspace(p + 6));
            if (ld.label) {
                refstr_put(ld.append);
                ld.append = a;
            } else {
                refstr_put(append);
                append = a;
            }
            //dprintf("we got a append: %s", a);
        } else if (looking_at(p, "initrd")) {
            const char *a = refstrdup(skipspace(p + 6));
            if (ld.label) {
                refstr_put(ld.initrd);
                ld.initrd = a;
            } else {
                /* Ignore */
            }
        } else if (looking_at(p, "label")) {
            p = skipspace(p + 5);
            /* when first time see "label", it will not really record anything */
            record(m, &ld, append);
            ld.label = __refdup_word(p, NULL);
            ld.kernel = __refdup_word(p, NULL);
            /* feng: this is the default type for all */
            ld.type = KT_KERNEL;
            ld.passwd = NULL;
            ld.append = NULL;
            ld.initrd = NULL;
            ld.menulabel = NULL;
            ld.helptext = NULL;
            ld.ipappend = SysAppends;
            ld.menudefault = ld.menuhide = ld.menuseparator =
                ld.menudisabled = ld.menuindent = 0;
        } else if ((ep = is_kernel_type(p, &type))) {
            if (ld.label) {
                refstr_put(ld.kernel);
                ld.kernel = refstrdup(skipspace(ep));
                ld.type = type;
                //dprintf("got a kernel: %s, type = %d", ld.kernel, ld.type);
            }
        } else if (looking_at(p, "timeout")) {
            kbdtimeout = (atoi(skipspace(p + 7)) * CLK_TCK + 9) / 10;
        } else if (looking_at(p, "totaltimeout")) {
            totaltimeout = (atoll(skipspace(p + 13)) * CLK_TCK + 9) / 10;
        } else if (looking_at(p, "ontimeout")) {
            ontimeout = refstrdup(skipspace(p + 9));
            ontimeoutlen = strlen(ontimeout);
        } else if (looking_at(p, "allowoptions")) {
            allowoptions = !!atoi(skipspace(p + 12));
        } else if ((ep = looking_at(p, "ipappend")) ||
                   (ep = looking_at(p, "sysappend"))) {
            uint32_t s = strtoul(skipspace(ep), NULL, 0);
            if (ld.label)
                ld.ipappend = s;
            else
                SysAppends = s;
        } else if (looking_at(p, "default")) {
            /* default could be a kernel image or another label */
            refstr_put(globaldefault);
            globaldefault = refstrdup(skipspace(p + 7));

            /*
             * On the chance that "default" is actually a kernel image
             * and not a label, store a copy of it, but only if we
             * haven't seen a "ui" command. "ui" commands take
             * precendence over "default" commands.
             */
            if (defaultlevel < LEVEL_UI) {
                defaultlevel = LEVEL_DEFAULT;
                refstr_put(default_cmd);
                default_cmd = refstrdup(globaldefault);
            }
        } else if (looking_at(p, "ui")) {
            has_ui = 1;
            defaultlevel = LEVEL_UI;
            refstr_put(default_cmd);
            default_cmd = refstrdup(skipspace(p + 2));
        }
        
        /*
         * subset 1:  pc_opencmd 
         * display/font/kbdmap are rather similar, open a file then do sth
         */
        else if (looking_at(p, "display")) {
                const char *filename;
                char *dst = KernelName;
                size_t len = FILENAME_MAX - 1;

                filename = refstrdup(skipspace(p + 7));

                while (len-- && not_whitespace(*filename))
                        *dst++ = *filename++;
                *dst = '\0';

                get_msg_file(KernelName);
                refstr_put(filename);
        } else if (looking_at(p, "font")) {
                const char *filename;
                char *dst = KernelName;
                size_t len = FILENAME_MAX - 1;

                filename = refstrdup(skipspace(p + 4));

                while (len-- && not_whitespace(*filename))
                        *dst++ = *filename++;
                *dst = '\0';

                loadfont(KernelName);
                refstr_put(filename);
        } else if (looking_at(p, "kbdmap")) {
                const char *filename;

                filename = refstrdup(skipspace(p + 6));
                loadkeys(filename);
                refstr_put(filename);
        }
        /*
         * subset 2:  pc_setint16
         * set a global flag
         */
        else if (looking_at(p, "implicit")) {
                allowimplicit = atoi(skipspace(p + 8));
        } else if (looking_at(p, "prompt")) {
                forceprompt = atoi(skipspace(p + 6));
        } else if (looking_at(p, "console")) {
                DisplayCon = atoi(skipspace(p + 7));
        } else if (looking_at(p, "allowoptions")) {
                allowoptions = atoi(skipspace(p + 12));
        } else if (looking_at(p, "noescape")) {
                noescape = atoi(skipspace(p + 8));
        } else if (looking_at(p, "nocomplete")) {
                nocomplete = atoi(skipspace(p + 10));
        } else if (looking_at(p, "nohalt")) {
                NoHalt = atoi(skipspace(p + 8));
        } else if (looking_at(p, "onerror")) {
                refstr_put(m->onerror);
                m->onerror = refstrdup(skipspace(p + 7));
                onerrorlen = strlen(m->onerror);
                refstr_put(onerror);
                onerror = refstrdup(m->onerror);
        }

        else if (looking_at(p, "pxeretry"))
                PXERetry = atoi(skipspace(p + 8));

        /* serial setting, bps, flow control */
        else if (looking_at(p, "serial")) {
                uint16_t port, flow;
                uint32_t baud;

                p = skipspace(p + 6);
                port = atoi(p);

                while (isalnum(*p))
                        p++;
                p = skipspace(p);

                /* Default to no flow control */
                FlowOutput = 0;
                FlowInput = 0;

                baud = DEFAULT_BAUD;
                if (isalnum(*p)) {
                        uint8_t ignore;

                        /* setup baud */
                        baud = atoi(p);
                        while (isalnum(*p))
                                p++;
                        p = skipspace(p);

                        ignore = 0;
                        flow = 0;
                        if (isalnum(*p)) {
                                /* flow control */
                                flow = atoi(p);
                                ignore = ((flow & 0x0F00) >> 4);
                        }

                        FlowIgnore = ignore;
                        flow = ((flow & 0xff) << 8) | (flow & 0xff);
                        flow &= 0xF00B;
                        FlowOutput = (flow & 0xff);
                        FlowInput = ((flow & 0xff00) >> 8);
                }

                /*
                 * Parse baud
                 */
                if (baud < 75) {
                        /* < 75 baud == bogus */
                        SerialPort = 0;
                        continue;
                }

                baud = BAUD_DIVISOR / baud;
                baud &= 0xffff;
                BaudDivisor = baud;

                port = get_serial_port(port);
                SerialPort = port;

                /*
                 * Begin code to actually set up the serial port
                 */
                sirq_cleanup_nowipe();

                outb(0x83, port + 3); /* Enable DLAB */
                io_delay();

                outb((baud & 0xff), port); /* write divisor to LS */
                io_delay();

                outb(((baud & 0xff00) >> 8), port + 1); /* write to MS */
                io_delay();

                outb(0x03, port + 3); /* Disable DLAB */
                io_delay();

                /*
                 * Read back LCR (detect missing hw). If nothing here
                 * we'll read 00 or FF.
                 */
                if (inb(port + 3) != 0x03) {
                        /* Assume serial port busted */
                        SerialPort = 0;
                        continue;
                }

                outb(0x01, port + 2); /* Enable FIFOs if present */
                io_delay();

                /* Disable FIFO if unusable */
                if (inb(port + 2) < 0x0C0) {
                        outb(0, port + 2);
                        io_delay();
                }

                /* Assert bits in MCR */
                outb(FlowOutput, port + 4);
                io_delay();

                /* Enable interrupts if requested */
                if (FlowOutput & 0x8)
                        sirq_install();

                /* Show some life */
                if (SerialNotice != 0) {
                        SerialNotice = 0;

                        write_serial_str(syslinux_banner);
                        write_serial_str(copyright_str);
                }

        } else if (looking_at(p, "say")) {
                printf("%s\n", p+4);
        } else if (looking_at(p, "path")) {
                if (parse_path(skipspace(p + 4)))
                        printf("Failed to parse PATH\n");
        } else if (looking_at(p, "sendcookies")) {
                const union syslinux_derivative_info *sdi;

                p += strlen("sendcookies");
                sdi = syslinux_derivative_info();

                if (sdi->c.filesystem == SYSLINUX_FS_PXELINUX) {
                        SendCookies = strtoul(skipspace(p), NULL, 10);
                        http_bake_cookies();
                }
        }
    }
}

static int parse_main_config(const char *filename)
{
        const char *mode = "r";
        FILE *f;
        int fd;

        if (!filename)
                fd = open_config();
        else
                fd = open(filename, O_RDONLY);

        if (fd < 0)
                return fd;

        if (config_cwd[0]) {
                if (chdir(config_cwd) < 0)
                        printf("Failed to chdir to %s\n", config_cwd);
                config_cwd[0] = '\0';
        }

        f = fdopen(fd, mode);
        parse_config_file(f);

        /*
         * Update ConfigName so that syslinux_config_file() returns
         * the filename we just opened. filesystem-specific
         * open_config() implementations are expected to update
         * ConfigName themselves.
         */
        if (filename)
            strcpy(ConfigName, filename);

        return 0;
}

static void resolve_gotos(void)
{
    struct menu_entry *me;
    struct menu *m;

    for (me = all_entries; me; me = me->next) {
        if (me->action == MA_GOTO_UNRES || me->action == MA_EXIT_UNRES) {
            m = find_menu(me->cmdline);
            refstr_put(me->cmdline);
            me->cmdline = NULL;
            if (m) {
                me->submenu = m;
                me->action--;   /* Drop the _UNRES */
            } else {
                me->action = MA_DISABLED;
            }
        }
    }
}

void parse_configs(char **argv)
{
    const char *filename;
    struct menu *m;
    struct menu_entry *me;
    dprintf("enter");

    empty_string = refstrdup("");

    /* feng: reset current menu_list and entry list */
    menu_list = NULL;
    all_entries = NULL;

    /* Initialize defaults for the root and hidden menus */
    hide_menu = new_menu(NULL, NULL, refstrdup(".hidden"));
    root_menu = new_menu(NULL, NULL, refstrdup(".top"));
    start_menu = root_menu;

    /* Other initialization */
    memset(&ld, 0, sizeof(struct labeldata));

    /* Actually process the files */
    current_menu = root_menu;

    if (!argv || !*argv) {
        if (parse_main_config(NULL) < 0) {
            printf("WARNING: No configuration file found\n");
            return;
        }
    } else {
        while ((filename = *argv++)) {
                dprintf("Parsing config: %s", filename);
            parse_main_config(filename);
        }
    }

    /* On final EOF process the last label statement */
    record(current_menu, &ld, append);

    /* Common postprocessing */
    resolve_gotos();

    /* Handle global default */
    //if (has_ui && globaldefault) {
    if (globaldefault) {
        dprintf("gloabldefault = %s", globaldefault);
        me = find_label(globaldefault);
        if (me && me->menu != hide_menu) {
            me->menu->defentry = me->entry;
            start_menu = me->menu;
            default_menu = me->menu;
        }
    }

    /* If "menu save" is active, let the ADV override the global default */
    if (menusave) {
        size_t len;
        const char *lbl = syslinux_getadv(ADV_MENUSAVE, &len);
        char *lstr;
        if (lbl && len) {
            lstr = refstr_alloc(len);
            memcpy(lstr, lbl, len);     /* refstr_alloc() adds the final null */
            me = find_label(lstr);
            if (me && me->menu != hide_menu) {
                me->menu->defentry = me->entry;
                start_menu = me->menu;
            }
            refstr_put(lstr);
        }
    }

    /* Final per-menu initialization, with all labels known */
    for (m = menu_list; m; m = m->next) {
        m->curentry = m->defentry;      /* All menus start at their defaults */

        if (m->ontimeout)
            m->ontimeout = unlabel(m->ontimeout);
        if (m->onerror)
            m->onerror = unlabel(m->onerror);
    }
}