Context Navigation

source: bootcd/isolinux/syslinux-6.03/com32/menu/menumain.c @ dd1be7c

Last change on this file since dd1be7c was e16e8f2, checked in by Edwin Eefting <edwin@datux.nl>, 3 years ago
bootstuff
Property mode set to `100644`
File size: 24.8 KB

Rev	Line
[e16e8f2]	1	/* ----------------------------------------------------------------------- *
	2	*
	3	* Copyright 2004-2008 H. Peter Anvin - All Rights Reserved
	4	* Copyright 2009-2014 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	/*
	15	* menumain.c
	16	*
	17	* Simple menu system which displays a list and allows the user to select
	18	* a command line and/or edit it.
	19	*/
	20
	21	#include <ctype.h>
	22	#include <string.h>
	23	#include <stdlib.h>
	24	#include <stdio.h>
	25	#include <consoles.h>
	26	#include <getkey.h>
	27	#include <minmax.h>
	28	#include <setjmp.h>
	29	#include <limits.h>
	30	#include <com32.h>
	31	#include <core.h>
	32	#include <syslinux/adv.h>
	33	#include <syslinux/boot.h>
	34
	35	#include "menu.h"
	36
	37	/* The symbol "cm" always refers to the current menu across this file... */
	38	static struct menu *cm;
	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	/* These macros assume "cm" is a pointer to the current menu */
	58	#define WIDTH (cm->mparm[P_WIDTH])
	59	#define MARGIN (cm->mparm[P_MARGIN])
	60	#define PASSWD_MARGIN (cm->mparm[P_PASSWD_MARGIN])
	61	#define MENU_ROWS (cm->mparm[P_MENU_ROWS])
	62	#define TABMSG_ROW (cm->mparm[P_TABMSG_ROW]+VSHIFT)
	63	#define CMDLINE_ROW (cm->mparm[P_CMDLINE_ROW]+VSHIFT)
	64	#define END_ROW (cm->mparm[P_END_ROW])
	65	#define PASSWD_ROW (cm->mparm[P_PASSWD_ROW]+VSHIFT)
	66	#define TIMEOUT_ROW (cm->mparm[P_TIMEOUT_ROW]+VSHIFT)
	67	#define HELPMSG_ROW (cm->mparm[P_HELPMSG_ROW]+VSHIFT)
	68	#define HELPMSGEND_ROW (cm->mparm[P_HELPMSGEND_ROW])
	69	#define HSHIFT (cm->mparm[P_HSHIFT])
	70	#define VSHIFT (cm->mparm[P_VSHIFT])
	71	#define HIDDEN_ROW (cm->mparm[P_HIDDEN_ROW])
	72
	73	static char pad_line(const char text, int align, int width)
	74	{
	75	static char buffer[MAX_CMDLINE_LEN];
	76	int n, p;
	77
	78	if (width >= (int)sizeof buffer)
	79	return NULL; /* Can't do it */
	80
	81	n = strlen(text);
	82	if (n >= width)
	83	n = width;
	84
	85	memset(buffer, ' ', width);
	86	buffer[width] = 0;
	87	p = ((width - n) * align) >> 1;
	88	memcpy(buffer + p, text, n);
	89
	90	return buffer;
	91	}
	92
	93	/* Display an entry, with possible hotkey highlight. Assumes
	94	that the current attribute is the non-hotkey one, and will
	95	guarantee that as an exit condition as well. */
	96	static void
	97	display_entry(const struct menu_entry entry, const char attrib,
	98	const char *hotattrib, int width)
	99	{
	100	const char *p = entry->displayname;
	101	char marker;
	102
	103	if (!p)
	104	p = "";
	105
	106	switch (entry->action) {
	107	case MA_SUBMENU:
	108	marker = '>';
	109	break;
	110	case MA_EXIT:
	111	marker = '<';
	112	break;
	113	default:
	114	marker = 0;
	115	break;
	116	}
	117
	118	if (marker)
	119	width -= 2;
	120
	121	while (width) {
	122	if (*p) {
	123	if (*p == '^') {
	124	p++;
	125	if (p && ((unsigned char)p & ~0x20) == entry->hotkey) {
	126	fputs(hotattrib, stdout);
	127	putchar(*p++);
	128	fputs(attrib, stdout);
	129	width--;
	130	}
	131	} else {
	132	putchar(*p++);
	133	width--;
	134	}
	135	} else {
	136	putchar(' ');
	137	width--;
	138	}
	139	}
	140
	141	if (marker) {
	142	putchar(' ');
	143	putchar(marker);
	144	}
	145	}
	146
	147	static void draw_row(int y, int sel, int top, int sbtop, int sbbot)
	148	{
	149	int i = (y - 4 - VSHIFT) + top;
	150	int dis = (i < cm->nentries) && is_disabled(cm->menu_entries[i]);
	151
	152	printf("\033[%d;%dH\1#1\016x\017%s ",
	153	y, MARGIN + 1 + HSHIFT,
	154	(i == sel) ? "\1#5" : dis ? "\2#17" : "\1#3");
	155
	156	if (i >= cm->nentries) {
	157	fputs(pad_line("", 0, WIDTH - 2 * MARGIN - 4), stdout);
	158	} else {
	159	display_entry(cm->menu_entries[i],
	160	(i == sel) ? "\1#5" : dis ? "\2#17" : "\1#3",
	161	(i == sel) ? "\1#6" : dis ? "\2#17" : "\1#4",
	162	WIDTH - 2 * MARGIN - 4);
	163	}
	164
	165	if (cm->nentries <= MENU_ROWS) {
	166	printf(" \1#1\016x\017");
	167	} else if (sbtop > 0) {
	168	if (y >= sbtop && y <= sbbot)
	169	printf(" \1#7\016a\017");
	170	else
	171	printf(" \1#1\016x\017");
	172	} else {
	173	putchar(' '); /* Don't modify the scrollbar */
	174	}
	175	}
	176
	177	static jmp_buf timeout_jump;
	178
	179	int mygetkey(clock_t timeout)
	180	{
	181	clock_t t0, t;
	182	clock_t tto, to;
	183	int key;
	184
	185	if (!totaltimeout)
	186	return get_key(stdin, timeout);
	187
	188	for (;;) {
	189	tto = min(totaltimeout, INT_MAX);
	190	to = timeout ? min(tto, timeout) : tto;
	191
	192	t0 = times(NULL);
	193	key = get_key(stdin, to);
	194	t = times(NULL) - t0;
	195
	196	if (totaltimeout <= t)
	197	longjmp(timeout_jump, 1);
	198
	199	totaltimeout -= t;
	200
	201	if (key != KEY_NONE)
	202	return key;
	203
	204	if (timeout) {
	205	if (timeout <= t)
	206	return KEY_NONE;
	207
	208	timeout -= t;
	209	}
	210	}
	211	}
	212
	213	static int ask_passwd(const char *menu_entry)
	214	{
	215	char user_passwd[WIDTH], *p;
	216	int done;
	217	int key;
	218	int x;
	219	int rv;
	220
	221	printf("\033[%d;%dH\2#11\016l", PASSWD_ROW, PASSWD_MARGIN + 1);
	222	for (x = 2; x <= WIDTH - 2 * PASSWD_MARGIN - 1; x++)
	223	putchar('q');
	224
	225	printf("k\033[%d;%dHx", PASSWD_ROW + 1, PASSWD_MARGIN + 1);
	226	for (x = 2; x <= WIDTH - 2 * PASSWD_MARGIN - 1; x++)
	227	putchar(' ');
	228
	229	printf("x\033[%d;%dHm", PASSWD_ROW + 2, PASSWD_MARGIN + 1);
	230	for (x = 2; x <= WIDTH - 2 * PASSWD_MARGIN - 1; x++)
	231	putchar('q');
	232
	233	printf("j\017\033[%d;%dH\2#12 %s \033[%d;%dH\2#13",
	234	PASSWD_ROW, (WIDTH - (strlen(cm->messages[MSG_PASSPROMPT]) + 2)) / 2,
	235	cm->messages[MSG_PASSPROMPT], PASSWD_ROW + 1, PASSWD_MARGIN + 3);
	236
	237	drain_keyboard();
	238
	239	/* Actually allow user to type a password, then compare to the SHA1 */
	240	done = 0;
	241	p = user_passwd;
	242
	243	while (!done) {
	244	key = mygetkey(0);
	245
	246	switch (key) {
	247	case KEY_ENTER:
	248	case KEY_CTRL('J'):
	249	done = 1;
	250	break;
	251
	252	case KEY_ESC:
	253	case KEY_CTRL('C'):
	254	p = user_passwd; /* No password entered */
	255	done = 1;
	256	break;
	257
	258	case KEY_BACKSPACE:
	259	case KEY_DEL:
	260	case KEY_DELETE:
	261	if (p > user_passwd) {
	262	printf("\b \b");
	263	p--;
	264	}
	265	break;
	266
	267	case KEY_CTRL('U'):
	268	while (p > user_passwd) {
	269	printf("\b \b");
	270	p--;
	271	}
	272	break;
	273
	274	default:
	275	if (key >= ' ' && key <= 0xFF &&
	276	(p - user_passwd) < WIDTH - 2 * PASSWD_MARGIN - 5) {
	277	*p++ = key;
	278	putchar('*');
	279	}
	280	break;
	281	}
	282	}
	283
	284	if (p == user_passwd)
	285	return 0; /* No password entered */
	286
	287	*p = '\0';
	288
	289	rv = (cm->menu_master_passwd &&
	290	passwd_compare(cm->menu_master_passwd, user_passwd))
	291	\|\| (menu_entry && passwd_compare(menu_entry, user_passwd));
	292
	293	/* Clean up */
	294	memset(user_passwd, 0, WIDTH);
	295	drain_keyboard();
	296
	297	return rv;
	298	}
	299
	300	static void draw_menu(int sel, int top, int edit_line)
	301	{
	302	int x, y;
	303	int sbtop = 0, sbbot = 0;
	304	const char *tabmsg;
	305	int tabmsg_len;
	306
	307	if (cm->nentries > MENU_ROWS) {
	308	int sblen = max(MENU_ROWS * MENU_ROWS / cm->nentries, 1);
	309	sbtop = (MENU_ROWS - sblen + 1) * top / (cm->nentries - MENU_ROWS + 1);
	310	sbbot = sbtop + sblen - 1;
	311	sbtop += 4;
	312	sbbot += 4; /* Starting row of scrollbar */
	313	}
	314
	315	printf("\033[%d;%dH\1#1\016l", VSHIFT + 1, HSHIFT + MARGIN + 1);
	316	for (x = 2 + HSHIFT; x <= (WIDTH - 2 * MARGIN - 1) + HSHIFT; x++)
	317	putchar('q');
	318
	319	printf("k\033[%d;%dH\1#1x\017\1#2 %s \1#1\016x",
	320	VSHIFT + 2,
	321	HSHIFT + MARGIN + 1, pad_line(cm->title, 1, WIDTH - 2 * MARGIN - 4));
	322
	323	printf("\033[%d;%dH\1#1t", VSHIFT + 3, HSHIFT + MARGIN + 1);
	324	for (x = 2 + HSHIFT; x <= (WIDTH - 2 * MARGIN - 1) + HSHIFT; x++)
	325	putchar('q');
	326	fputs("u\017", stdout);
	327
	328	for (y = 4 + VSHIFT; y < 4 + VSHIFT + MENU_ROWS; y++)
	329	draw_row(y, sel, top, sbtop, sbbot);
	330
	331	printf("\033[%d;%dH\1#1\016m", y, HSHIFT + MARGIN + 1);
	332	for (x = 2 + HSHIFT; x <= (WIDTH - 2 * MARGIN - 1) + HSHIFT; x++)
	333	putchar('q');
	334	fputs("j\017", stdout);
	335
	336	if (edit_line && cm->allowedit && !cm->menu_master_passwd)
	337	tabmsg = cm->messages[MSG_TAB];
	338	else
	339	tabmsg = cm->messages[MSG_NOTAB];
	340
	341	tabmsg_len = strlen(tabmsg);
	342
	343	printf("\1#8\033[%d;%dH%s",
	344	TABMSG_ROW, 1 + HSHIFT + ((WIDTH - tabmsg_len) >> 1), tabmsg);
	345	printf("\1#0\033[%d;1H", END_ROW);
	346	}
	347
	348	static void clear_screen(void)
	349	{
	350	fputs("\033e\033%@\033)0\033(B\1#0\033[?25l\033[2J", stdout);
	351	}
	352
	353	static void display_help(const char *text)
	354	{
	355	int row;
	356	const char *p;
	357
	358	if (!text) {
	359	text = "";
	360	printf("\1#0\033[%d;1H", HELPMSG_ROW);
	361	} else {
	362	printf("\2#16\033[%d;1H", HELPMSG_ROW);
	363	}
	364
	365	for (p = text, row = HELPMSG_ROW; *p && row <= HELPMSGEND_ROW; p++) {
	366	switch (*p) {
	367	case '\r':
	368	case '\f':
	369	case '\v':
	370	case '\033':
	371	break;
	372	case '\n':
	373	printf("\033[K\033[%d;1H", ++row);
	374	break;
	375	default:
	376	putchar(*p);
	377	}
	378	}
	379
	380	fputs("\033[K", stdout);
	381
	382	while (row <= HELPMSGEND_ROW) {
	383	printf("\033[K\033[%d;1H", ++row);
	384	}
	385	}
	386
	387	static void show_fkey(int key)
	388	{
	389	int fkey;
	390
	391	while (1) {
	392	switch (key) {
	393	case KEY_F1:
	394	fkey = 0;
	395	break;
	396	case KEY_F2:
	397	fkey = 1;
	398	break;
	399	case KEY_F3:
	400	fkey = 2;
	401	break;
	402	case KEY_F4:
	403	fkey = 3;
	404	break;
	405	case KEY_F5:
	406	fkey = 4;
	407	break;
	408	case KEY_F6:
	409	fkey = 5;
	410	break;
	411	case KEY_F7:
	412	fkey = 6;
	413	break;
	414	case KEY_F8:
	415	fkey = 7;
	416	break;
	417	case KEY_F9:
	418	fkey = 8;
	419	break;
	420	case KEY_F10:
	421	fkey = 9;
	422	break;
	423	case KEY_F11:
	424	fkey = 10;
	425	break;
	426	case KEY_F12:
	427	fkey = 11;
	428	break;
	429	default:
	430	fkey = -1;
	431	break;
	432	}
	433
	434	if (fkey == -1)
	435	break;
	436
	437	if (cm->fkeyhelp[fkey].textname)
	438	key = show_message_file(cm->fkeyhelp[fkey].textname,
	439	cm->fkeyhelp[fkey].background);
	440	else
	441	break;
	442	}
	443	}
	444
	445	static const char edit_cmdline(const char input, int top)
	446	{
	447	static char cmdline[MAX_CMDLINE_LEN];
	448	int key, len, prev_len, cursor;
	449	int redraw = 1; /* We enter with the menu already drawn */
	450
	451	strlcpy(cmdline, input, MAX_CMDLINE_LEN);
	452	cmdline[MAX_CMDLINE_LEN - 1] = '\0';
	453
	454	len = cursor = strlen(cmdline);
	455	prev_len = 0;
	456
	457	for (;;) {
	458	if (redraw > 1) {
	459	/* Clear and redraw whole screen */
	460	/* Enable ASCII on G0 and DEC VT on G1; do it in this order
	461	to avoid confusing the Linux console */
	462	clear_screen();
	463	draw_menu(-1, top, 1);
	464	prev_len = 0;
	465	}
	466
	467	if (redraw > 0) {
	468	/* Redraw the command line */
	469	printf("\033[?25l\033[%d;1H\1#9> \2#10%s",
	470	CMDLINE_ROW, pad_line(cmdline, 0, max(len, prev_len)));
	471	printf("\2#10\033[%d;3H%s\033[?25h",
	472	CMDLINE_ROW, pad_line(cmdline, 0, cursor));
	473	prev_len = len;
	474	redraw = 0;
	475	}
	476
	477	key = mygetkey(0);
	478
	479	switch (key) {
	480	case KEY_CTRL('L'):
	481	redraw = 2;
	482	break;
	483
	484	case KEY_ENTER:
	485	case KEY_CTRL('J'):
	486	return cmdline;
	487
	488	case KEY_ESC:
	489	case KEY_CTRL('C'):
	490	return NULL;
	491
	492	case KEY_BACKSPACE:
	493	case KEY_DEL:
	494	if (cursor) {
	495	memmove(cmdline + cursor - 1, cmdline + cursor,
	496	len - cursor + 1);
	497	len--;
	498	cursor--;
	499	redraw = 1;
	500	}
	501	break;
	502
	503	case KEY_CTRL('D'):
	504	case KEY_DELETE:
	505	if (cursor < len) {
	506	memmove(cmdline + cursor, cmdline + cursor + 1, len - cursor);
	507	len--;
	508	redraw = 1;
	509	}
	510	break;
	511
	512	case KEY_CTRL('U'):
	513	if (len) {
	514	len = cursor = 0;
	515	cmdline[len] = '\0';
	516	redraw = 1;
	517	}
	518	break;
	519
	520	case KEY_CTRL('W'):
	521	if (cursor) {
	522	int prevcursor = cursor;
	523
	524	while (cursor && my_isspace(cmdline[cursor - 1]))
	525	cursor--;
	526
	527	while (cursor && !my_isspace(cmdline[cursor - 1]))
	528	cursor--;
	529
	530	memmove(cmdline + cursor, cmdline + prevcursor,
	531	len - prevcursor + 1);
	532	len -= (prevcursor - cursor);
	533	redraw = 1;
	534	}
	535	break;
	536
	537	case KEY_LEFT:
	538	case KEY_CTRL('B'):
	539	if (cursor) {
	540	cursor--;
	541	redraw = 1;
	542	}
	543	break;
	544
	545	case KEY_RIGHT:
	546	case KEY_CTRL('F'):
	547	if (cursor < len) {
	548	putchar(cmdline[cursor++]);
	549	}
	550	break;
	551
	552	case KEY_CTRL('K'):
	553	if (cursor < len) {
	554	cmdline[len = cursor] = '\0';
	555	redraw = 1;
	556	}
	557	break;
	558
	559	case KEY_HOME:
	560	case KEY_CTRL('A'):
	561	if (cursor) {
	562	cursor = 0;
	563	redraw = 1;
	564	}
	565	break;
	566
	567	case KEY_END:
	568	case KEY_CTRL('E'):
	569	if (cursor != len) {
	570	cursor = len;
	571	redraw = 1;
	572	}
	573	break;
	574
	575	case KEY_F1:
	576	case KEY_F2:
	577	case KEY_F3:
	578	case KEY_F4:
	579	case KEY_F5:
	580	case KEY_F6:
	581	case KEY_F7:
	582	case KEY_F8:
	583	case KEY_F9:
	584	case KEY_F10:
	585	case KEY_F11:
	586	case KEY_F12:
	587	show_fkey(key);
	588	redraw = 1;
	589	break;
	590
	591	default:
	592	if (key >= ' ' && key <= 0xFF && len < MAX_CMDLINE_LEN - 1) {
	593	if (cursor == len) {
	594	cmdline[len] = key;
	595	cmdline[++len] = '\0';
	596	cursor++;
	597	putchar(key);
	598	prev_len++;
	599	} else {
	600	memmove(cmdline + cursor + 1, cmdline + cursor,
	601	len - cursor + 1);
	602	cmdline[cursor++] = key;
	603	len++;
	604	redraw = 1;
	605	}
	606	}
	607	break;
	608	}
	609	}
	610	}
	611
	612	static void print_timeout_message(int tol, int row, const char *msg)
	613	{
	614	static int last_msg_len = 0;
	615	char buf[256];
	616	int nc = 0, nnc, padc;
	617	const char *tp = msg;
	618	char tc;
	619	char *tq = buf;
	620
	621	while ((size_t) (tq - buf) < (sizeof buf - 16) && (tc = *tp)) {
	622	tp++;
	623	if (tc == '#') {
	624	nnc = sprintf(tq, "\2#15%d\2#14", tol);
	625	tq += nnc;
	626	nc += nnc - 8; /* 8 formatting characters */
	627	} else if (tc == '{') {
	628	/* Deal with {singular[,dual],plural} constructs */
	629	struct {
	630	const char s, e;
	631	} tx[3];
	632	const char *tpp;
	633	int n = 0;
	634
	635	memset(tx, 0, sizeof tx);
	636
	637	tx[0].s = tp;
	638
	639	while (tp && tp != '}') {
	640	if (*tp == ',' && n < 2) {
	641	tx[n].e = tp;
	642	n++;
	643	tx[n].s = tp + 1;
	644	}
	645	tp++;
	646	}
	647	tx[n].e = tp;
	648
	649	if (*tp)
	650	tp++; /* Skip final bracket */
	651
	652	if (!tx[1].s)
	653	tx[1] = tx[0];
	654	if (!tx[2].s)
	655	tx[2] = tx[1];
	656
	657	/* Now [0] is singular, [1] is dual, and [2] is plural,
	658	even if the user only specified some of them. */
	659
	660	switch (tol) {
	661	case 1:
	662	n = 0;
	663	break;
	664	case 2:
	665	n = 1;
	666	break;
	667	default:
	668	n = 2;
	669	break;
	670	}
	671
	672	for (tpp = tx[n].s; tpp < tx[n].e; tpp++) {
	673	if ((size_t) (tq - buf) < (sizeof buf)) {
	674	tq++ = tpp;
	675	nc++;
	676	}
	677	}
	678	} else {
	679	*tq++ = tc;
	680	nc++;
	681	}
	682	}
	683	*tq = '\0';
	684
	685	if (nc >= last_msg_len) {
	686	padc = 0;
	687	} else {
	688	padc = (last_msg_len - nc + 1) >> 1;
	689	}
	690
	691	printf("\033[%d;%dH\2#14%s%s%s", row,
	692	HSHIFT + 1 + ((WIDTH - nc) >> 1) - padc,
	693	padc, "", buf, padc, "");
	694
	695	last_msg_len = nc;
	696	}
	697
	698	/* Set the background screen, etc. */
	699	static void prepare_screen_for_menu(void)
	700	{
	701	console_color_table = cm->color_table;
	702	console_color_table_size = menu_color_table_size;
	703	set_background(cm->menu_background);
	704	}
	705
	706	static const char *do_hidden_menu(void)
	707	{
	708	int key;
	709	int timeout_left, this_timeout;
	710
	711	clear_screen();
	712
	713	if (!setjmp(timeout_jump)) {
	714	timeout_left = cm->timeout;
	715
	716	while (!cm->timeout \|\| timeout_left) {
	717	int tol = timeout_left / CLK_TCK;
	718
	719	print_timeout_message(tol, HIDDEN_ROW, cm->messages[MSG_AUTOBOOT]);
	720
	721	this_timeout = min(timeout_left, CLK_TCK);
	722	key = mygetkey(this_timeout);
	723
	724	if (key != KEY_NONE) {
	725	/* Clear the message from the screen */
	726	print_timeout_message(0, HIDDEN_ROW, "");
	727	return hide_key[key]; /* NULL if no MENU HIDEKEY in effect */
	728	}
	729
	730	timeout_left -= this_timeout;
	731	}
	732	}
	733
	734	/* Clear the message from the screen */
	735	print_timeout_message(0, HIDDEN_ROW, "");
	736
	737	if (cm->ontimeout)
	738	return cm->ontimeout;
	739	else
	740	return cm->menu_entries[cm->defentry]->cmdline; /* Default entry */
	741	}
	742
	743	static const char *run_menu(void)
	744	{
	745	int key;
	746	int done = 0;
	747	volatile int entry = cm->curentry;
	748	int prev_entry = -1;
	749	volatile int top = cm->curtop;
	750	int prev_top = -1;
	751	int clear = 1, to_clear;
	752	const char *cmdline = NULL;
	753	volatile clock_t key_timeout, timeout_left, this_timeout;
	754	const struct menu_entry *me;
	755	bool hotkey = false;
	756
	757	/* Note: for both key_timeout and timeout == 0 means no limit */
	758	timeout_left = key_timeout = cm->timeout;
	759
	760	/* If we're in shiftkey mode, exit immediately unless a shift key
	761	is pressed */
	762	if (shiftkey && !shift_is_held()) {
	763	return cm->menu_entries[cm->defentry]->cmdline;
	764	} else {
	765	shiftkey = 0;
	766	}
	767
	768	/* Do this before hiddenmenu handling, so we show the background */
	769	prepare_screen_for_menu();
	770
	771	/* Handle hiddenmenu */
	772	if (hiddenmenu) {
	773	cmdline = do_hidden_menu();
	774	if (cmdline)
	775	return cmdline;
	776
	777	/* Otherwise display the menu now; the timeout has already been
	778	cancelled, since the user pressed a key. */
	779	hiddenmenu = 0;
	780	key_timeout = 0;
	781	}
	782
	783	/* Handle both local and global timeout */
	784	if (setjmp(timeout_jump)) {
	785	entry = cm->defentry;
	786
	787	if (top < 0 \|\| top < entry - MENU_ROWS + 1)
	788	top = max(0, entry - MENU_ROWS + 1);
	789	else if (top > entry \|\| top > max(0, cm->nentries - MENU_ROWS))
	790	top = min(entry, max(0, cm->nentries - MENU_ROWS));
	791
	792	draw_menu(cm->ontimeout ? -1 : entry, top, 1);
	793	cmdline =
	794	cm->ontimeout ? cm->ontimeout : cm->menu_entries[entry]->cmdline;
	795	done = 1;
	796	}
	797
	798	while (!done) {
	799	if (entry <= 0) {
	800	entry = 0;
	801	while (entry < cm->nentries && is_disabled(cm->menu_entries[entry]))
	802	entry++;
	803	}
	804	if (entry >= cm->nentries - 1) {
	805	entry = cm->nentries - 1;
	806	while (entry > 0 && is_disabled(cm->menu_entries[entry]))
	807	entry--;
	808	}
	809
	810	me = cm->menu_entries[entry];
	811
	812	if (top < 0 \|\| top < entry - MENU_ROWS + 1)
	813	top = max(0, entry - MENU_ROWS + 1);
	814	else if (top > entry \|\| top > max(0, cm->nentries - MENU_ROWS))
	815	top = min(entry, max(0, cm->nentries - MENU_ROWS));
	816
	817	/* Start with a clear screen */
	818	if (clear) {
	819	/* Clear and redraw whole screen */
	820	/* Enable ASCII on G0 and DEC VT on G1; do it in this order
	821	to avoid confusing the Linux console */
	822	if (clear >= 2)
	823	prepare_screen_for_menu();
	824	clear_screen();
	825	clear = 0;
	826	prev_entry = prev_top = -1;
	827	}
	828
	829	if (top != prev_top) {
	830	draw_menu(entry, top, 1);
	831	display_help(me->helptext);
	832	} else if (entry != prev_entry) {
	833	draw_row(prev_entry - top + 4 + VSHIFT, entry, top, 0, 0);
	834	draw_row(entry - top + 4 + VSHIFT, entry, top, 0, 0);
	835	display_help(me->helptext);
	836	}
	837
	838	prev_entry = entry;
	839	prev_top = top;
	840	cm->curentry = entry;
	841	cm->curtop = top;
	842
	843	/* Cursor movement cancels timeout */
	844	if (entry != cm->defentry)
	845	key_timeout = 0;
	846
	847	if (key_timeout) {
	848	int tol = timeout_left / CLK_TCK;
	849	print_timeout_message(tol, TIMEOUT_ROW, cm->messages[MSG_AUTOBOOT]);
	850	to_clear = 1;
	851	} else {
	852	to_clear = 0;
	853	}
	854
	855	if (hotkey && me->immediate) {
	856	/* If the hotkey was flagged immediate, simulate pressing ENTER */
	857	key = KEY_ENTER;
	858	} else {
	859	this_timeout = min(min(key_timeout, timeout_left),
	860	(clock_t) CLK_TCK);
	861	key = mygetkey(this_timeout);
	862
	863	if (key != KEY_NONE) {
	864	timeout_left = key_timeout;
	865	if (to_clear)
	866	printf("\033[%d;1H\1#0\033[K", TIMEOUT_ROW);
	867	}
	868	}
	869
	870	hotkey = false;
	871
	872	switch (key) {
	873	case KEY_NONE: /* Timeout */
	874	/* This is somewhat hacky, but this at least lets the user
	875	know what's going on, and still deals with "phantom inputs"
	876	e.g. on serial ports.
	877
	878	Warning: a timeout will boot the default entry without any
	879	password! */
	880	if (key_timeout) {
	881	if (timeout_left <= this_timeout)
	882	longjmp(timeout_jump, 1);
	883
	884	timeout_left -= this_timeout;
	885	}
	886	break;
	887
	888	case KEY_CTRL('L'):
	889	clear = 1;
	890	break;
	891
	892	case KEY_ENTER:
	893	case KEY_CTRL('J'):
	894	key_timeout = 0; /* Cancels timeout */
	895	if (me->passwd) {
	896	clear = 1;
	897	done = ask_passwd(me->passwd);
	898	} else {
	899	done = 1;
	900	}
	901	cmdline = NULL;
	902	if (done) {
	903	switch (me->action) {
	904	case MA_CMD:
	905	cmdline = me->cmdline;
	906	break;
	907	case MA_SUBMENU:
	908	case MA_GOTO:
	909	case MA_EXIT:
	910	done = 0;
	911	clear = 2;
	912	cm = me->submenu;
	913	entry = cm->curentry;
	914	top = cm->curtop;
	915	break;
	916	case MA_QUIT:
	917	/* Quit menu system */
	918	done = 1;
	919	clear = 1;
	920	draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0);
	921	break;
	922	case MA_HELP:
	923	key = show_message_file(me->cmdline, me->background);
	924	/* If the exit was an F-key, display that help screen */
	925	show_fkey(key);
	926	done = 0;
	927	clear = 1;
	928	break;
	929	default:
	930	done = 0;
	931	break;
	932	}
	933	}
	934	if (done && !me->passwd) {
	935	/* Only save a new default if we don't have a password... */
	936	if (me->save && me->label) {
	937	syslinux_setadv(ADV_MENUSAVE, strlen(me->label), me->label);
	938	syslinux_adv_write();
	939	}
	940	}
	941	break;
	942
	943	case KEY_UP:
	944	case KEY_CTRL('P'):
	945	while (entry > 0) {
	946	entry--;
	947	if (entry < top)
	948	top -= MENU_ROWS;
	949	if (!is_disabled(cm->menu_entries[entry]))
	950	break;
	951	}
	952	break;
	953
	954	case KEY_DOWN:
	955	case KEY_CTRL('N'):
	956	while (entry < cm->nentries - 1) {
	957	entry++;
	958	if (entry >= top + MENU_ROWS)
	959	top += MENU_ROWS;
	960	if (!is_disabled(cm->menu_entries[entry]))
	961	break;
	962	}
	963	break;
	964
	965	case KEY_PGUP:
	966	case KEY_LEFT:
	967	case KEY_CTRL('B'):
	968	case '<':
	969	entry -= MENU_ROWS;
	970	top -= MENU_ROWS;
	971	while (entry > 0 && is_disabled(cm->menu_entries[entry])) {
	972	entry--;
	973	if (entry < top)
	974	top -= MENU_ROWS;
	975	}
	976	break;
	977
	978	case KEY_PGDN:
	979	case KEY_RIGHT:
	980	case KEY_CTRL('F'):
	981	case '>':
	982	case ' ':
	983	entry += MENU_ROWS;
	984	top += MENU_ROWS;
	985	while (entry < cm->nentries - 1
	986	&& is_disabled(cm->menu_entries[entry])) {
	987	entry++;
	988	if (entry >= top + MENU_ROWS)
	989	top += MENU_ROWS;
	990	}
	991	break;
	992
	993	case '-':
	994	while (entry > 0) {
	995	entry--;
	996	top--;
	997	if (!is_disabled(cm->menu_entries[entry]))
	998	break;
	999	}
	1000	break;
	1001
	1002	case '+':
	1003	while (entry < cm->nentries - 1) {
	1004	entry++;
	1005	top++;
	1006	if (!is_disabled(cm->menu_entries[entry]))
	1007	break;
	1008	}
	1009	break;
	1010
	1011	case KEY_CTRL('A'):
	1012	case KEY_HOME:
	1013	top = entry = 0;
	1014	break;
	1015
	1016	case KEY_CTRL('E'):
	1017	case KEY_END:
	1018	entry = cm->nentries - 1;
	1019	top = max(0, cm->nentries - MENU_ROWS);
	1020	break;
	1021
	1022	case KEY_F1:
	1023	case KEY_F2:
	1024	case KEY_F3:
	1025	case KEY_F4:
	1026	case KEY_F5:
	1027	case KEY_F6:
	1028	case KEY_F7:
	1029	case KEY_F8:
	1030	case KEY_F9:
	1031	case KEY_F10:
	1032	case KEY_F11:
	1033	case KEY_F12:
	1034	show_fkey(key);
	1035	clear = 1;
	1036	break;
	1037
	1038	case KEY_TAB:
	1039	if (cm->allowedit && me->action == MA_CMD) {
	1040	int ok = 1;
	1041
	1042	key_timeout = 0; /* Cancels timeout */
	1043	draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0);
	1044
	1045	if (cm->menu_master_passwd) {
	1046	ok = ask_passwd(NULL);
	1047	clear_screen();
	1048	draw_menu(-1, top, 0);
	1049	} else {
	1050	/* Erase [Tab] message and help text */
	1051	printf("\033[%d;1H\1#0\033[K", TABMSG_ROW);
	1052	display_help(NULL);
	1053	}
	1054
	1055	if (ok) {
	1056	cmdline = edit_cmdline(me->cmdline, top);
	1057	done = !!cmdline;
	1058	clear = 1; /* In case we hit [Esc] and done is null */
	1059	} else {
	1060	draw_row(entry - top + 4 + VSHIFT, entry, top, 0, 0);
	1061	}
	1062	}
	1063	break;
	1064	case KEY_CTRL('C'): /* Ctrl-C */
	1065	case KEY_ESC: /* Esc */
	1066	if (cm->parent) {
	1067	cm = cm->parent;
	1068	clear = 2;
	1069	entry = cm->curentry;
	1070	top = cm->curtop;
	1071	} else if (cm->allowedit) {
	1072	done = 1;
	1073	clear = 1;
	1074	key_timeout = 0;
	1075
	1076	draw_row(entry - top + 4 + VSHIFT, -1, top, 0, 0);
	1077
	1078	if (cm->menu_master_passwd)
	1079	done = ask_passwd(NULL);
	1080	}
	1081	break;
	1082	default:
	1083	if (key > 0 && key < 0xFF) {
	1084	key &= ~0x20; /* Upper case */
	1085	if (cm->menu_hotkeys[key]) {
	1086	key_timeout = 0;
	1087	entry = cm->menu_hotkeys[key]->entry;
	1088	/* Should we commit at this point? */
	1089	hotkey = true;
	1090	}
	1091	}
	1092	break;
	1093	}
	1094	}
	1095
	1096	printf("\033[?25h"); /* Show cursor */
	1097
	1098	/* Return the label name so localboot and ipappend work */
	1099	return cmdline;
	1100	}
	1101
	1102	int main(int argc, char *argv[])
	1103	{
	1104	const char *cmdline;
	1105	struct menu *m;
	1106	int rows, cols;
	1107	int i;
	1108
	1109	(void)argc;
	1110
	1111	parse_configs(argv + 1);
	1112
	1113	/*
	1114	* We don't start the console until we have parsed the configuration
	1115	* file, since the configuration file might impact the console
	1116	* configuration, e.g. MENU RESOLUTION.
	1117	*/
	1118	start_console();
	1119	if (getscreensize(1, &rows, &cols)) {
	1120	/* Unknown screen size? */
	1121	rows = 24;
	1122	cols = 80;
	1123	}
	1124
	1125	/* Some postprocessing for all menus */
	1126	for (m = menu_list; m; m = m->next) {
	1127	if (!m->mparm[P_WIDTH])
	1128	m->mparm[P_WIDTH] = cols;
	1129
	1130	/* If anyone has specified negative parameters, consider them
	1131	relative to the bottom row of the screen. */
	1132	for (i = 0; i < NPARAMS; i++)
	1133	if (m->mparm[i] < 0)
	1134	m->mparm[i] = max(m->mparm[i] + rows, 0);
	1135	}
	1136
	1137	cm = start_menu;
	1138
	1139	if (!cm->nentries) {
	1140	fputs("Initial menu has no LABEL entries!\n", stdout);
	1141	return 1; /* Error! */
	1142	}
	1143
	1144	for (;;) {
	1145	local_cursor_enable(true);
	1146	cmdline = run_menu();
	1147
	1148	if (clearmenu)
	1149	clear_screen();
	1150
	1151	local_cursor_enable(false);
	1152	printf("\033[?25h\033[%d;1H\033[0m", END_ROW);
	1153
	1154	if (cmdline) {
	1155	uint32_t type = parse_image_type(cmdline);
	1156
	1157	execute(cmdline, type, false);
	1158	if (cm->onerror) {
	1159	type = parse_image_type(cm->onerror);
	1160	execute(cm->onerror, type, true);
	1161	}
	1162	} else {
	1163	return 0; /* Exit */
	1164	}
	1165	}
	1166	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: