vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

GRUB-legacy configuration file support.

Browse source 
* Makefile.util.def (grub-menulst2cfg): New util.
	* docs/man/grub-menulst2cfg.h2m: New file.
	* grub-core/Makefile.core.def (legacycfg): New module.
	* grub-core/commands/legacycfg.c: New file.
	* grub-core/commands/menuentry.c (append_menu_entry): Rename to ...
	(grub_normal_add_menu_entry): ... this.
	* grub-core/commands/password.c (grub_cmd_password): Split main part to ...
	(grub_normal_set_password): ...this.
	* grub-core/commands/videoinfo.c (grub_cmd_videoinfo): Support MODE.
	* grub-core/loader/i386/linux.c (linux_vesafb_res): Move to ..,
	* grub-core/lib/i386/pc/vesa_modes_table.c: ... here.
	* grub-core/lib/legacy_parse.c: New file.
	* grub-core/normal/auth.c (grub_cmd_authenticate): New command.
	* include/grub/i386/pc/vesa_modes_table.h: New file.
	* include/grub/legacy_parse.h: Likewise.
	* include/grub/normal.h (grub_normal_add_menu_entry): New proto.
	* util/grub-menulst2cfg.c: New file.

	* grub-core/Makefile.core.def (lsapm): New module.
	* grub-core/commands/i386/pc/lsapm.c: New file.
	* grub-core/loader/i386/multiboot_mbi.c (make_mbi) [GRUB_MACHINE_PCBIOS]: Pass APM info.
	* grub-core/loader/multiboot_mbi2.c (make_mbi) [GRUB_MACHINE_PCBIOS]:
	Likewise.
	* include/grub/i386/pc/apm.h: New file.
	* include/multiboot.h (multiboot_apm_info): New struct.
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2010-09-18 16:21:57 +02:00
commit 9696382e79
24 changed files with 2176 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
ChangeLog
View file

@ -1,3 +1,35 @@
2010-09-18 Vladimir Serbinenko <phcoder@gmail.com>
* grub-core/Makefile.core.def (lsapm): New module.
* grub-core/commands/i386/pc/lsapm.c: New file.
* grub-core/loader/i386/multiboot_mbi.c (make_mbi) [GRUB_MACHINE_PCBIOS]: Pass APM info.
* grub-core/loader/multiboot_mbi2.c (make_mbi) [GRUB_MACHINE_PCBIOS]:
Likewise.
* include/grub/i386/pc/apm.h: New file.
* include/multiboot.h (multiboot_apm_info): New struct.
2010-09-18 Vladimir Serbinenko <phcoder@gmail.com>
GRUB-legacy configuration file support.
* Makefile.util.def (grub-menulst2cfg): New util.
* docs/man/grub-menulst2cfg.h2m: New file.
* grub-core/Makefile.core.def (legacycfg): New module.
* grub-core/commands/legacycfg.c: New file.
* grub-core/commands/menuentry.c (append_menu_entry): Rename to ...
(grub_normal_add_menu_entry): ... this.
* grub-core/commands/password.c (grub_cmd_password): Split main part to ...
(grub_normal_set_password): ...this.
* grub-core/commands/videoinfo.c (grub_cmd_videoinfo): Support MODE.
* grub-core/loader/i386/linux.c (linux_vesafb_res): Move to ..,
* grub-core/lib/i386/pc/vesa_modes_table.c: ... here.
* grub-core/lib/legacy_parse.c: New file.
* grub-core/normal/auth.c (grub_cmd_authenticate): New command.
* include/grub/i386/pc/vesa_modes_table.h: New file.
* include/grub/legacy_parse.h: Likewise.
* include/grub/normal.h (grub_normal_add_menu_entry): New proto.
* util/grub-menulst2cfg.c: New file.
2010-09-17 Colin Watson <cjwatson@ubuntu.com> 2010-09-17 Colin Watson <cjwatson@ubuntu.com>
* grub-core/kern/emu/hostdisk.c * grub-core/kern/emu/hostdisk.c

11
Makefile.util.def
View file

@ -562,3 +562,14 @@ program = {
ldadd = libgrub.a; ldadd = libgrub.a;
ldadd = '$(LIBDEVMAPPER)'; ldadd = '$(LIBDEVMAPPER)';
}; };
program = {
name = grub-menulst2cfg;
mansection = 1;
common = util/grub-menulst2cfg.c;
common = grub-core/lib/legacy_parse.c;
common = grub-core/lib/i386/pc/vesa_modes_table.c;
ldadd = libgrub.a;
ldflags = '$(LIBDEVMAPPER)';
};

3
docs/man/grub-menulst2cfg.h2m Normal file
View file

@ -0,0 +1,3 @@
[NAME]
grub-menulst2cfg \- transform legacy menu.lst into grub.cfg

15
grub-core/Makefile.core.def
View file

@ -1118,6 +1118,7 @@ module = {
module = { module = {
name = linux; name = linux;
x86 = loader/i386/linux.c; x86 = loader/i386/linux.c;
i386_pc = lib/i386/pc/vesa_modes_table.c;
mips = loader/mips/linux.c; mips = loader/mips/linux.c;
powerpc_ieee1275 = loader/powerpc/ieee1275/linux.c; powerpc_ieee1275 = loader/powerpc/ieee1275/linux.c;
sparc64_ieee1275 = loader/sparc64/ieee1275/linux.c; sparc64_ieee1275 = loader/sparc64/ieee1275/linux.c;
@ -1413,6 +1414,14 @@ module = {
common = hook/datehook.c; common = hook/datehook.c;
}; };
module = {
name = legacycfg;
common = commands/legacycfg.c;
common = lib/legacy_parse.c;
enable = i386_pc;
enable = emu;
};
module = { module = {
name = test_blockarg; name = test_blockarg;
common = tests/test_blockarg.c; common = tests/test_blockarg.c;
@ -1431,3 +1440,9 @@ module = {
name = testload; name = testload;
common = commands/testload.c; common = commands/testload.c;
}; };
module = {
name = lsapm;
common = commands/i386/pc/lsapm.c;
enable = i386_pc;
};

113
grub-core/commands/i386/pc/lsapm.c Normal file
View file

@ -0,0 +1,113 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2010 Free Software Foundation, Inc.
*
* GRUB 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/machine/int.h>
#include <grub/machine/apm.h>
#include <grub/dl.h>
#include <grub/command.h>
#include <grub/i18n.h>
int
grub_apm_get_info (struct grub_apm_info *info)
{
struct grub_bios_int_registers regs;
/* detect APM */
regs.eax = 0x5300;
regs.ebx = 0;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x15, &regs);
if (regs.flags & GRUB_CPU_INT_FLAGS_CARRY)
return 0;
info->version = regs.eax & 0xffff;
info->flags = regs.ecx & 0xffff;
/* disconnect APM first */
regs.eax = 0x5304;
regs.ebx = 0;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x15, &regs);
/* connect APM */
regs.eax = 0x5303;
regs.ebx = 0;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x15, &regs);
if (regs.flags & GRUB_CPU_INT_FLAGS_CARRY)
return 0;
info->cseg = regs.eax & 0xffff;
info->offset = regs.ebx;
info->cseg_16 = regs.ecx & 0xffff;
info->dseg = regs.edx & 0xffff;
info->cseg_len = regs.esi >> 16;
info->cseg_16_len = regs.esi & 0xffff;
info->dseg_len = regs.edi;
return 1;
}
static grub_err_t
grub_cmd_lsapm (grub_command_t cmd __attribute__ ((unused)),
int argc __attribute__ ((unused)), char **args __attribute__ ((unused)))
{
struct grub_apm_info info;
if (!grub_apm_get_info (&info))
return grub_error (GRUB_ERR_IO, "no APM found");
grub_printf ("Vesion %u.%u\n"
"32-bit CS = 0x%x, len = 0x%x, offset = 0x%x\n"
"16-bit CS = 0x%x, len = 0x%x\n"
"DS = 0x%x, len = 0x%x\n",
info.version >> 8, info.version & 0xff,
info.cseg, info.cseg_len, info.offset,
info.cseg_16, info.cseg_16_len,
info.dseg, info.dseg_len);
grub_xputs (info.flags & GRUB_APM_FLAGS_16BITPROTECTED_SUPPORTED
? "16-bit protected interface supported\n"
: "16-bit protected interface unsupported\n");
grub_xputs (info.flags & GRUB_APM_FLAGS_32BITPROTECTED_SUPPORTED
? "32-bit protected interface supported\n"
: "32-bit protected interface unsupported\n");
grub_xputs (info.flags & GRUB_APM_FLAGS_CPUIDLE_SLOWS_DOWN
? "CPU Idle slows down processor\n"
: "CPU Idle doesn't slow down processor\n");
grub_xputs (info.flags & GRUB_APM_FLAGS_DISABLED
? "APM disabled\n" : "APM enabled\n");
grub_xputs (info.flags & GRUB_APM_FLAGS_DISENGAGED
? "APM disengaged\n" : "APM engaged\n");
return GRUB_ERR_NONE;
}
static grub_command_t cmd;
GRUB_MOD_INIT(lsapm)
{
cmd = grub_register_command ("lsapm", grub_cmd_lsapm, 0,
N_("Show APM information."));
}
GRUB_MOD_FINI(lsapm)
{
grub_unregister_command (cmd);
}

781
grub-core/commands/legacycfg.c Normal file
View file

