diff --git a/ChangeLog b/ChangeLog
index d34dbd201..5b4f61e44 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -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>
 
 	* grub-core/kern/emu/hostdisk.c
diff --git a/Makefile.util.def b/Makefile.util.def
index f56eab339..e5f93b0a7 100644
--- a/Makefile.util.def
+++ b/Makefile.util.def
@@ -562,3 +562,14 @@ program = {
   ldadd = libgrub.a;
   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)';
+};
diff --git a/docs/man/grub-menulst2cfg.h2m b/docs/man/grub-menulst2cfg.h2m
new file mode 100644
index 000000000..0c0570f27
--- /dev/null
+++ b/docs/man/grub-menulst2cfg.h2m
@@ -0,0 +1,3 @@
+[NAME]
+grub-menulst2cfg \- transform legacy menu.lst into grub.cfg
+
diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 2fca91430..378dc838e 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -1118,6 +1118,7 @@ module = {
 module = {
   name = linux;
   x86 = loader/i386/linux.c;
+  i386_pc = lib/i386/pc/vesa_modes_table.c;
   mips = loader/mips/linux.c;
   powerpc_ieee1275 = loader/powerpc/ieee1275/linux.c;
   sparc64_ieee1275 = loader/sparc64/ieee1275/linux.c;
@@ -1413,6 +1414,14 @@ module = {
   common = hook/datehook.c;
 };
 
+module = {
+  name = legacycfg;
+  common = commands/legacycfg.c;
+  common = lib/legacy_parse.c;
+  enable = i386_pc;
+  enable = emu;
+};
+
 module = {
   name = test_blockarg;
   common = tests/test_blockarg.c;
@@ -1431,3 +1440,9 @@ module = {
   name = testload;
   common = commands/testload.c;
 };
+
+module = {
+  name = lsapm;
+  common = commands/i386/pc/lsapm.c;
+  enable = i386_pc;
+};
diff --git a/grub-core/commands/i386/pc/lsapm.c b/grub-core/commands/i386/pc/lsapm.c
new file mode 100644
index 000000000..30475d2ec
--- /dev/null
+++ b/grub-core/commands/i386/pc/lsapm.c
@@ -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);
+}
+
+
diff --git a/grub-core/commands/legacycfg.c b/grub-core/commands/legacycfg.c
new file mode 100644
index 000000000..463297810
--- /dev/null
+++ b/grub-core/commands/legacycfg.c
@@ -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);
+}
diff --git a/grub-core/commands/menuentry.c b/grub-core/commands/menuentry.c
index 9c4139d7d..0d863515d 100644
--- a/grub-core/commands/menuentry.c
+++ b/grub-core/commands/menuentry.c
@@ -52,10 +52,10 @@ static struct
 /* 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
    parser calls this when a menu entry is to be created.  */
