/* ----------------------------------------------------------------------- * * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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 (my_isspace(c)) { 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 = strtoul(p, &p, 0); 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 = strtoul(p, NULL, 0); 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); } }