@ -0,0 +1,781 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2000, 2001, 2010 Free Software Foundation, Inc.
*
* GRUB 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/types.h>
#include <grub/misc.h>
#include <grub/command.h>
#include <grub/mm.h>
#include <grub/err.h>
#include <grub/dl.h>
#include <grub/file.h>
#include <grub/normal.h>
#include <grub/script_sh.h>
#include <grub/i18n.h>
#include <grub/term.h>
#include <grub/legacy_parse.h>
#include <grub/crypto.h>
#include <grub/auth.h>
#include <grub/disk.h>
#include <grub/partition.h>
static grub_err_t
legacy_file (const char *filename)
{
grub_file_t file;
char *entryname = NULL, *entrysrc = NULL;
grub_menu_t menu;
char *suffix = grub_strdup ("");
auto grub_err_t getline (char **line, int cont);
grub_err_t getline (char **line,
int cont __attribute__ ((unused)))
{
*line = 0;
return GRUB_ERR_NONE;
}
if (!suffix)
return grub_errno;
file = grub_file_open (filename);
if (! file)
return grub_errno;
menu = grub_env_get_menu ();
if (! menu)
{
menu = grub_zalloc (sizeof (*menu));
if (! menu)
return grub_errno;
grub_env_set_menu (menu);
}
while (1)
{
char *buf = grub_file_getline (file);
char *parsed = NULL;
if (!buf && grub_errno)
{
grub_file_close (file);
return grub_errno;
}
if (!buf)
break;
{
char *oldname = NULL;
char *newsuffix;
oldname = entryname;
parsed = grub_legacy_parse (buf, &entryname, &newsuffix);
buf = NULL;
if (newsuffix)
{
char *t;
t = suffix;
suffix = grub_realloc (suffix, grub_strlen (suffix)
+ grub_strlen (newsuffix) + 1);
if (!suffix)
{
grub_free (t);
grub_free (entrysrc);
grub_free (parsed);
grub_free (newsuffix);
grub_free (suffix);
return grub_errno;
}
grub_memcpy (suffix + grub_strlen (suffix), newsuffix,
grub_strlen (newsuffix) + 1);
grub_free (newsuffix);
newsuffix = NULL;
}
if (oldname != entryname && oldname)
{
const char **args = grub_malloc (sizeof (args[0]));
if (!args)
{
grub_file_close (file);
return grub_errno;
}
args[0] = oldname;
grub_normal_add_menu_entry (1, args, NULL, NULL, NULL, NULL,
entrysrc);
grub_free (args);
entrysrc[0] = 0;
grub_free (oldname);
}
}
if (parsed && !entryname)
{
grub_normal_parse_line (parsed, getline);
grub_print_error ();
grub_free (parsed);
parsed = NULL;
}
else if (parsed)
{
if (!entrysrc)
entrysrc = parsed;
else
{
char *t;
t = entrysrc;
entrysrc = grub_realloc (entrysrc, grub_strlen (entrysrc)
+ grub_strlen (parsed) + 1);
if (!entrysrc)
{
grub_free (t);
grub_free (parsed);
grub_free (suffix);
return grub_errno;
}
grub_memcpy (entrysrc + grub_strlen (entrysrc), parsed,
grub_strlen (parsed) + 1);
grub_free (parsed);
parsed = NULL;
}
}
}
grub_file_close (file);
if (entryname)
{
const char **args = grub_malloc (sizeof (args[0]));
if (!args)
{
grub_file_close (file);
return grub_errno;
}
args[0] = entryname;
grub_normal_add_menu_entry (1, args, NULL, NULL, NULL, NULL, entrysrc);
grub_free (args);
}
grub_normal_parse_line (suffix, getline);
grub_print_error ();
grub_free (suffix);
grub_free (entrysrc);
if (menu && menu->size)
grub_show_menu (menu, 1);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_cmd_legacy_source (struct grub_command *cmd __attribute__ ((unused)),
int argc, char **args)
{
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return legacy_file (args[0]);
}
static grub_err_t
grub_cmd_legacy_configfile (struct grub_command *cmd __attribute__ ((unused)),
int argc, char **args)
{
grub_err_t ret;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
grub_cls ();
grub_env_context_open (1);
ret = legacy_file (args[0]);
grub_env_context_close ();
return ret;
}
static enum
{
GUESS_IT, LINUX, MULTIBOOT, KFREEBSD, KNETBSD, KOPENBSD
} kernel_type;
static grub_err_t
grub_cmd_legacy_kernel (struct grub_command *mycmd __attribute__ ((unused)),
int argc, char **args)
{
int i;
int no_mem_option = 0;
struct grub_command *cmd;
char **cutargs;
int cutargc;
for (i = 0; i < 2; i++)
{
/* FIXME: really support this. */
if (argc >= 1 && grub_strcmp (args[0], "--no-mem-option") == 0)
{
no_mem_option = 1;
argc--;
args++;
continue;
}
/* linux16 handles both zImages and bzImages. */
if (argc >= 1 && (grub_strcmp (args[0], "--type=linux") == 0
|| grub_strcmp (args[0], "--type=biglinux") == 0))
{
kernel_type = LINUX;
argc--;
args++;
continue;
}
if (argc >= 1 && grub_strcmp (args[0], "--type=multiboot") == 0)
{
kernel_type = MULTIBOOT;
argc--;
args++;
continue;
}
if (argc >= 1 && grub_strcmp (args[0], "--type=freebsd") == 0)
{
kernel_type = KFREEBSD;
argc--;
args++;
continue;
}
if (argc >= 1 && grub_strcmp (args[0], "--type=openbsd") == 0)
{
kernel_type = KOPENBSD;
argc--;
args++;
continue;
}
if (argc >= 1 && grub_strcmp (args[0], "--type=netbsd") == 0)
{
kernel_type = KNETBSD;
argc--;
args++;
continue;
}
}
if (argc < 2)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "filename required");
cutargs = grub_malloc (sizeof (cutargs[0]) * (argc - 1));
cutargc = argc - 1;
grub_memcpy (cutargs + 1, args + 2, sizeof (cutargs[0]) * (argc - 2));
cutargs[0] = args[0];
do
{
/* First try Linux. */
if (kernel_type == GUESS_IT || kernel_type == LINUX)
{
cmd = grub_command_find ("linux16");
if (cmd)
{
if (!(cmd->func) (cmd, cutargc, cutargs))
{
kernel_type = LINUX;
return GRUB_ERR_NONE;
}
}
grub_errno = GRUB_ERR_NONE;
}
/* Then multiboot. */
if (kernel_type == GUESS_IT || kernel_type == MULTIBOOT)
{
cmd = grub_command_find ("multiboot");
if (cmd)
{
if (!(cmd->func) (cmd, argc, args))
{
kernel_type = MULTIBOOT;
return GRUB_ERR_NONE;
}
}
grub_errno = GRUB_ERR_NONE;
}
{
int bsd_device = -1;
int bsd_slice = -1;
int bsd_part = -1;
{
grub_device_t dev;
char *hdbiasstr;
int hdbias = 0;
hdbiasstr = grub_env_get ("legacy_hdbias");
if (hdbiasstr)
{
hdbias = grub_strtoul (hdbiasstr, 0, 0);
grub_errno = GRUB_ERR_NONE;
}
dev = grub_device_open (0);
if (dev && dev->disk
&& dev->disk->dev->id == GRUB_DISK_DEVICE_BIOSDISK_ID
&& dev->disk->dev->id >= 0x80 && dev->disk->dev->id <= 0x90)
{
struct grub_partition *part = dev->disk->partition;
bsd_device = dev->disk->id - 0x80 - hdbias;
if (part && (grub_strcmp (part->partmap->name, "netbsd") == 0
|| grub_strcmp (part->partmap->name, "openbsd") == 0
|| grub_strcmp (part->partmap->name, "bsd") == 0))
{
bsd_part = part->number;
part = part->parent;
}
if (part && grub_strcmp (part->partmap->name, "msdos") == 0)
bsd_slice = part->number;
}
}
/* k*BSD didn't really work well with grub-legacy. */
if (kernel_type == GUESS_IT || kernel_type == KFREEBSD)
{
char buf[sizeof("adXXXXXXXXXXXXsXXXXXXXXXXXXYYY")];
if (bsd_device != -1)
{
if (bsd_slice != -1 && bsd_part != -1)
grub_snprintf(buf, sizeof(buf), "ad%ds%d%c", bsd_device,
bsd_slice, 'a' + bsd_part);
else if (bsd_slice != -1)
grub_snprintf(buf, sizeof(buf), "ad%ds%d", bsd_device,
bsd_slice);
else
grub_snprintf(buf, sizeof(buf), "ad%d", bsd_device);
grub_env_set ("kFreeBSD.vfs.root.mountfrom", buf);
}
else
grub_env_unset ("kFreeBSD.vfs.root.mountfrom");
cmd = grub_command_find ("kfreebsd");
if (cmd)
{
if (!(cmd->func) (cmd, cutargc, cutargs))
{
kernel_type = KFREEBSD;
return GRUB_ERR_NONE;
}
}
grub_errno = GRUB_ERR_NONE;
}
{
char **bsdargs;
int bsdargc;
char bsddevname[sizeof ("wdXXXXXXXXXXXXY")];
if (bsd_device == -1)
{
bsdargs = cutargs;
bsdargc = cutargc;
}
else
{
bsdargc = cutargc + 2;
bsdargs = grub_malloc (sizeof (bsdargs[0]) * bsdargc);
grub_memcpy (bsdargs, args, argc * sizeof (bsdargs[0]));
bsdargs[argc] = "-r";
bsdargs[argc + 1] = bsddevname;
grub_snprintf (bsddevname, sizeof (bsddevname),
"wd%d%c", bsd_device,
bsd_part != -1 ? bsd_part + 'a' : 'c');
}
if (kernel_type == GUESS_IT || kernel_type == KNETBSD)
{
cmd = grub_command_find ("knetbsd");
if (cmd)
{
if (!(cmd->func) (cmd, bsdargc, bsdargs))
{
kernel_type = KNETBSD;
return GRUB_ERR_NONE;
}
}
grub_errno = GRUB_ERR_NONE;
}
if (kernel_type == GUESS_IT || kernel_type == KOPENBSD)
{
cmd = grub_command_find ("kopenbsd");
if (cmd)
{
if (!(cmd->func) (cmd, bsdargc, bsdargs))
{
kernel_type = KOPENBSD;
return GRUB_ERR_NONE;
}
}
grub_errno = GRUB_ERR_NONE;
}
if (bsdargs != cutargs)
grub_free (bsdargs);
}
}
}
while (0);
return grub_error (GRUB_ERR_BAD_OS, "couldn't load file %s\n",
args[0]);
}
static grub_err_t
grub_cmd_legacy_initrd (struct grub_command *mycmd __attribute__ ((unused)),
int argc, char **args)
{
struct grub_command *cmd;
if (kernel_type == LINUX)
{
cmd = grub_command_find ("initrd16");
if (!cmd)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "command initrd16 not found");
return cmd->func (cmd, argc, args);
}
if (kernel_type == MULTIBOOT)
{
cmd = grub_command_find ("module");
if (!cmd)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "command module not found");
return cmd->func (cmd, argc, args);
}
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"no kernel with module support is loaded in legacy way");
}
static grub_err_t
grub_cmd_legacy_initrdnounzip (struct grub_command *mycmd __attribute__ ((unused)),
int argc, char **args)
{
struct grub_command *cmd;
if (kernel_type == LINUX)
{
cmd = grub_command_find ("initrd16");
if (!cmd)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "command initrd16 not found");
return cmd->func (cmd, argc, args);
}
if (kernel_type == MULTIBOOT)
{
char **newargs;
grub_err_t err;
newargs = grub_malloc ((argc + 1) * sizeof (newargs[0]));
if (!newargs)
return grub_errno;
grub_memcpy (newargs + 1, args, argc * sizeof (newargs[0]));
newargs[0] = "--nounzip";
cmd = grub_command_find ("module");
if (!cmd)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "command module not found");
err = cmd->func (cmd, argc + 1, newargs);
grub_free (newargs);
return err;
}
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"no kernel with module support is loaded in legacy way");
}
static grub_err_t
check_password_deny (const char *user __attribute__ ((unused)),
const char *entered __attribute__ ((unused)),
void *password __attribute__ ((unused)))
{
return GRUB_ACCESS_DENIED;
}
#define MD5_HASHLEN 16
struct legacy_md5_password
{
grub_uint8_t *salt;
int saltlen;
grub_uint8_t hash[MD5_HASHLEN];
};
static int
check_password_md5_real (const char *entered,
struct legacy_md5_password *pw)
{
int enteredlen = grub_strlen (entered);
unsigned char alt_result[MD5_HASHLEN];
unsigned char *digest;
grub_uint8_t ctx[GRUB_MD_MD5->contextsize];
int i;
GRUB_MD_MD5->init (ctx);
GRUB_MD_MD5->write (ctx, entered, enteredlen);
GRUB_MD_MD5->write (ctx, pw->salt + 3, pw->saltlen - 3);
GRUB_MD_MD5->write (ctx, entered, enteredlen);
digest = GRUB_MD_MD5->read (ctx);
GRUB_MD_MD5->final (ctx);
memcpy (alt_result, digest, MD5_HASHLEN);
GRUB_MD_MD5->init (ctx);
GRUB_MD_MD5->write (ctx, entered, enteredlen);
GRUB_MD_MD5->write (ctx, pw->salt, pw->saltlen); /* include the $1$ header */
for (i = enteredlen; i > 16; i -= 16)
GRUB_MD_MD5->write (ctx, alt_result, 16);
GRUB_MD_MD5->write (ctx, alt_result, i);
for (i = enteredlen; i > 0; i >>= 1)
GRUB_MD_MD5->write (ctx, entered + ((i & 1) ? enteredlen : 0), 1);
digest = GRUB_MD_MD5->read (ctx);
GRUB_MD_MD5->final (ctx);
for (i = 0; i < 1000; i++)
{
memcpy (alt_result, digest, 16);
GRUB_MD_MD5->init (ctx);
if ((i & 1) != 0)
GRUB_MD_MD5->write (ctx, entered, enteredlen);
else
GRUB_MD_MD5->write (ctx, alt_result, 16);
if (i % 3 != 0)
GRUB_MD_MD5->write (ctx, pw->salt + 3, pw->saltlen - 3);
if (i % 7 != 0)
GRUB_MD_MD5->write (ctx, entered, enteredlen);
if ((i & 1) != 0)
GRUB_MD_MD5->write (ctx, alt_result, 16);
else
GRUB_MD_MD5->write (ctx, entered, enteredlen);
digest = GRUB_MD_MD5->read (ctx);
GRUB_MD_MD5->final (ctx);
}
return (grub_crypto_memcmp (digest, pw->hash, MD5_HASHLEN) == 0);
}
static grub_err_t
check_password_md5 (const char *user,
const char *entered,
void *password)
{
if (!check_password_md5_real (entered, password))
return GRUB_ACCESS_DENIED;
grub_auth_authenticate (user);
return GRUB_ERR_NONE;
}
static inline int
ib64t (char c)
{
if (c == '.')
return 0;
if (c == '/')
return 1;
if (c >= '0' && c <= '9')
return c - '0' + 2;
if (c >= 'A' && c <= 'Z')
return c - 'A' + 12;
if (c >= 'a' && c <= 'z')
return c - 'a' + 38;
return -1;
}
static struct legacy_md5_password *
parse_legacy_md5 (int argc, char **args)
{
const char *salt, *saltend;
struct legacy_md5_password *pw = NULL;
int i;
const char *p;
if (grub_memcmp (args[0], "--md5", sizeof ("--md5")) != 0)
goto fail;
if (argc == 1)
goto fail;
if (grub_strlen(args[1]) <= 3)
goto fail;
salt = args[1];
saltend = grub_strchr (salt + 3, '$');
if (!saltend)
goto fail;
pw = grub_malloc (sizeof (*pw));
if (!pw)
goto fail;
p = saltend + 1;
for (i = 0; i < 5; i++)
{
int n;
grub_uint32_t w = 0;
for (n = 0; n < 4; n++)
{
int ww = ib64t(*p++);
if (ww == -1)
goto fail;
w |= ww << (n * 6);
}
pw->hash[i == 4 ? 5 : 12+i] = w & 0xff;
pw->hash[6+i] = (w >> 8) & 0xff;
pw->hash[i] = (w >> 16) & 0xff;
}
{
int n;
grub_uint32_t w = 0;
for (n = 0; n < 2; n++)
{
int ww = ib64t(*p++);
if (ww == -1)
goto fail;
w |= ww << (6 * n);
}
if (w >= 0x100)
goto fail;
pw->hash[11] = w;
}
pw->saltlen = saltend - salt;
pw->salt = (grub_uint8_t *) grub_strndup (salt, pw->saltlen);
if (!pw->salt)
goto fail;
return pw;
fail:
grub_free (pw);
return NULL;
}
static grub_err_t
grub_cmd_legacy_password (struct grub_command *mycmd __attribute__ ((unused)),
int argc, char **args)
{
struct legacy_md5_password *pw = NULL;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "arguments expected");
if (args[0][0] != '-' || args[0][1] != '-')
return grub_normal_set_password ("legacy", args[0]);
pw = parse_legacy_md5 (argc, args);
if (pw)
return grub_auth_register_authentication ("legacy", check_password_md5, pw);
else
/* This is to imitate minor difference between grub-legacy in GRUB2.
If 2 password commands are executed in a row and second one fails
on GRUB2 the password of first one is used, whereas in grub-legacy
authenthication is denied. In case of no password command was executed
early both versions deny any access. */
return grub_auth_register_authentication ("legacy", check_password_deny,
NULL);
}
static grub_err_t
grub_cmd_legacy_check_password (struct grub_command *mycmd __attribute__ ((unused)),
int argc, char **args)
{
struct legacy_md5_password *pw = NULL;
char entered[GRUB_AUTH_MAX_PASSLEN];
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "arguments expected");
grub_printf ("Enter password:");
if (!grub_password_get (entered, GRUB_AUTH_MAX_PASSLEN))
return GRUB_ACCESS_DENIED;
if (args[0][0] != '-' || args[0][1] != '-')
{
char correct[GRUB_AUTH_MAX_PASSLEN];
grub_memset (correct, 0, sizeof (correct));
grub_strncpy (correct, args[0], sizeof (correct));
if (grub_crypto_memcmp (entered, correct, GRUB_AUTH_MAX_PASSLEN) != 0)
return GRUB_ACCESS_DENIED;
return GRUB_ERR_NONE;
}
pw = parse_legacy_md5 (argc, args);
if (!pw)
return GRUB_ACCESS_DENIED;
if (!check_password_md5_real (entered, pw))
return GRUB_ACCESS_DENIED;
return GRUB_ERR_NONE;
}
static grub_command_t cmd_source, cmd_configfile, cmd_kernel, cmd_initrd;
static grub_command_t cmd_password, cmd_check_password, cmd_initrdnounzip;
GRUB_MOD_INIT(legacycfg)
{
cmd_source = grub_register_command ("legacy_source",
grub_cmd_legacy_source,
N_("FILE"), N_("Parse legacy config"));
cmd_configfile = grub_register_command ("legacy_configfile",
grub_cmd_legacy_configfile,
N_("FILE"),
N_("Parse legacy config"));
cmd_kernel = grub_register_command ("legacy_kernel",
grub_cmd_legacy_kernel,
N_("[--no-mem-option] [--type=TYPE] FILE [ARG ...]"),
N_("Simulate grub-legacy kernel command"));
cmd_initrd = grub_register_command ("legacy_initrd",
grub_cmd_legacy_initrd,
N_("FILE [ARG ...]"),
N_("Simulate grub-legacy initrd command"));
cmd_initrdnounzip = grub_register_command ("legacy_initrd_nounzip",
grub_cmd_legacy_initrdnounzip,
N_("FILE [ARG ...]"),
N_("Simulate grub-legacy modulenounzip command"));
cmd_password = grub_register_command ("legacy_password",
grub_cmd_legacy_password,
N_("[--md5] PASSWD [FILE]"),
N_("Simulate grub-legacy password command"));
cmd_check_password = grub_register_command ("legacy_check_password",
grub_cmd_legacy_check_password,
N_("[--md5] PASSWD [FILE]"),
N_("Simulate grub-legacy password command in menuentry mode"));
}
GRUB_MOD_FINI(legacycfg)
{
grub_unregister_command (cmd_source);
grub_unregister_command (cmd_configfile);
grub_unregister_command (cmd_kernel);
grub_unregister_command (cmd_initrd);
grub_unregister_command (cmd_initrdnounzip);
grub_unregister_command (cmd_password);
grub_unregister_command (cmd_check_password);
}