-static grub_err_t
-append_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_add_menu_entry (int argc, const char **args, char **classes,
+			    const char *users, const char *hotkey,
+			    const char *prefix, const char *sourcecode)
 {
   unsigned i;
   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");
 
   if (! ctxt->script)
-    return append_menu_entry (argc, (const char **) args,
-			      ctxt->state[0].args, ctxt->state[1].arg,
-			      ctxt->state[2].arg, 0, ctxt->state[3].arg);
+    return grub_normal_add_menu_entry (argc, (const char **) args,
+				       ctxt->state[0].args, ctxt->state[1].arg,
+				       ctxt->state[2].arg, 0,
+				       ctxt->state[3].arg);
 
   src = args[argc - 1];
   args[argc - 1] = NULL;
@@ -258,9 +259,9 @@ grub_cmd_menuentry (grub_extcmd_context_t ctxt, int argc, char **args)
   if (! prefix)
     return grub_errno;
 
-  r = append_menu_entry (argc - 1, (const char **) args,
-			 ctxt->state[0].args, ctxt->state[1].arg,
-			 ctxt->state[2].arg, prefix, src + 1);
+  r = grub_normal_add_menu_entry (argc - 1, (const char **) args,
+				  ctxt->state[0].args, ctxt->state[1].arg,
+				  ctxt->state[2].arg, prefix, src + 1);
 
   src[len - 1] = ch;
   args[argc - 1] = src;
diff --git a/grub-core/commands/password.c b/grub-core/commands/password.c
index 04285254e..db5951cbb 100644
--- a/grub-core/commands/password.c
+++ b/grub-core/commands/password.c
@@ -40,26 +40,22 @@ check_password (const char *user, const char *entered,
   return GRUB_ERR_NONE;
 }
 
-static grub_err_t
-grub_cmd_password (grub_command_t cmd __attribute__ ((unused)),
-		   int argc, char **args)
+grub_err_t
+grub_normal_set_password (const char *user, const char *password)
 {
   grub_err_t err;
   char *pass;
   int copylen;
 
-  if (argc != 2)
-    return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments expected");
-
   pass = grub_zalloc (GRUB_AUTH_MAX_PASSLEN);
   if (!pass)
     return grub_errno;
-  copylen = grub_strlen (args[1]);
+  copylen = grub_strlen (password);
   if (copylen >= GRUB_AUTH_MAX_PASSLEN)
     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)
     {
       grub_free (pass);
@@ -69,6 +65,15 @@ grub_cmd_password (grub_command_t cmd __attribute__ ((unused)),
   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;
 
 GRUB_MOD_INIT(password)
diff --git a/grub-core/commands/videoinfo.c b/grub-core/commands/videoinfo.c
index 15f677e14..10f77915b 100644
--- a/grub-core/commands/videoinfo.c
+++ b/grub-core/commands/videoinfo.c
@@ -25,9 +25,17 @@
 #include <grub/command.h>
 #include <grub/i18n.h>
 
+static unsigned height, width, depth; 
+
 static int
 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)
     grub_printf ("        ");
   else
@@ -71,12 +79,34 @@ hook (const struct grub_video_mode_info *info)
 
 static grub_err_t
 grub_cmd_videoinfo (grub_command_t cmd __attribute__ ((unused)),
-		    int argc __attribute__ ((unused)),
-		    char **args __attribute__ ((unused)))
+		    int argc, char **args)
 {
   grub_video_adapter_t adapter;
   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
   if (grub_strcmp (cmd->name, "vbeinfo") == 0)
     grub_dl_load ("vbe");
@@ -132,11 +162,15 @@ static grub_command_t cmd_vbe;
 
 GRUB_MOD_INIT(videoinfo)
 {
-  cmd = grub_register_command ("videoinfo", grub_cmd_videoinfo, 0,
-			       N_("List available video modes."));
+  cmd = grub_register_command ("videoinfo", grub_cmd_videoinfo, "[WxH[xD]]",
+			       N_("List available video modes. If "
+				     "resolution is given show only modes"
+				     " matching it."));
 #ifdef GRUB_MACHINE_PCBIOS
-  cmd_vbe = grub_register_command ("vbeinfo", grub_cmd_videoinfo, 0,
-				   N_("List available video modes."));
+  cmd_vbe = grub_register_command ("vbeinfo", grub_cmd_videoinfo, "[WxH[xD]]",
+				   N_("List available video modes. If "
+				      "resolution is given show only modes"
+				      " matching it."));
 #endif
 }
 
diff --git a/grub-core/lib/i386/pc/vesa_modes_table.c b/grub-core/lib/i386/pc/vesa_modes_table.c
new file mode 100644
index 000000000..6dc4b7d8d
--- /dev/null
+++ b/grub-core/lib/i386/pc/vesa_modes_table.c
@@ -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 */
+  };
diff --git a/grub-core/lib/legacy_parse.c b/grub-core/lib/legacy_parse.c
new file mode 100644
index 000000000..6ad15dc49
--- /dev/null
+++ b/grub-core/lib/legacy_parse.c
@@ -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;
+  }
+}
diff --git a/grub-core/loader/i386/linux.c b/grub-core/loader/i386/linux.c
index cc2d20af3..9d5b7b727 100644
--- a/grub-core/loader/i386/linux.c
+++ b/grub-core/loader/i386/linux.c
@@ -35,6 +35,10 @@
 #include <grub/i386/relocator.h>
 #include <grub/i18n.h>
 
