/*  *  Copyright (C) 2001-2003 Hewlett-Packard Co. *	Contributed by Stephane Eranian <eranian@hpl.hp.com> * * This file is part of the ELILO, the EFI Linux boot loader. * *  ELILO 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; either version 2, or (at your option) *  any later version. * *  ELILO is distributed in the hope that it will be useful, *  but WITHOUT ANY WARRANTY; without even the implied warranty of *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the *  GNU General Public License for more details. * *  You should have received a copy of the GNU General Public License *  along with ELILO; see the file COPYING.  If not, write to the Free *  Software Foundation, 59 Temple Place - Suite 330, Boston, MA *  02111-1307, USA. * * Please check out the elilo.txt for complete documentation on how * to use this program. */#include <efi.h>#include <efilib.h>#include "elilo.h"#include "vars.h"/* static is ugly but does the job here! */static CHAR16 **alt_argv;static VOIDdisplay_label_info(CHAR16 *name){	CHAR16 *desc;	CHAR16 initrd_name[CMDLINE_MAXLEN];	CHAR16 options_tmp[CMDLINE_MAXLEN];	CHAR16 options[CMDLINE_MAXLEN];	CHAR16 kname[FILENAME_MAXLEN];	desc = find_description(name);	if (desc) {		Print(L"desc   : %s\n", desc);	}	initrd_name[0] = options_tmp[0] = kname[0] = CHAR_NULL;	if (find_label(name, kname, options_tmp, initrd_name) == -1) {		StrCpy(kname, name);		Print(L"\n");	}	subst_vars(options_tmp, options, CMDLINE_MAXLEN);	Print(L"cmdline: %s %s\n", kname, options);	if (initrd_name[0]) Print(L"initrd : %s\n", initrd_name);}static VOIDprint_infos(int force){	CHAR16 *config_file;	CHAR16 dpath[FILENAME_MAXLEN];	CHAR16 *boot_dev_name;	UINT8 is_abs;	boot_dev_name = fops_bootdev_name();	config_file   = get_config_file();	fops_getdefault_path(dpath, FILENAME_MAXLEN);	if (force || elilo_opt.verbose > 0)		Print(L"default file path: %s:%s\n", boot_dev_name, dpath);	is_abs = config_file && (config_file[0] == CHAR_BACKSLASH || config_file[0] == CHAR_SLASH) ? 1 : 0;	if (force || elilo_opt.verbose > 0)			Print(L"config file      : %s%s\n", config_file && is_abs == 0 ? dpath : L"", config_file ? config_file : L"none used");	if (alt_argv) {		CHAR16 **p = alt_argv;		Print(L"found alternate default choice :");		while (*p) Print(L" %s", *p++);		Print(L"\n");	}}static VOIDprint_help(int force){	if (force || elilo_opt.verbose > 0)		Print(L"command list (must be first character):\n=:print device list, %%:print variable list, &:print paths, ?:help\nTAB:print label information\n");}/* * interactively select a kernel image and options. * The kernel can be an actual filename or a label in the config file * Return: * 	-1: if unsucessful * 	 0: otherwise */static INTNselect_kernel(CHAR16 *buffer, INTN size){#define CHAR_CTRL_C	L'\003' /* Unicode CTRL-C */#define CHAR_CTRL_D	L'\004' /* Unicode CTRL-D */#define CHAR_CTRL_U	L'\025' /* Unicode CTRL-U *///#define CHAR_TAB	L'\t'	SIMPLE_INPUT_INTERFACE *ip = systab->ConIn;	EFI_INPUT_KEY key;	EFI_STATUS status;	INTN pos = 0, ret;	INT8 first_time = 1;	/* 	 * let's give some help first	 */	print_help(0);	print_infos(0);reprint:	buffer[pos] = CHAR_NULL;	Print(L"\nELILO boot: %s", buffer);	/*	 * autoboot with default choice after timeout expires	 */	if (first_time && (ret=wait_timeout(elilo_opt.timeout)) != 1) {		return ret == -1 ? -1: 0;	}	first_time = 0;	for (;;) {		while ((status=ip->ReadKeyStroke(ip, &key)) == EFI_NOT_READY);		if (EFI_ERROR(status)) {			ERR_PRT((L"select_kernel readkey: %r", status));			return -1;		} 		switch (key.UnicodeChar) {			case CHAR_TAB:				Print(L"\n");				if (pos == 0) {					print_label_list();					Print(L"(or a kernel file name: [[dev_name:/]path/]kernel_image cmdline options)\n");				} else {					buffer[pos] = CHAR_NULL;					display_label_info(buffer);				}				goto reprint;			case L'%':				if (pos>0) goto normal_char;				Print(L"\n");				print_vars();				goto reprint;			case L'?':				if (pos>0) goto normal_char;				Print(L"\n");				print_help(1);				goto reprint;			case L'&':				if (pos>0) goto normal_char;				Print(L"\n");				print_infos(1);				goto reprint;			case L'=':				if (pos>0) goto normal_char;				Print(L"\n");				print_devices();				goto reprint;			case CHAR_BACKSPACE:				if (pos == 0) break;				pos--;				Print(L"\b \b");				break;			case CHAR_CTRL_U: /* clear line */				while (pos) {					Print(L"\b \b");					pos--;				}				break;			case CHAR_CTRL_C: /* kill line */				pos = 0;				goto reprint;			case CHAR_LINEFEED:			case CHAR_CARRIAGE_RETURN:				buffer[pos]   = CHAR_NULL;				Print(L"\n");				return 0;			default:normal_char:				if (key.UnicodeChar == CHAR_CTRL_D || key.ScanCode == 0x17 ) {					Print(L"\nGiving up then...\n");					return  -1;				}				if (key.UnicodeChar == CHAR_NULL) break;				if (pos > size-1) break;				buffer[pos++] = key.UnicodeChar;				/* Write the character out */				Print(L"%c", key.UnicodeChar);		}	}	return 0;}static VOIDdisplay_message(VOID){	fops_fd_t fd;	EFI_STATUS status;	INTN len, i;	CHAR16 *filename;	CHAR8 buf[256];	if ((filename = get_message_filename(0)) == NULL) return;	if (*filename == CHAR_NULL) return;	VERB_PRT(3, Print(L"opening message file %s\n", filename));	status = fops_open(filename, &fd);	if (EFI_ERROR(status)) {		VERB_PRT(3, Print(L"message file %s not found\n", filename));		return;	}	len = 256;	Print(L"\n");	while ((status = fops_read(fd, buf, &len)) == EFI_SUCCESS) {		/* XXX: ugly ! */		for (i=0; i < len; i++) {			Print(L"%c", (CHAR16)buf[i]);		}		if (len < 256) break;	}	fops_close(fd);}static INTNsimple_choose(CHAR16 **argv, INTN argc, INTN index, CHAR16 *kname, CHAR16 *cmdline){	#	define BOOT_IMG_STR	L"BOOT_IMAGE="	CHAR16 buffer[CMDLINE_MAXLEN];	CHAR16 alt_buffer[CMDLINE_MAXLEN];	CHAR16 initrd_name[CMDLINE_MAXLEN];	CHAR16 args[CMDLINE_MAXLEN];	CHAR16 devname[CMDLINE_MAXLEN];	CHAR16 dpath[FILENAME_MAXLEN];	CHAR16 *slash_pos, *colon_pos, *backslash_pos;	UINTN len;	INTN ret;	buffer[0] = alt_buffer[0] = CHAR_NULL;	display_message();restart:	initrd_name[0] = kname[0] = cmdline[0] = args[0] = CHAR_NULL;	/* reset per image loader options */	Memset(&elilo_opt.img_opt, 0, sizeof(elilo_opt.img_opt));	/*	 * check for alternate kernel image and params in EFI variable	 */	if (elilo_opt.alt_check && alternate_kernel(alt_buffer, sizeof(alt_buffer)) == 0) {		argc     = argify(alt_buffer,sizeof(alt_buffer), argv); 		alt_argv = argv;		index    = 0;		args[0]  = initrd_name[0] = 0;		/* 		 * don't check twice because the variable is deleted after		 * first access		 */		elilo_opt.alt_check = 0; 	}	if (elilo_opt.prompt) {		ret = select_kernel(buffer, sizeof(buffer));		if (ret == -1) return -1;		argc    = argify(buffer,sizeof(buffer), argv); 		index   = 0;	}	/*	 * if we found an alternate choice and the user	 * did not force it manually, then use the alternate	 * option.	 */	if (alt_buffer[0] && buffer[0] == CHAR_NULL) {		StrCpy(buffer, alt_buffer);	}	/*	 * First search for matching label in the config file	 * if options were specified on command line, they take	 * precedence over the ones in the config file	 *	 * if no match is found, the args and initrd arguments may	 * still be modified by global options in the config file.	 */	ret = find_label(argv[index], kname, args, initrd_name);	/*	 * not found, so assume first argument is kernel name and	 * not label name 	 */	if (ret == -1) {		if (argv[index]) 			StrCpy(kname, argv[index]);		else			StrCpy(kname, elilo_opt.default_kernel);	}	/*	 * no matter what happened for kname, if user specified	 * additional options, they override the ones in the	 * config file 	 */	if (argc > 1+index) {		/*StrCpy(args, argv[++index]);*/		while (++index < argc) {			StrCat(args, L" ");			StrCat(args, argv[index]);		}	}	/*	 * if initrd specified on command line, it overrides	 * the one defined in config file, if any	 */	if (elilo_opt.initrd[0] == CHAR_NULL && initrd_name[0] != CHAR_NULL) {		StrCpy(elilo_opt.initrd, initrd_name);	}	VERB_PRT(1,  { Print(L"kernel     is  '%s'\n", kname);		       Print(L"arguments  are '%s'\n", args);			if (elilo_opt.initrd[0]) Print(L"initrd      is '%s'\n", elilo_opt.initrd);		      });	if (elilo_opt.prompt == 0) {		/* minimal printing */		Print(L"ELILO\n");		ret = wait_timeout(elilo_opt.delay);		if (ret != 0) {			elilo_opt.prompt = 1;			elilo_opt.initrd[0] = CHAR_NULL;			elilo_opt.timeout =  ELILO_TIMEOUT_INFINITY;			goto restart;		}	}	/*	 * add the device name, if not already specified, 	 * so that we know where we came from	 */	slash_pos     = StrChr(kname, L'/');	backslash_pos = StrChr(kname, L'\\');	colon_pos     = StrChr(kname, L':');	if (backslash_pos && backslash_pos < slash_pos) slash_pos = backslash_pos;	if (colon_pos == NULL || (slash_pos && (slash_pos < colon_pos))) {		StrCpy(devname, fops_bootdev_name());		StrCat(devname, L":");		/* the default path is always terminated with a separator */		if (kname[0] != L'/' && kname[0] != L'\\') {			fops_getdefault_path(dpath,FILENAME_MAXLEN); 			StrCat(devname, dpath);		}	} else {		devname[0] = CHAR_NULL;	}	/*	 * create final argument list to the kernel	 */	len = StrLen(BOOT_IMG_STR)	/* BOOT_IMAGE= */	     +StrLen(devname)		/* device name */	     +StrLen(kname)		/* kernel name */	     +1				/* space */	     +StrLen(args);		/* args length */	if (len >= CMDLINE_MAXLEN-1) {		ERR_PRT((L" arguments list too long cannot fit BOOT_IMAGE\n"));		return -1;	}	StrCpy(cmdline, L"BOOT_IMAGE=");	StrCat(cmdline, devname);	StrCat(cmdline, kname);	StrCat(cmdline, L" ");	StrCat(cmdline, args);	return 0;}static INTNsimple_probe(EFI_HANDLE dev){	/* this chooser always work */	return 0;}chooser_t simple_chooser={	L"simple",	simple_probe,	simple_choose};