21
grub-core/commands/menuentry.c
View file

@ -52,10 +52,10 @@ static struct
/* Add a menu entry to the current menu context (as given by the environment /* Add a menu entry to the current menu context (as given by the environment
variable data slot `menu'). As the configuration file is read, the script variable data slot `menu'). As the configuration file is read, the script
parser calls this when a menu entry is to be created. */ parser calls this when a menu entry is to be created. */
static grub_err_t grub_err_t
append_menu_entry (int argc, const char **args, char **classes, grub_normal_add_menu_entry (int argc, const char **args, char **classes,
const char *users, const char *hotkey, const char *users, const char *hotkey,
const char *prefix, const char *sourcecode) const char *prefix, const char *sourcecode)
{ {
unsigned i; unsigned i;
int menu_hotkey = 0; int menu_hotkey = 0;
@ -243,9 +243,10 @@ grub_cmd_menuentry (grub_extcmd_context_t ctxt, int argc, char **args)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no menuentry definition"); return grub_error (GRUB_ERR_BAD_ARGUMENT, "no menuentry definition");
if (! ctxt->script) if (! ctxt->script)
return append_menu_entry (argc, (const char **) args, return grub_normal_add_menu_entry (argc, (const char **) args,
ctxt->state[0].args, ctxt->state[1].arg, ctxt->state[0].args, ctxt->state[1].arg,
ctxt->state[2].arg, 0, ctxt->state[3].arg); ctxt->state[2].arg, 0,
ctxt->state[3].arg);
src = args[argc - 1]; src = args[argc - 1];
args[argc - 1] = NULL; args[argc - 1] = NULL;
@ -258,9 +259,9 @@ grub_cmd_menuentry (grub_extcmd_context_t ctxt, int argc, char **args)
if (! prefix) if (! prefix)
return grub_errno; return grub_errno;
r = append_menu_entry (argc - 1, (const char **) args, r = grub_normal_add_menu_entry (argc - 1, (const char **) args,
ctxt->state[0].args, ctxt->state[1].arg, ctxt->state[0].args, ctxt->state[1].arg,
ctxt->state[2].arg, prefix, src + 1); ctxt->state[2].arg, prefix, src + 1);
src[len - 1] = ch; src[len - 1] = ch;
args[argc - 1] = src; args[argc - 1] = src;

23
grub-core/commands/password.c
View file

@ -40,26 +40,22 @@ check_password (const char *user, const char *entered,
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
static grub_err_t grub_err_t
grub_cmd_password (grub_command_t cmd __attribute__ ((unused)), grub_normal_set_password (const char *user, const char *password)
int argc, char **args)
{ {
grub_err_t err; grub_err_t err;
char *pass; char *pass;
int copylen; int copylen;
if (argc != 2)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments expected");
pass = grub_zalloc (GRUB_AUTH_MAX_PASSLEN); pass = grub_zalloc (GRUB_AUTH_MAX_PASSLEN);
if (!pass) if (!pass)
return grub_errno; return grub_errno;
copylen = grub_strlen (args[1]); copylen = grub_strlen (password);
if (copylen >= GRUB_AUTH_MAX_PASSLEN) if (copylen >= GRUB_AUTH_MAX_PASSLEN)
copylen = GRUB_AUTH_MAX_PASSLEN - 1; copylen = GRUB_AUTH_MAX_PASSLEN - 1;
grub_memcpy (pass, args[1], copylen); grub_memcpy (pass, password, copylen);
err = grub_auth_register_authentication (args[0], check_password, pass); err = grub_auth_register_authentication (user, check_password, pass);
if (err) if (err)
{ {
grub_free (pass); grub_free (pass);
@ -69,6 +65,15 @@ grub_cmd_password (grub_command_t cmd __attribute__ ((unused)),
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
static grub_err_t
grub_cmd_password (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
if (argc != 2)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments expected");
return grub_normal_set_password (args[0], args[1]);
}
static grub_command_t cmd; static grub_command_t cmd;
GRUB_MOD_INIT(password) GRUB_MOD_INIT(password)

46
grub-core/commands/videoinfo.c
View file

@ -25,9 +25,17 @@
#include <grub/command.h> #include <grub/command.h>
#include <grub/i18n.h> #include <grub/i18n.h>
static unsigned height, width, depth;
static int static int
hook (const struct grub_video_mode_info *info) hook (const struct grub_video_mode_info *info)
{ {
if (height && width && (info->width != width || info->height != height))
return 0;
if (depth && info->bpp != depth)
return 0;
if (info->mode_number == GRUB_VIDEO_MODE_NUMBER_INVALID) if (info->mode_number == GRUB_VIDEO_MODE_NUMBER_INVALID)
grub_printf (" "); grub_printf (" ");
else else
@ -71,12 +79,34 @@ hook (const struct grub_video_mode_info *info)
static grub_err_t static grub_err_t
grub_cmd_videoinfo (grub_command_t cmd __attribute__ ((unused)), grub_cmd_videoinfo (grub_command_t cmd __attribute__ ((unused)),
int argc __attribute__ ((unused)), int argc, char **args)
char **args __attribute__ ((unused)))
{ {
grub_video_adapter_t adapter; grub_video_adapter_t adapter;
grub_video_driver_id_t id; grub_video_driver_id_t id;
height = width = depth = 0;
if (argc)
{
char *ptr;
ptr = args[0];
width = grub_strtoul (ptr, &ptr, 0);
if (grub_errno)
return grub_errno;
if (*ptr != 'x')
return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid mode specification");
ptr++;
height = grub_strtoul (ptr, &ptr, 0);
if (grub_errno)
return grub_errno;
if (*ptr == 'x')
{
ptr++;
depth = grub_strtoul (ptr, &ptr, 0);
if (grub_errno)
return grub_errno;
}
}
#ifdef GRUB_MACHINE_PCBIOS #ifdef GRUB_MACHINE_PCBIOS
if (grub_strcmp (cmd->name, "vbeinfo") == 0) if (grub_strcmp (cmd->name, "vbeinfo") == 0)
grub_dl_load ("vbe"); grub_dl_load ("vbe");
@ -132,11 +162,15 @@ static grub_command_t cmd_vbe;
GRUB_MOD_INIT(videoinfo) GRUB_MOD_INIT(videoinfo)
{ {
cmd = grub_register_command ("videoinfo", grub_cmd_videoinfo, 0, cmd = grub_register_command ("videoinfo", grub_cmd_videoinfo, "[WxH[xD]]",
N_("List available video modes.")); N_("List available video modes. If "
"resolution is given show only modes"
" matching it."));
#ifdef GRUB_MACHINE_PCBIOS #ifdef GRUB_MACHINE_PCBIOS
cmd_vbe = grub_register_command ("vbeinfo", grub_cmd_videoinfo, 0, cmd_vbe = grub_register_command ("vbeinfo", grub_cmd_videoinfo, "[WxH[xD]]",
N_("List available video modes.")); N_("List available video modes. If "
"resolution is given show only modes"
" matching it."));
#endif #endif
} }

127
grub-core/lib/i386/pc/vesa_modes_table.c Normal file
View file

@ -0,0 +1,127 @@
#include <grub/i386/pc/vesa_modes_table.h>
/* This is the reverse of the table in [linux]/Documentation/fb/vesafb.txt
plus a few more modes based on the table in
http://en.wikipedia.org/wiki/VESA_BIOS_Extensions */
struct grub_vesa_mode_table_entry
grub_vesa_mode_table[GRUB_VESA_MODE_TABLE_END
- GRUB_VESA_MODE_TABLE_START + 1] =
{
{ 640, 400, 8 }, /* 0x300 */
{ 640, 480, 8 }, /* 0x301 */
{ 800, 600, 4 }, /* 0x302 */
{ 800, 600, 8 }, /* 0x303 */
{ 1024, 768, 4 }, /* 0x304 */
{ 1024, 768, 8 }, /* 0x305 */
{ 1280, 1024, 4 }, /* 0x306 */
{ 1280, 1024, 8 }, /* 0x307 */
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 320, 200, 15 }, /* 0x30d */
{ 320, 200, 16 }, /* 0x30e */
{ 320, 200, 24 }, /* 0x30f */
{ 640, 480, 15 }, /* 0x310 */
{ 640, 480, 16 }, /* 0x311 */
{ 640, 480, 24 }, /* 0x312 */
{ 800, 600, 15 }, /* 0x313 */
{ 800, 600, 16 }, /* 0x314 */
{ 800, 600, 24 }, /* 0x315 */
{ 1024, 768, 15 }, /* 0x316 */
{ 1024, 768, 16 }, /* 0x317 */
{ 1024, 768, 24 }, /* 0x318 */
{ 1280, 1024, 15 }, /* 0x319 */
{ 1280, 1024, 16 }, /* 0x31a */
{ 1280, 1024, 24 }, /* 0x31b */
{ 1600, 1200, 8 }, /* 0x31c */
{ 1600, 1200, 15 }, /* 0x31d */
{ 1600, 1200, 16 }, /* 0x31e */
{ 1600, 1200, 24 }, /* 0x31f */
{ 0, 0, 0 },
{ 640, 400, 15 }, /* 0x321 */
{ 640, 400, 16 }, /* 0x322 */
{ 640, 400, 24 }, /* 0x323 */
{ 640, 400, 32 }, /* 0x324 */
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 640, 480, 32 }, /* 0x329 */
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 896, 672, 8 }, /* 0x32f */
{ 896, 672, 15 }, /* 0x330 */
{ 896, 672, 16 }, /* 0x331 */
{ 896, 672, 24 }, /* 0x332 */
{ 896, 672, 32 }, /* 0x333 */
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 1600, 1200, 32 }, /* 0x342 */
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 1440, 900, 8 }, /* 0x360 */
{ 1440, 900, 15 }, /* 0x361 */
{ 1440, 900, 16 }, /* 0x362 */
{ 1440, 900, 24 }, /* 0x363 */
{ 1440, 900, 32 }, /* 0x364 */
{ 1152, 720, 8 }, /* 0x365 */
{ 1152, 720, 15 }, /* 0x366 */
{ 1152, 720, 16 }, /* 0x367 */
{ 1152, 720, 24 }, /* 0x368 */
{ 1152, 720, 32 }, /* 0x369 */
{ 1024, 640, 8 }, /* 0x36a */
{ 1024, 640, 15 }, /* 0x36b */
{ 1024, 640, 16 }, /* 0x36c */
{ 1024, 640, 24 }, /* 0x36d */
{ 1024, 640, 32 }, /* 0x36e */
{ 800, 500, 8 }, /* 0x36f */
{ 800, 500, 15 }, /* 0x370 */
{ 800, 500, 16 }, /* 0x371 */
{ 800, 500, 24 }, /* 0x372 */
{ 800, 500, 32 }, /* 0x373 */
};

698
grub-core/lib/legacy_parse.c Normal file
View file

@ -0,0 +1,698 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 1999,2000,2001,2002,2003,2004,2010 Free Software Foundation, Inc.
*
* GRUB 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/types.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/err.h>
#include <grub/legacy_parse.h>
#include <grub/i386/pc/vesa_modes_table.h>
struct legacy_command
{
const char *name;
const char *map;
const char *suffix;
unsigned suffixarg;
unsigned argc;
enum arg_type {
TYPE_VERBATIM,
TYPE_FORCE_OPTION,
TYPE_NOAPM_OPTION,
TYPE_TYPE_OR_NOMEM_OPTION,
TYPE_OPTION,
TYPE_FILE,
TYPE_FILE_NO_CONSUME,
TYPE_PARTITION,
TYPE_BOOL,
TYPE_INT,
TYPE_REST_VERBATIM,
TYPE_VBE_MODE
} argt[4];
enum {
FLAG_IGNORE_REST = 1,
FLAG_FALLBACK_AVAILABLE = 4,
FLAG_FALLBACK = 8,
FLAG_COLOR_INVERT = 16,
FLAG_NO_MENUENTRY = 32,
FLAG_MENUENTRY_ONLY = 64,
} flags;
const char *shortdesc;
const char *longdesc;
};
struct legacy_command legacy_commands[] =
{
{"blocklist", "blocklist '%s'\n", NULL, 0, 1, {TYPE_FILE}, 0, "FILE",
"Print the blocklist notation of the file FILE."},
{"boot", "boot\n", NULL, 0, 0, {}, 0, 0,
"Boot the OS/chain-loader which has been loaded."},
/* FIXME: bootp unsupported. */
{"cat", "cat '%s'\n", NULL, 0, 1, {TYPE_FILE}, 0, "FILE",
"Print the contents of the file FILE."},
{"chainloader", "chainloader %s '%s'\n", NULL, 0,
2, {TYPE_FORCE_OPTION, TYPE_FILE}, 0, "[--force] FILE",
"Load the chain-loader FILE. If --force is specified, then load it"
" forcibly, whether the boot loader signature is present or not."},
{"cmp", "cmp '%s' '%s'\n", NULL, 0,
2, {TYPE_FILE, TYPE_FILE}, FLAG_IGNORE_REST, "FILE1 FILE2",
"Compare the file FILE1 with the FILE2 and inform the different values"
" if any."},
{"color", "set color_normal='%s'; set color_highlight='%s'\n", NULL, 0,
2, {TYPE_VERBATIM, TYPE_VERBATIM},
FLAG_IGNORE_REST | FLAG_FALLBACK_AVAILABLE, "NORMAL [HIGHLIGHT]",
"Change the menu colors. The color NORMAL is used for most"
" lines in the menu, and the color HIGHLIGHT is used to highlight the"
" line where the cursor points. If you omit HIGHLIGHT, then the"
" inverted color of NORMAL is used for the highlighted line."
" The format of a color is \"FG/BG\". FG and BG are symbolic color names."
" A symbolic color name must be one of these: black, blue, green,"
" cyan, red, magenta, brown, light-gray, dark-gray, light-blue,"
" light-green, light-cyan, light-red, light-magenta, yellow and white."
" But only the first eight names can be used for BG. You can prefix"
" \"blink-\" to FG if you want a blinking foreground color."},
{"color", "set color_normal='%s'; set color_highlight='%s'\n", NULL, 0,
1, {TYPE_VERBATIM},
FLAG_IGNORE_REST | FLAG_FALLBACK | FLAG_COLOR_INVERT, NULL, NULL},
{"configfile", "legacy_configfile '%s'\n", NULL, 0, 1, {TYPE_FILE},
0, "FILE", "Load FILE as the configuration file."},
{"debug",
"if [ -z \"$debug\" ]; then set debug=all; else set debug=; fi\n", NULL, 0,
0, {}, 0, 0, "Turn on/off the debug mode."},
{"default",
"set default='%s'; if [ x\"$default\" = xsaved ]; then load_env; "
"set default=\"$saved_entry\"; fi\n", NULL, 0, 1, {TYPE_VERBATIM}, 0,
"[NUM | `saved']",
"Set the default entry to entry number NUM (if not specified, it is"
" 0, the first entry) or the entry number saved by savedefault."},
/* FIXME: dhcp unsupported. */
{"displayapm", "lsapm\n", NULL, 0, 0, {}, 0, 0,
"Display APM BIOS information."},
{"displaymem", "lsmmap\n", NULL, 0, 0, {}, 0, 0,
"Display what GRUB thinks the system address space map of the"
" machine is, including all regions of physical RAM installed."},
/* NOTE: embed unsupported. */
{"fallback", "set fallback='%s'\n", NULL, 0,
1, {TYPE_VERBATIM}, 0, "NUM...",
"Go into unattended boot mode: if the default boot entry has any"
" errors, instead of waiting for the user to do anything, it"
" immediately starts over using the NUM entry (same numbering as the"
" `default' command). This obviously won't help if the machine"
" was rebooted by a kernel that GRUB loaded."},
{"find", "search -sf '%s'\n", NULL, 0, 1, {TYPE_FILE}, 0, "FILENAME",
"Search for the filename FILENAME in all of partitions and print the list of"
" the devices which contain the file."},
/* FIXME: fstest unsupported. */
/* NOTE: The obsolete C/H/S geometry isn't shown anymore. */
{"geometry", "insmod regexp; ls -l (%s*)\n", NULL, 0, 1, {TYPE_VERBATIM}, 0, "DRIVE",
"Print the information for a drive DRIVE. "},
{"halt", "halt %s\n", NULL, 0, 1, {TYPE_NOAPM_OPTION}, 0, "[--no-apm]",
"Halt your system. If APM is available on it, turn off the power using"
" the APM BIOS, unless you specify the option `--no-apm'."},
/* FIXME: help unsupported. */ /* NUL_TERMINATE */
{"hiddenmenu", NULL,
"if sleep -i $timeout; then timeout=0; else timeout=-1; fi\n", 0,
0, {}, 0, "", "Hide the menu."},
{"hide", "parttool '%s' hidden+\n", NULL, 0, 1, {TYPE_PARTITION},
0, "PARTITION",
"Hide PARTITION by setting the \"hidden\" bit in"
" its partition type code."},
/* FIXME: ifconfig unsupported. */
/* FIXME: impsprobe unsupported. */
{"initrd", "legacy_initrd '%s' %s\n", NULL, 0, 2, {TYPE_FILE_NO_CONSUME,
TYPE_REST_VERBATIM}, 0,
"FILE [ARG ...]",
"Load an initial ramdisk FILE for a Linux format boot image and set the"
" appropriate parameters in the Linux setup area in memory."},
/* NOTE: install unsupported. */
/* FIXME: ioprobe unsupported. */
/* FIXME: really support --no-mem-option. */
{"kernel", "legacy_kernel %s %s '%s' %s\n", NULL, 0,
4, {TYPE_TYPE_OR_NOMEM_OPTION, TYPE_TYPE_OR_NOMEM_OPTION,
TYPE_FILE_NO_CONSUME, TYPE_REST_VERBATIM}, 0,
"[--no-mem-option] [--type=TYPE] FILE [ARG ...]",
"Attempt to load the primary boot image from FILE. The rest of the"
" line is passed verbatim as the \"kernel command line\". Any modules"
" must be reloaded after using this command. The option --type is used"
" to suggest what type of kernel to be loaded. TYPE must be either of"
" \"netbsd\", \"freebsd\", \"openbsd\", \"linux\", \"biglinux\" and"
" \"multiboot\". The option --no-mem-option tells GRUB not to pass a"
" Linux's mem option automatically."},
{"lock", "if ! authenticate legacy; then return; fi", NULL, 0, 0, {}, 0,
0, "Break a command execution unless the user is authenticated."},
{"makeactive", "parttool \"$root\" boot+\n", NULL, 0, 0, {}, 0, 0,
"Set the active partition on the root disk to GRUB's root device."
" This command is limited to _primary_ PC partitions on a hard disk."},
{"map", "drivemap '%s' '%s'\n", NULL, 0,
2, {TYPE_PARTITION, TYPE_PARTITION},
FLAG_IGNORE_REST, "TO_DRIVE FROM_DRIVE",
"Map the drive FROM_DRIVE to the drive TO_DRIVE. This is necessary"
" when you chain-load some operating systems, such as DOS, if such an"
" OS resides at a non-first drive."},
/* NOTE: md5crypt unsupported since GRUB has not enough entropy and this
hash shouldn't be used anymore. */
{"module", "legacy_initrd '%s' %s\n", NULL, 0, 2, {TYPE_FILE_NO_CONSUME,
TYPE_REST_VERBATIM}, 0,
"FILE [ARG ...]",
"Load a boot module FILE for a Multiboot format boot image (no"
" interpretation of the file contents is made, so users of this"
" command must know what the kernel in question expects). The"
" rest of the line is passed as the \"module command line\", like"
" the `kernel' command."},
{"modulenounzip", "legacy_initrd_nounzip '%s' %s\n", NULL, 0, 2,
{TYPE_FILE_NO_CONSUME, TYPE_REST_VERBATIM}, 0,
"FILE [ARG ...]",
"The same as `module', except that automatic decompression is"
" disabled."},
{"pager", "set pager=%s; if [ \"$pager\" = 0 ]; then "
" echo Internal pager is now off; else "
"echo Internal pager is now on; fi\n", NULL, 0,
1, {TYPE_BOOL}, FLAG_FALLBACK_AVAILABLE, "[FLAG]",
"Toggle pager mode with no argument. If FLAG is given and its value"
" is `on', turn on the mode. If FLAG is `off', turn off the mode."},
{"pager",
"if [ \"$pager\" = 1 ]; then pager=0; echo Internal pager is now off;"
"else pager=1; echo Internal pager is now on; fi\n", NULL, 0, 0, {},
FLAG_FALLBACK, NULL, NULL},
/* FIXME: partnew unsupported. */
{"parttype", "parttool '%s' type=%s\n", NULL, 0,
2, {TYPE_PARTITION, TYPE_INT}, 0,
"PART TYPE", "Change the type of the partition PART to TYPE."},
{"password", "if [ \"$superusers\" = "" ]; then superusers=legacy; fi;\n"
"legacy_password %s '%s'\n",
"menuentry \"Superuser menu\" --users \"legacy\" { configfile '%s'; }\n",
2, 3, {TYPE_OPTION, TYPE_VERBATIM, TYPE_FILE},
FLAG_IGNORE_REST | FLAG_FALLBACK_AVAILABLE | FLAG_NO_MENUENTRY,
"[--md5] PASSWD [FILE]",
"If used in the first section of a menu file, disable all"
" interactive editing control (menu entry editor and"
" command line). If the password PASSWD is entered, it loads the"
" FILE as a new config file and restarts the GRUB Stage 2. If you"
" omit the argument FILE, then GRUB just unlocks privileged"
" instructions. You can also use it in the script section, in"
" which case it will ask for the password, before continuing."
" The option --md5 tells GRUB that PASSWD is encrypted with"
" md5crypt."},
{"password", "if [ \"$superusers\" = "" ]; then superusers=legacy; fi;\n"
"legacy_password %s '%s'\n", NULL, 0, 2, {TYPE_OPTION, TYPE_VERBATIM},
FLAG_IGNORE_REST | FLAG_FALLBACK | FLAG_NO_MENUENTRY, NULL, NULL},
{"password", "if legacy_check_password %s '%s'; then configfile '%s'; "
"else return; fi\n", NULL, 2, 3, {TYPE_OPTION, TYPE_VERBATIM, TYPE_FILE},
FLAG_IGNORE_REST | FLAG_FALLBACK_AVAILABLE | FLAG_MENUENTRY_ONLY,
NULL, NULL},
{"password", "if ! legacy_check_password %s '%s'; then return fi;\n",
NULL, 0, 2, {TYPE_OPTION, TYPE_VERBATIM},
FLAG_IGNORE_REST | FLAG_FALLBACK | FLAG_MENUENTRY_ONLY, NULL, NULL},
/* NOTE: GRUB2 has a design principle of not eternally waiting for user
input. 60 seconds should be enough.
*/
{"pause", "echo %s; if ! sleep -i 60; then return; fi\n", NULL, 0, 1,
{TYPE_REST_VERBATIM}, 0,
"[MESSAGE ...]", "Print MESSAGE, then wait until a key is pressed."},
/* FIXME: rarp unsupported. */
{"read", "read_dword %s\n", NULL, 0, 1, {TYPE_INT}, 0, "ADDR",
"Read a 32-bit value from memory at address ADDR and"
" display it in hex format."},
{"reboot", "reboot\n", NULL, 0, 0, {}, 0, 0, "Reboot your system."},
{"root", "set root='%s'; set legacy_hdbias='%s'\n", NULL, 0,
2, {TYPE_PARTITION, TYPE_INT}, FLAG_FALLBACK_AVAILABLE,
"[DEVICE [HDBIAS]]",
"Set the current \"root device\" to the device DEVICE, then"
" attempt to mount it to get the partition size (for passing the"
" partition descriptor in `ES:ESI', used by some chain-loaded"
" bootloaders), the BSD drive-type (for booting BSD kernels using"
" their native boot format), and correctly determine "
" the PC partition where a BSD sub-partition is located. The"
" optional HDBIAS parameter is a number to tell a BSD kernel"
" how many BIOS drive numbers are on controllers before the current"
" one. For example, if there is an IDE disk and a SCSI disk, and your"
" FreeBSD root partition is on the SCSI disk, then use a `1' for HDBIAS."},
{"root", "echo \"$root\"\n", NULL, 0, 0, {}, FLAG_FALLBACK, NULL, NULL},
{"rootnoverify", "set root='%s'; set legacy_hdbias='%s'\n", NULL, 0,
2, {TYPE_PARTITION, TYPE_INT}, 0,
"[DEVICE [HDBIAS]]",
"Similar to `root', but don't attempt to mount the partition. This"
" is useful for when an OS is outside of the area of the disk that"
" GRUB can read, but setting the correct root device is still"
" desired. Note that the items mentioned in `root' which"
" derived from attempting the mount will NOT work correctly."},
{"rootnoverify", "echo \"$root\"\n", NULL, 0,
0, {}, FLAG_FALLBACK, NULL, NULL},
/* FIXME: support saving NUM and fallback. */
{"savedefault", "saved_entry=${chosen}; save_env saved_entry\n", NULL, 0,
0, {}, 0, "[NUM | `fallback']",
"Save the current entry as the default boot entry if no argument is"
" specified. If a number is specified, this number is saved. If"
" `fallback' is used, next fallback entry is saved."},
{"serial", "serial %s\n", NULL, 0, 1, {TYPE_REST_VERBATIM}, 0,
"[--unit=UNIT] [--port=PORT] [--speed=SPEED] [--word=WORD] "
"[--parity=PARITY] [--stop=STOP] [--device=DEV]",
"Initialize a serial device. UNIT is a digit that specifies which serial"
" device is used (e.g. 0 == COM1). If you need to specify the port number,"
" set it by --port. SPEED is the DTE-DTE speed. WORD is the word length,"
" PARITY is the type of parity, which is one of `no', `odd' and `even'."
" STOP is the length of stop bit(s). The option --device can be used only"
" in the grub shell, which specifies the file name of a tty device. The"
" default values are COM1, 9600, 8N1."},
/* FIXME: setkey unsupported. */ /* NUL_TERMINATE */
/* NOTE: setup unsupported. */
/* FIXME: terminal unsupported. */ /* NUL_TERMINATE */
/* FIXME: terminfo unsupported. */ /* NUL_TERMINATE */
{"testload", "cat '%s'\n", NULL, 0, 1, {TYPE_FILE}, 0, "FILE",
"Read the entire contents of FILE in several different ways and"
" compares them, to test the filesystem code. "
" If this test succeeds, then a good next"
" step is to try loading a kernel."},
{"testvbe", "insmod vbe; videotest '%s'\n", NULL, 0, 1, {TYPE_VBE_MODE}, 0,
"MODE", "Test the VBE mode MODE. Hit any key to return."},
/* FIXME: tftpserver unsupported. */
{"timeout", "set timeout=%s\n", NULL, 0, 1, {TYPE_INT}, 0, "SEC",
"Set a timeout, in SEC seconds, before automatically booting the"
" default entry (normally the first entry defined)."},
/* title is handled separately. */
{"unhide", "parttool '%s' hidden-\n", NULL, 0,
1, {TYPE_PARTITION}, 0, "PARTITION",
"Unhide PARTITION by clearing the \"hidden\" bit in its"
" partition type code."},
/* FIXME: uppermem unsupported. */
{"uuid", "search --set=root --fs-uuid '%s'\n", NULL, 0, 1, {TYPE_VERBATIM},
0, "UUID", "Find root by UUID"},
{"vbeprobe", "insmod vbe; videoinfo '%s'\n", NULL, 0, 1, {TYPE_VBE_MODE},
FLAG_FALLBACK_AVAILABLE, "[MODE]",
"Probe VBE information. If the mode number MODE is specified, show only"
" the information about only the mode."},
{"vbeprobe", "insmod vbe; videoinfo\n", NULL, 0, 0, {},
FLAG_FALLBACK, NULL, NULL}
};
char *
grub_legacy_escape (const char *in, grub_size_t len)
{
const char *ptr;
char *ret, *outptr;
int overhead = 0;
for (ptr = in; ptr < in + len && *ptr; ptr++)
if (*ptr == '\'' || *ptr == '\\')
overhead++;
ret = grub_malloc (ptr - in + overhead + 1);
if (!ret)
return NULL;
outptr = ret;
for (ptr = in; ptr < in + len && *ptr; ptr++)
{
if (*ptr == '\'' || *ptr == '\\')
*outptr++ = '\\';
*outptr++ = *ptr;
}
*outptr++ = 0;
return ret;
}
static char *
adjust_file (const char *in, grub_size_t len)
{
const char *comma, *ptr, *rest;
char *ret, *outptr;
int overhead = 0;
int part = -1, subpart = -1;
if (in[0] != '(')
return grub_legacy_escape (in, len);
for (ptr = in + 1; ptr < in + len && *ptr && *ptr != ')'
&& *ptr != ','; ptr++)
if (*ptr == '\'' || *ptr == '\\')
overhead++;
comma = ptr;
if (*comma != ',')
return grub_legacy_escape (in, len);
part = grub_strtoull (comma + 1, (char **) &rest, 0);
if (rest[0] == ',' && rest[1] >= 'a' && rest[1] <= 'z')
{
subpart = rest[1] - 'a';
rest += 2;
}
for (ptr = rest; ptr < in + len && *ptr; ptr++)
if (*ptr == '\'' || *ptr == '\\')
overhead++;
/* 35 is enough for any 2 numbers. */
ret = grub_malloc (ptr - in + overhead + 35);
if (!ret)
return NULL;
outptr = ret;
for (ptr = in; ptr < in + len && ptr <= comma; ptr++)
{
if (*ptr == '\'' || *ptr == '\\')
*outptr++ = '\\';
*outptr++ = *ptr;
}
if (subpart != -1)
grub_snprintf (outptr, 35, "%d,%d", part + 1, subpart + 1);
else
grub_snprintf (outptr, 35, "%d", part + 1);
while (*outptr)
outptr++;
for (ptr = rest; ptr < in + len; ptr++)
{
if (*ptr == '\'' || *ptr == '\\')
*outptr++ = '\\';
*outptr++ = *ptr;
}
*outptr = 0;
return ret;
}
static int
check_option (const char *a, char *b, grub_size_t len)
{
if (grub_strlen (b) != len)
return 0;
return grub_strncmp (a, b, len) == 0;
}
static int
is_option (enum arg_type opt, const char *curarg, grub_size_t len)
{
switch (opt)
{
case TYPE_NOAPM_OPTION:
return check_option (curarg, "--no-apm", len);
case TYPE_FORCE_OPTION:
return check_option (curarg, "--force", len);
case TYPE_TYPE_OR_NOMEM_OPTION:
return check_option (curarg, "--type=netbsd", len)
|| check_option (curarg, "--type=freebsd", len)
|| check_option (curarg, "--type=openbsd", len)
|| check_option (curarg, "--type=linux", len)
|| check_option (curarg, "--type=biglinux", len)
|| check_option (curarg, "--type=multiboot", len)
|| check_option (curarg, "--no-mem-option", len);
case TYPE_OPTION:
return (len >= 2 && curarg[0] == '-' && curarg[1] == '-');
default:
return 0;
}
}
char *
grub_legacy_parse (const char *buf, char **entryname, char **suffix)
{
const char *ptr;
const char *cmdname;
unsigned i, cmdnum;
*suffix = NULL;
for (ptr = buf; *ptr && grub_isspace (*ptr); ptr++);
if (!*ptr || *ptr == '#')
{
char *ret;
int len = grub_strlen (buf);
ret = grub_malloc (len + 2);
grub_memcpy (ret, buf, len);
if (len && ret[len - 1] == '\n')
ret[len] = 0;
else
{
ret[len] = '\n';
ret[len + 1] = 0;
}
return ret;
}
cmdname = ptr;
for (ptr = buf; *ptr && !grub_isspace (*ptr) && *ptr != '='; ptr++);
if (entryname && grub_strncmp ("title", cmdname, ptr - cmdname) == 0
&& ptr - cmdname == sizeof ("title") - 1)
{
const char *ptr2;
for (; grub_isspace (*ptr) || *ptr == '='; ptr++);
ptr2 = ptr + grub_strlen (ptr);
while (ptr2 > ptr && grub_isspace (*(ptr2 - 1)))
ptr2--;
*entryname = grub_strndup (ptr, ptr2 - ptr);
return NULL;
}
for (cmdnum = 0; cmdnum < ARRAY_SIZE (legacy_commands); cmdnum++)
if (grub_strncmp (legacy_commands[cmdnum].name, cmdname, ptr - cmdname) == 0
&& legacy_commands[cmdnum].name[ptr - cmdname] == 0
&& (!(*entryname != NULL && (legacy_commands[cmdnum].flags
& FLAG_NO_MENUENTRY)))
&& (!(*entryname == NULL && (legacy_commands[cmdnum].flags
& FLAG_MENUENTRY_ONLY))))
break;
if (cmdnum == ARRAY_SIZE (legacy_commands))
return grub_xasprintf ("# Unsupported legacy command: %s\n", buf);
for (; grub_isspace (*ptr) || *ptr == '='; ptr++);
char *args[ARRAY_SIZE (legacy_commands[0].argt)];
grub_memset (args, 0, sizeof (args));
{
int hold_arg = 0;
const char *curarg = NULL;
for (i = 0; i < legacy_commands[cmdnum].argc; i++)
{
grub_size_t curarglen;
if (hold_arg)
{
ptr = curarg;
hold_arg = 0;
}
for (; grub_isspace (*ptr); ptr++);
curarg = ptr;
if (!*curarg)
break;
for (; *ptr && !grub_isspace (*ptr); ptr++);
if (i != legacy_commands[cmdnum].argc - 1
|| (legacy_commands[cmdnum].flags & FLAG_IGNORE_REST))
curarglen = ptr - curarg;
else
{
curarglen = grub_strlen (curarg);
while (curarglen > 0 && grub_isspace (curarg[curarglen - 1]))
curarglen--;
}
if (*ptr)
ptr++;
switch (legacy_commands[cmdnum].argt[i])
{
case TYPE_FILE_NO_CONSUME:
hold_arg = 1;
case TYPE_PARTITION:
case TYPE_FILE:
args[i] = adjust_file (curarg, curarglen);
break;
case TYPE_REST_VERBATIM:
{
char *outptr, *outptr0;
int overhead = 3;
ptr = curarg;
while (*ptr)
{
for (; *ptr && grub_isspace (*ptr); ptr++);
for (; *ptr && !grub_isspace (*ptr); ptr++)
if (*ptr == '\\' || *ptr == '\'')
overhead++;
if (*ptr)
ptr++;
overhead += 3;
}
outptr0 = args[i] = grub_malloc (overhead + (ptr - curarg));
if (!outptr0)
return NULL;
ptr = curarg;
outptr = outptr0;
while (*ptr)
{
for (; *ptr && grub_isspace (*ptr); ptr++);
if (outptr != outptr0)
*outptr++ = ' ';
*outptr++ = '\'';
for (; *ptr && !grub_isspace (*ptr); ptr++)
{
if (*ptr == '\\' || *ptr == '\'')
*outptr++ = '\\';
*outptr++ = *ptr;
}
*outptr++ = '\'';
if (*ptr)
ptr++;
}
*outptr++ = 0;
}
break;
case TYPE_VERBATIM:
args[i] = grub_legacy_escape (curarg, curarglen);
break;
case TYPE_FORCE_OPTION:
case TYPE_NOAPM_OPTION:
case TYPE_TYPE_OR_NOMEM_OPTION:
case TYPE_OPTION:
if (is_option (legacy_commands[cmdnum].argt[i], curarg, curarglen))
{
args[i] = grub_strndup (curarg, curarglen);
break;
}
args[i] = grub_strdup ("");
hold_arg = 1;
break;
case TYPE_INT:
{
const char *brk;
int base = 10;
brk = curarg;
if (brk[0] == '0' && brk[1] == 'x')
base = 16;
else if (brk[0] == '0')
base = 8;
for (; *brk && brk < curarg + curarglen; brk++)
{
if (base == 8 && (*brk == '8' || *brk == '9'))
break;
if (grub_isdigit (*brk))
continue;
if (base != 16)
break;
if (!(*brk >= 'a' && *brk <= 'f')
&& !(*brk >= 'A' && *brk <= 'F'))
break;
}
if (brk == curarg)
args[i] = grub_strdup ("0");
else
args[i] = grub_strndup (curarg, brk - curarg);
}
break;
case TYPE_VBE_MODE:
{
unsigned mod;
struct grub_vesa_mode_table_entry *modedesc;
mod = grub_strtoul (curarg, 0, 0);
if (grub_errno)
{
mod = 0;
grub_errno = GRUB_ERR_NONE;
}
if (mod < GRUB_VESA_MODE_TABLE_START
|| mod > GRUB_VESA_MODE_TABLE_END)
{
args[i] = grub_strdup ("auto");
break;
}
modedesc = &grub_vesa_mode_table[mod - GRUB_VESA_MODE_TABLE_START];
if (!modedesc->width)
{
args[i] = grub_strdup ("auto");
break;
}
args[i] = grub_xasprintf ("%ux%ux%u",
modedesc->width, modedesc->height,
modedesc->depth);
break;
}
case TYPE_BOOL:
if (curarglen == 2 && curarg[0] == 'o' && curarg[1] == 'n')
args[i] = grub_strdup ("1");
else
args[i] = grub_strdup ("0");
break;
}
}
}
while (legacy_commands[cmdnum].argc > 0
&& args[legacy_commands[cmdnum].argc - 1] == NULL
&& (legacy_commands[cmdnum].flags & FLAG_FALLBACK_AVAILABLE)
&& args[legacy_commands[cmdnum + 1].argc] == NULL)
cmdnum++;
for (; i < legacy_commands[cmdnum].argc; i++)
switch (legacy_commands[cmdnum].argt[i])
{
case TYPE_FILE_NO_CONSUME:
case TYPE_PARTITION:
case TYPE_FILE:
case TYPE_REST_VERBATIM:
case TYPE_VERBATIM:
case TYPE_FORCE_OPTION:
case TYPE_NOAPM_OPTION:
case TYPE_TYPE_OR_NOMEM_OPTION:
case TYPE_OPTION:
args[i] = grub_strdup ("");
break;
case TYPE_BOOL:
case TYPE_INT:
args[i] = grub_strdup ("0");
break;
case TYPE_VBE_MODE:
args[i] = grub_strdup ("auto");
break;
}
if (legacy_commands[cmdnum].flags & FLAG_COLOR_INVERT)
{
char *corig = args[legacy_commands[cmdnum].argc - 1];
char *slash = grub_strchr (corig, '/');
char *invert;
grub_size_t len;
len = grub_strlen (corig);
if (!slash)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "bad color specification %s",
args[0]);
return NULL;
}
invert = grub_malloc (len + 1);
if (!invert)
return NULL;
grub_memcpy (invert, slash + 1, len - (slash - corig) - 1);
invert[len - (slash - args[0]) - 1] = '/';
grub_memcpy (invert + len - (slash - corig), corig, slash - corig);
invert[len] = 0;
args[legacy_commands[cmdnum].argc] = invert;
}
if (legacy_commands[cmdnum].suffix)
{
*suffix = grub_xasprintf (legacy_commands[cmdnum].suffix,
args[legacy_commands[cmdnum].suffixarg]);
if (*suffix)
return NULL;
}
{
char *ret = grub_xasprintf (legacy_commands[cmdnum].map, args[0], args[1],
args[2], args[3]);
grub_free (args[0]);
grub_free (args[1]);
grub_free (args[2]);
grub_free (args[3]);
return ret;
}
}

190
grub-core/loader/i386/linux.c
View file

@ -35,6 +35,10 @@
#include <grub/i386/relocator.h> #include <grub/i386/relocator.h>
#include <grub/i18n.h> #include <grub/i18n.h>
#ifdef GRUB_MACHINE_PCBIOS
#include <grub/i386/pc/vesa_modes_table.h>
#endif
#ifdef GRUB_MACHINE_EFI #ifdef GRUB_MACHINE_EFI
#include <grub/efi/efi.h> #include <grub/efi/efi.h>
#define HAS_VGA_TEXT 0 #define HAS_VGA_TEXT 0
@ -89,175 +93,6 @@ static struct idt_descriptor idt_desc =
}; };
#endif #endif
#ifdef GRUB_MACHINE_PCBIOS
struct linux_vesafb_res
{
grub_uint16_t width;
grub_uint16_t height;
};
struct linux_vesafb_mode
{
grub_uint8_t res_index;
grub_uint8_t depth;
};
enum vga_modes
{
VGA_320_200,
VGA_640_400,
VGA_640_480,
VGA_800_500,
VGA_800_600,
VGA_896_672,
VGA_1024_640,
VGA_1024_768,
VGA_1152_720,
VGA_1280_1024,
VGA_1440_900,
VGA_1600_1200,
};
static struct linux_vesafb_res linux_vesafb_res[] =
{
{ 320, 200 },
{ 640, 400 },
{ 640, 480 },
{ 800, 500 },
{ 800, 600 },
{ 896, 672 },
{ 1024, 640 },
{ 1024, 768 },
{ 1152, 720 },
{ 1280, 1024 },
{ 1440, 900 },
{ 1600, 1200 },
};
/* This is the reverse of the table in [linux]/Documentation/fb/vesafb.txt
plus a few more modes based on the table in
http://en.wikipedia.org/wiki/VESA_BIOS_Extensions */
struct linux_vesafb_mode linux_vesafb_modes[] =
{
{ VGA_640_400, 8 }, /* 0x300 */
{ VGA_640_480, 8 }, /* 0x301 */
{ VGA_800_600, 4 }, /* 0x302 */
{ VGA_800_600, 8 }, /* 0x303 */
{ VGA_1024_768, 4 }, /* 0x304 */
{ VGA_1024_768, 8 }, /* 0x305 */
{ VGA_1280_1024, 4 }, /* 0x306 */
{ VGA_1280_1024, 8 }, /* 0x307 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_320_200, 15 }, /* 0x30d */
{ VGA_320_200, 16 }, /* 0x30e */
{ VGA_320_200, 24 }, /* 0x30f */
{ VGA_640_480, 15 }, /* 0x310 */
{ VGA_640_480, 16 }, /* 0x311 */
{ VGA_640_480, 24 }, /* 0x312 */
{ VGA_800_600, 15 }, /* 0x313 */
{ VGA_800_600, 16 }, /* 0x314 */
{ VGA_800_600, 24 }, /* 0x315 */
{ VGA_1024_768, 15 }, /* 0x316 */
{ VGA_1024_768, 16 }, /* 0x317 */
{ VGA_1024_768, 24 }, /* 0x318 */
{ VGA_1280_1024, 15 }, /* 0x319 */
{ VGA_1280_1024, 16 }, /* 0x31a */
{ VGA_1280_1024, 24 }, /* 0x31b */
{ VGA_1600_1200, 8 }, /* 0x31c */
{ VGA_1600_1200, 15 }, /* 0x31d */
{ VGA_1600_1200, 16 }, /* 0x31e */
{ VGA_1600_1200, 24 }, /* 0x31f */
{ 0, 0 },
{ VGA_640_400, 15 }, /* 0x321 */
{ VGA_640_400, 16 }, /* 0x322 */
{ VGA_640_400, 24 }, /* 0x323 */
{ VGA_640_400, 32 }, /* 0x324 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_640_480, 32 }, /* 0x329 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_896_672, 8 }, /* 0x32f */
{ VGA_896_672, 15 }, /* 0x330 */
{ VGA_896_672, 16 }, /* 0x331 */
{ VGA_896_672, 24 }, /* 0x332 */
{ VGA_896_672, 32 }, /* 0x333 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_1600_1200, 32 }, /* 0x342 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_1440_900, 8 }, /* 0x360 */
{ VGA_1440_900, 15 }, /* 0x361 */
{ VGA_1440_900, 16 }, /* 0x362 */
{ VGA_1440_900, 24 }, /* 0x363 */
{ VGA_1440_900, 32 }, /* 0x364 */
{ VGA_1152_720, 8 }, /* 0x365 */
{ VGA_1152_720, 15 }, /* 0x366 */
{ VGA_1152_720, 16 }, /* 0x367 */
{ VGA_1152_720, 24 }, /* 0x368 */
{ VGA_1152_720, 32 }, /* 0x369 */
{ VGA_1024_640, 8 }, /* 0x36a */
{ VGA_1024_640, 15 }, /* 0x36b */
{ VGA_1024_640, 16 }, /* 0x36c */
{ VGA_1024_640, 24 }, /* 0x36d */
{ VGA_1024_640, 32 }, /* 0x36e */
{ VGA_800_500, 8 }, /* 0x36f */
{ VGA_800_500, 15 }, /* 0x370 */
{ VGA_800_500, 16 }, /* 0x371 */
{ VGA_800_500, 24 }, /* 0x372 */
{ VGA_800_500, 32 }, /* 0x373 */
};
#endif
static inline grub_size_t static inline grub_size_t
page_align (grub_size_t size) page_align (grub_size_t size)
{ {
@ -882,7 +717,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
/* Video mode selection support. */ /* Video mode selection support. */
char *val = argv[i] + 4; char *val = argv[i] + 4;
unsigned vid_mode = GRUB_LINUX_VID_MODE_NORMAL; unsigned vid_mode = GRUB_LINUX_VID_MODE_NORMAL;
struct linux_vesafb_mode *linux_mode; struct grub_vesa_mode_table_entry *linux_mode;
grub_err_t err; grub_err_t err;
char *buf; char *buf;
@ -925,9 +760,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
break; break;
default: default:
/* Ignore invalid values. */ /* Ignore invalid values. */
if (vid_mode < GRUB_LINUX_VID_MODE_VESA_START || if (vid_mode < GRUB_VESA_MODE_TABLE_START ||
vid_mode >= GRUB_LINUX_VID_MODE_VESA_START + vid_mode > GRUB_VESA_MODE_TABLE_END)
ARRAY_SIZE (linux_vesafb_modes))
{ {
grub_env_set ("gfxpayload", "text"); grub_env_set ("gfxpayload", "text");
grub_printf ("%s is deprecated. Mode %d isn't recognized. " grub_printf ("%s is deprecated. Mode %d isn't recognized. "
@ -941,15 +775,13 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
is built-in because `vga=' parameter was used. */ is built-in because `vga=' parameter was used. */
params->have_vga = GRUB_VIDEO_LINUX_TYPE_VESA; params->have_vga = GRUB_VIDEO_LINUX_TYPE_VESA;
linux_mode linux_mode = &grub_vesa_mode_table[vid_mode
= &linux_vesafb_modes[vid_mode - GRUB_LINUX_VID_MODE_VESA_START]; - GRUB_VESA_MODE_TABLE_START];
buf = grub_xasprintf ("%ux%ux%u,%ux%u", buf = grub_xasprintf ("%ux%ux%u,%ux%u",
linux_vesafb_res[linux_mode->res_index].width, linux_mode->width, linux_mode->height,
linux_vesafb_res[linux_mode->res_index].height,
linux_mode->depth, linux_mode->depth,
linux_vesafb_res[linux_mode->res_index].width, linux_mode->width, linux_mode->height);
linux_vesafb_res[linux_mode->res_index].height);
if (! buf) if (! buf)
goto fail; goto fail;

27
grub-core/loader/i386/multiboot_mbi.c
View file

@ -20,6 +20,7 @@
#include <grub/memory.h> #include <grub/memory.h>
#ifdef GRUB_MACHINE_PCBIOS #ifdef GRUB_MACHINE_PCBIOS
#include <grub/machine/biosnum.h> #include <grub/machine/biosnum.h>
#include <grub/machine/apm.h>
#endif #endif
#include <grub/multiboot.h> #include <grub/multiboot.h>
#include <grub/cpu/relocator.h> #include <grub/cpu/relocator.h>
@ -194,7 +195,8 @@ grub_multiboot_get_mbi_size (void)
+ ALIGN_UP (sizeof(PACKAGE_STRING), 4) + ALIGN_UP (sizeof(PACKAGE_STRING), 4)
+ grub_get_multiboot_mmap_count () * sizeof (struct multiboot_mmap_entry) + grub_get_multiboot_mmap_count () * sizeof (struct multiboot_mmap_entry)
+ elf_sec_entsize * elf_sec_num + elf_sec_entsize * elf_sec_num
+ 256 * sizeof (struct multiboot_color); + 256 * sizeof (struct multiboot_color)
+ ALIGN_UP (sizeof (struct multiboot_apm_info), 4);
} }
/* Fill previously allocated Multiboot mmap. */ /* Fill previously allocated Multiboot mmap. */
@ -356,6 +358,29 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
ptrorig += ALIGN_UP (sizeof(PACKAGE_STRING), 4); ptrorig += ALIGN_UP (sizeof(PACKAGE_STRING), 4);
ptrdest += ALIGN_UP (sizeof(PACKAGE_STRING), 4); ptrdest += ALIGN_UP (sizeof(PACKAGE_STRING), 4);
#ifdef GRUB_MACHINE_PCBIOS
{
struct grub_apm_info info;
if (grub_apm_get_info (&info))
{
struct multiboot_apm_info *mbinfo = (void *) ptrorig;
mbinfo->cseg = info.cseg;
mbinfo->offset = info.offset;
mbinfo->cseg_16 = info.cseg_16;
mbinfo->dseg = info.dseg;
mbinfo->flags = info.flags;
mbinfo->cseg_len = info.cseg_len;
mbinfo->dseg_len = info.dseg_len;
mbinfo->cseg_16_len = info.cseg_16_len;
mbinfo->version = info.version;
ptrorig += ALIGN_UP (sizeof (struct multiboot_apm_info), 4);
ptrdest += ALIGN_UP (sizeof (struct multiboot_apm_info), 4);
}
}
#endif
if (modcnt) if (modcnt)
{ {
mbi->flags |= MULTIBOOT_INFO_MODS; mbi->flags |= MULTIBOOT_INFO_MODS;

2
grub-core/loader/multiboot.c
View file

@ -21,10 +21,8 @@
* FIXME: The following features from the Multiboot specification still * FIXME: The following features from the Multiboot specification still
* need to be implemented: * need to be implemented:
* - VBE support * - VBE support
* - symbol table
* - drives table * - drives table
* - ROM configuration table * - ROM configuration table
* - APM table
*/ */
#include <grub/loader.h> #include <grub/loader.h>

29
grub-core/loader/multiboot_mbi2.c
View file

@ -20,6 +20,7 @@
#include <grub/memory.h> #include <grub/memory.h>
#ifdef GRUB_MACHINE_PCBIOS #ifdef GRUB_MACHINE_PCBIOS
#include <grub/machine/biosnum.h> #include <grub/machine/biosnum.h>
#include <grub/machine/apm.h>
#endif #endif
#include <grub/multiboot.h> #include <grub/multiboot.h>
#include <grub/cpu/multiboot.h> #include <grub/cpu/multiboot.h>
@ -279,7 +280,8 @@ grub_multiboot_get_mbi_size (void)
+ elf_sec_entsize * elf_sec_num + elf_sec_entsize * elf_sec_num
+ (sizeof (struct multiboot_tag_mmap) + grub_get_multiboot_mmap_count () + (sizeof (struct multiboot_tag_mmap) + grub_get_multiboot_mmap_count ()
* sizeof (struct multiboot_mmap_entry)) * sizeof (struct multiboot_mmap_entry))
+ sizeof (struct multiboot_tag_vbe) + MULTIBOOT_TAG_ALIGN - 1; + sizeof (struct multiboot_tag_vbe) + MULTIBOOT_TAG_ALIGN - 1
+ sizeof (struct multiboot_tag_apm) + MULTIBOOT_TAG_ALIGN - 1;
} }
/* Fill previously allocated Multiboot mmap. */ /* Fill previously allocated Multiboot mmap. */
@ -515,6 +517,31 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN); ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN);
} }
#ifdef GRUB_MACHINE_PCBIOS
{
struct grub_apm_info info;
if (grub_apm_get_info (&info))
{
struct multiboot_tag_apm *tag = (struct multiboot_tag_apm *) ptrorig;
tag->type = MULTIBOOT_TAG_TYPE_APM;
tag->size = sizeof (struct multiboot_tag_apm);
tag->cseg = info.cseg;
tag->offset = info.offset;
tag->cseg_16 = info.cseg_16;
tag->dseg = info.dseg;
tag->flags = info.flags;
tag->cseg_len = info.cseg_len;
tag->dseg_len = info.dseg_len;
tag->cseg_16_len = info.cseg_16_len;
tag->version = info.version;
ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN);
}
}
#endif
{ {
unsigned i; unsigned i;
struct module *cur; struct module *cur;

24
grub-core/normal/auth.c
View file

@ -248,3 +248,27 @@ grub_auth_check_authentication (const char *userlist)
return GRUB_ACCESS_DENIED; return GRUB_ACCESS_DENIED;
} }
static grub_err_t
grub_cmd_authenticate (struct grub_command *cmd __attribute__ ((unused)),
int argc, char **args)
{
return grub_auth_check_authentication ((argc >= 1) ? args[0] : "");
}
static grub_command_t cmd;
void
grub_normal_auth_init (void)
{
cmd = grub_register_command ("authenticate",
grub_cmd_authenticate,
N_("[USERLIST]"), N_("Authenticate users"));
}
void
grub_normal_auth_fini (void)
{
grub_unregister_command (cmd);
}

2
grub-core/normal/main.c
View file

@ -477,6 +477,7 @@ GRUB_MOD_INIT(normal)
/* Previously many modules depended on gzio. Be nice to user and load it. */ /* Previously many modules depended on gzio. Be nice to user and load it. */
grub_dl_load ("gzio"); grub_dl_load ("gzio");
grub_normal_auth_init ();
grub_context_init (); grub_context_init ();
grub_script_init (); grub_script_init ();
grub_menu_init (); grub_menu_init ();
@ -520,6 +521,7 @@ GRUB_MOD_FINI(normal)
grub_context_fini (); grub_context_fini ();
grub_script_fini (); grub_script_fini ();
grub_menu_fini (); grub_menu_fini ();
grub_normal_auth_fini ();
grub_xputs = grub_xputs_saved; grub_xputs = grub_xputs_saved;

48
include/grub/i386/pc/apm.h Normal file
View file

@ -0,0 +1,48 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2010 Free Software Foundation, Inc.
*
* GRUB 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_APM_MACHINE_HEADER
#define GRUB_APM_MACHINE_HEADER 1
#include <grub/types.h>
struct grub_apm_info
{
grub_uint16_t cseg;
grub_uint32_t offset;
grub_uint16_t cseg_16;
grub_uint16_t dseg;
grub_uint16_t flags;
grub_uint16_t cseg_len;
grub_uint16_t cseg_16_len;
grub_uint16_t dseg_len;
grub_uint16_t version;
};
enum
{
GRUB_APM_FLAGS_16BITPROTECTED_SUPPORTED = 1,
GRUB_APM_FLAGS_32BITPROTECTED_SUPPORTED = 2,
GRUB_APM_FLAGS_CPUIDLE_SLOWS_DOWN = 4,
GRUB_APM_FLAGS_DISABLED = 8,
GRUB_APM_FLAGS_DISENGAGED = 16,
};
int grub_apm_get_info (struct grub_apm_info *info);
#endif

1
include/grub/i386/pc/int.h
View file

@ -20,6 +20,7 @@
#define GRUB_INTERRUPT_MACHINE_HEADER 1 #define GRUB_INTERRUPT_MACHINE_HEADER 1
#include <grub/symbol.h> #include <grub/symbol.h>
#include <grub/types.h>
struct grub_bios_int_registers struct grub_bios_int_registers
{ {

19
include/grub/i386/pc/vesa_modes_table.h Normal file
View file

@ -0,0 +1,19 @@
#ifndef GRUB_VESA_MODE_TABLE_HEADER
#define GRUB_VESA_MODE_TABLE_HEADER 1
#include <grub/types.h>
#define GRUB_VESA_MODE_TABLE_START 0x300
#define GRUB_VESA_MODE_TABLE_END 0x373
struct grub_vesa_mode_table_entry {
grub_uint16_t width;
grub_uint16_t height;
grub_uint8_t depth;
};
extern struct grub_vesa_mode_table_entry
grub_vesa_mode_table[GRUB_VESA_MODE_TABLE_END
- GRUB_VESA_MODE_TABLE_START + 1];
#endif

27
include/grub/legacy_parse.h Normal file
View file

@ -0,0 +1,27 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2008 Free Software Foundation, Inc.
*
* GRUB 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_LEGACY_PARSE_HEADER
#define GRUB_LEGACY_PARSE_HEADER 1
#include <grub/types.h>
char *grub_legacy_parse (const char *buf, char **entryname, char **suffix);
char *grub_legacy_escape (const char *in, grub_size_t len);
#endif

11
include/grub/normal.h
View file

@ -115,4 +115,15 @@ void grub_normal_reset_more (void);
void grub_xputs_normal (const char *str); void grub_xputs_normal (const char *str);
grub_err_t
grub_normal_add_menu_entry (int argc, const char **args, char **classes,
const char *users, const char *hotkey,
const char *prefix, const char *sourcecode);
grub_err_t
grub_normal_set_password (const char *user, const char *password);
void grub_normal_auth_init (void);
void grub_normal_auth_fini (void);
#endif /* ! GRUB_NORMAL_HEADER */ #endif /* ! GRUB_NORMAL_HEADER */

14
include/multiboot.h
View file

@ -254,6 +254,20 @@ struct multiboot_mod_list
}; };
typedef struct multiboot_mod_list multiboot_module_t; typedef struct multiboot_mod_list multiboot_module_t;
/* APM BIOS info. */
struct multiboot_apm_info
{
grub_uint16_t version;
grub_uint16_t cseg;
grub_uint32_t offset;
grub_uint16_t cseg_16;
grub_uint16_t dseg;
grub_uint16_t flags;
grub_uint16_t cseg_len;
grub_uint16_t cseg_16_len;
grub_uint16_t dseg_len;
};
#endif /* ! ASM_FILE */ #endif /* ! ASM_FILE */
#endif /* ! MULTIBOOT_HEADER */ #endif /* ! MULTIBOOT_HEADER */

120
util/grub-menulst2cfg.c Normal file
View file

@ -0,0 +1,120 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2010 Free Software Foundation, Inc.
*
* GRUB 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/legacy_parse.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <grub/util/misc.h>
int
main (int argc, char **argv)
{
FILE *in, *out;
char *entryname = NULL;
char *buf = NULL;
size_t bufsize = 0;
char *suffix = xstrdup ("");
int suffixlen = 0;
if (argc >= 2 && argv[1][0] == '-')
{
fprintf (stdout, "Usage: %s [INFILE [OUTFILE]]\n", argv[0]);
return 0;
}
if (argc >= 2)
{
in = fopen (argv[1], "r");
if (!in)
{
fprintf (stderr, "Couldn't open %s for reading: %s\n",
argv[1], strerror (errno));
return 1;
}
}
else
in = stdin;
if (argc >= 3)
{
out = fopen (argv[2], "w");
if (!out)
{
if (in != stdin)
fclose (in);
fprintf (stderr, "Couldn't open %s for writing: %s\n",
argv[2], strerror (errno));
return 1;
}
}
else
out = stdout;
while (1)
{
char *parsed;
if (getline (&buf, &bufsize, in) < 0)
break;
{
char *oldname = NULL;
char *newsuffix;
oldname = entryname;
parsed = grub_legacy_parse (buf, &entryname, &newsuffix);
if (newsuffix)
{
suffixlen += strlen (newsuffix);
suffix = xrealloc (suffix, suffixlen + 1);
strcat (suffix, newsuffix);
}
if (oldname != entryname && oldname)
fprintf (out, "}\n\n");
if (oldname != entryname)
{
char *escaped = grub_legacy_escape (entryname, strlen (entryname));
fprintf (out, "menuentry \'%s\' {\n", escaped);
free (escaped);
free (oldname);
}
}
if (parsed)
fprintf (out, "%s%s", entryname ? " " : "", parsed);
free (parsed);
parsed = NULL;
}
if (entryname)
fprintf (out, "}\n\n");
fwrite (suffix, 1, suffixlen, out);
free (buf);
free (suffix);
free (entryname);
if (in != stdin)
fclose (in);
if (out != stdout)
fclose (out);
return 0;
}