+#ifdef GRUB_MACHINE_PCBIOS
+#include <grub/i386/pc/vesa_modes_table.h>
+#endif
+
 #ifdef GRUB_MACHINE_EFI
 #include <grub/efi/efi.h>
 #define HAS_VGA_TEXT 0
@@ -89,175 +93,6 @@ static struct idt_descriptor idt_desc =
   };
 #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
 page_align (grub_size_t size)
 {
@@ -882,7 +717,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
 	/* Video mode selection support.  */
 	char *val = argv[i] + 4;
 	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;
 	char *buf;
 
@@ -925,9 +760,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
 	    break;
 	  default:
 	    /* Ignore invalid values.  */
-	    if (vid_mode < GRUB_LINUX_VID_MODE_VESA_START ||
-		vid_mode >= GRUB_LINUX_VID_MODE_VESA_START +
-		ARRAY_SIZE (linux_vesafb_modes))
+	    if (vid_mode < GRUB_VESA_MODE_TABLE_START ||
+		vid_mode > GRUB_VESA_MODE_TABLE_END)
 	      {
 		grub_env_set ("gfxpayload", "text");
 		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.  */
 	    params->have_vga = GRUB_VIDEO_LINUX_TYPE_VESA;
 
-	    linux_mode
-	      = &linux_vesafb_modes[vid_mode - GRUB_LINUX_VID_MODE_VESA_START];
+	    linux_mode = &grub_vesa_mode_table[vid_mode
+					       - GRUB_VESA_MODE_TABLE_START];
 
 	    buf = grub_xasprintf ("%ux%ux%u,%ux%u",
-				 linux_vesafb_res[linux_mode->res_index].width,
-				 linux_vesafb_res[linux_mode->res_index].height,
+				 linux_mode->width, linux_mode->height,
 				 linux_mode->depth,
-				 linux_vesafb_res[linux_mode->res_index].width,
-				 linux_vesafb_res[linux_mode->res_index].height);
+				 linux_mode->width, linux_mode->height);
 	    if (! buf)
 	      goto fail;
 
diff --git a/grub-core/loader/i386/multiboot_mbi.c b/grub-core/loader/i386/multiboot_mbi.c
index bf17863cf..2cce39746 100644
--- a/grub-core/loader/i386/multiboot_mbi.c
+++ b/grub-core/loader/i386/multiboot_mbi.c
@@ -20,6 +20,7 @@
 #include <grub/memory.h>
 #ifdef GRUB_MACHINE_PCBIOS
 #include <grub/machine/biosnum.h>
+#include <grub/machine/apm.h>
 #endif
 #include <grub/multiboot.h>
 #include <grub/cpu/relocator.h>
@@ -194,7 +195,8 @@ grub_multiboot_get_mbi_size (void)
     + ALIGN_UP (sizeof(PACKAGE_STRING), 4) 
     + grub_get_multiboot_mmap_count () * sizeof (struct multiboot_mmap_entry)
     + 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.  */
@@ -356,6 +358,29 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
   ptrorig += 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)
     {
       mbi->flags |= MULTIBOOT_INFO_MODS;
diff --git a/grub-core/loader/multiboot.c b/grub-core/loader/multiboot.c
index 8780ec061..d5cb42604 100644
--- a/grub-core/loader/multiboot.c
+++ b/grub-core/loader/multiboot.c
@@ -21,10 +21,8 @@
  *  FIXME: The following features from the Multiboot specification still
  *         need to be implemented:
  *  - VBE support
- *  - symbol table
  *  - drives table
  *  - ROM configuration table
- *  - APM table
  */
 
 #include <grub/loader.h>
diff --git a/grub-core/loader/multiboot_mbi2.c b/grub-core/loader/multiboot_mbi2.c
index f453dcc6a..2e6801252 100644
--- a/grub-core/loader/multiboot_mbi2.c
+++ b/grub-core/loader/multiboot_mbi2.c
@@ -20,6 +20,7 @@
 #include <grub/memory.h>
 #ifdef GRUB_MACHINE_PCBIOS
 #include <grub/machine/biosnum.h>
+#include <grub/machine/apm.h>
 #endif
 #include <grub/multiboot.h>
 #include <grub/cpu/multiboot.h>
@@ -279,7 +280,8 @@ grub_multiboot_get_mbi_size (void)
     + elf_sec_entsize * elf_sec_num
     + (sizeof (struct multiboot_tag_mmap) + grub_get_multiboot_mmap_count ()
        * 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.  */
@@ -515,6 +517,31 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
     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;
     struct module *cur;
diff --git a/grub-core/normal/auth.c b/grub-core/normal/auth.c
index bf1efbfdd..e5216da8c 100644
--- a/grub-core/normal/auth.c
+++ b/grub-core/normal/auth.c
@@ -248,3 +248,27 @@ grub_auth_check_authentication (const char *userlist)
 
   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);
+}
diff --git a/grub-core/normal/main.c b/grub-core/normal/main.c
index c7e83fba0..f2e5eaf51 100644
--- a/grub-core/normal/main.c
+++ b/grub-core/normal/main.c
@@ -477,6 +477,7 @@ GRUB_MOD_INIT(normal)
   /* Previously many modules depended on gzio. Be nice to user and load it.  */
   grub_dl_load ("gzio");
 
+  grub_normal_auth_init ();
   grub_context_init ();
   grub_script_init ();
   grub_menu_init ();
@@ -520,6 +521,7 @@ GRUB_MOD_FINI(normal)
   grub_context_fini ();
   grub_script_fini ();
   grub_menu_fini ();
+  grub_normal_auth_fini ();
 
   grub_xputs = grub_xputs_saved;
 
diff --git a/include/grub/i386/pc/apm.h b/include/grub/i386/pc/apm.h
new file mode 100644
index 000000000..6d9e8c61d
--- /dev/null
+++ b/include/grub/i386/pc/apm.h
@@ -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
diff --git a/include/grub/i386/pc/int.h b/include/grub/i386/pc/int.h
index e1c463925..de23775d0 100644
--- a/include/grub/i386/pc/int.h
+++ b/include/grub/i386/pc/int.h
@@ -20,6 +20,7 @@
 #define GRUB_INTERRUPT_MACHINE_HEADER	1
 
 #include <grub/symbol.h>
+#include <grub/types.h>
 
 struct grub_bios_int_registers
 {
diff --git a/include/grub/i386/pc/vesa_modes_table.h b/include/grub/i386/pc/vesa_modes_table.h
new file mode 100644
index 000000000..376ca376b
--- /dev/null
+++ b/include/grub/i386/pc/vesa_modes_table.h
@@ -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
diff --git a/include/grub/legacy_parse.h b/include/grub/legacy_parse.h
new file mode 100644
index 000000000..a5e67a071
--- /dev/null
+++ b/include/grub/legacy_parse.h
@@ -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
diff --git a/include/grub/normal.h b/include/grub/normal.h
index 51ab46b12..72912e524 100644
--- a/include/grub/normal.h
+++ b/include/grub/normal.h
@@ -115,4 +115,15 @@ void grub_normal_reset_more (void);
 
 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 */
diff --git a/include/multiboot.h b/include/multiboot.h
index fda863e85..ed71e6b96 100644
--- a/include/multiboot.h
+++ b/include/multiboot.h
@@ -254,6 +254,20 @@ struct multiboot_mod_list
 };
 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 /* ! MULTIBOOT_HEADER */
diff --git a/util/grub-menulst2cfg.c b/util/grub-menulst2cfg.c
new file mode 100644
index 000000000..512239e89
--- /dev/null
+++ b/util/grub-menulst2cfg.c
@@ -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;
+}