1.0.45 release

2. Add WIMBOOT for UEFI mode.

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/VentoyProtocol.c

@@ -148,7 +148,7 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
     ventoy_override_chunk *pOverride = g_override_chunk;
     EFI_BLOCK_IO_PROTOCOL *pRawBlockIo = gBlockData.pRawBlockIo;
     
-    debug("read iso sector %lu  count %u", Sector, Count);
+    debug("read iso sector %lu count %u Buffer:%p Align:%u", Sector, Count, Buffer, pRawBlockIo->Media->IoAlign);
 
     ReadStart = Sector * 2048;
     ReadEnd = (Sector + Count) * 2048;
@@ -173,7 +173,6 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
             {
                 MapLba = ((Sector - pchunk->img_start_sector) >> 1) + pchunk->disk_start_sector;
             }
-            
 
             secLeft = pchunk->img_end_sector + 1 - Sector;
             secRead = (Count < secLeft) ? Count : secLeft;
@@ -182,7 +181,7 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
                                      MapLba, secRead * 2048, pCurBuf);
             if (EFI_ERROR(Status))
             {
-                debug("Raw disk read block failed %r LBA:%lu Count:%u", Status, MapLba, secRead);
+                debug("Raw disk read block failed %r LBA:%lu Count:%u %p", Status, MapLba, secRead, pCurBuf);
                 return Status;
             }
 
@@ -425,7 +424,7 @@ end:
     return Lba;
 }
 
-EFI_STATUS EFIAPI ventoy_block_io_read 
+EFI_STATUS EFIAPI ventoy_block_io_read_real 
 (
     IN EFI_BLOCK_IO_PROTOCOL          *This,
     IN UINT32                          MediaId,
@@ -447,7 +446,7 @@ EFI_STATUS EFIAPI ventoy_block_io_read
     ventoy_sector_flag *cur_flag;
     ventoy_virt_chunk *node;
     
-    //debug("### ventoy_block_io_read sector:%u count:%u", (UINT32)Lba, (UINT32)BufferSize / 2048);
+    debug("### block_io_read_real sector:%u count:%u Buffer:%p", (UINT32)Lba, (UINT32)BufferSize / 2048, Buffer);
 
     secNum = BufferSize / 2048;
 
@@ -551,6 +550,42 @@ EFI_STATUS EFIAPI ventoy_block_io_read
 	return EFI_SUCCESS;
 }
 
+EFI_STATUS EFIAPI ventoy_block_io_read
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                          MediaId,
+    IN EFI_LBA                         Lba,
+    IN UINTN                           BufferSize,
+    OUT VOID                          *Buffer
+) 
+{
+    UINT32 IoAlign = 0;
+    VOID *NewBuf = NULL;
+    EFI_STATUS Status = EFI_OUT_OF_RESOURCES;
+
+    if (gBlockData.pRawBlockIo && gBlockData.pRawBlockIo->Media)
+    {
+        IoAlign = gBlockData.pRawBlockIo->Media->IoAlign;
+    }
+
+    if ((IoAlign == 0) || (((UINTN) Buffer & (IoAlign - 1)) == 0))
+    {
+        Status = ventoy_block_io_read_real(This, MediaId, Lba, BufferSize, Buffer);
+    }
+    else
+    {
+        NewBuf = AllocatePages(EFI_SIZE_TO_PAGES(BufferSize + IoAlign));
+        if (NewBuf)
+        {
+            Status = ventoy_block_io_read_real(This, MediaId, Lba, BufferSize, NewBuf);
+            CopyMem(Buffer, NewBuf, BufferSize);
+            FreePages(NewBuf, EFI_SIZE_TO_PAGES(BufferSize + IoAlign));
+        }
+    }
+
+    return Status;
+}
+
 EFI_STATUS EFIAPI ventoy_block_io_write 
 (
     IN EFI_BLOCK_IO_PROTOCOL          *This,
@@ -720,7 +755,7 @@ EFI_STATUS EFIAPI ventoy_block_io_read_512
     UINT8 *CurBuf = NULL;
     EFI_STATUS Status = EFI_SUCCESS;
 
-    debug("ventoy_block_io_read_512 %lu %lu\n", Lba, BufferSize / 512);
+    debug("ventoy_block_io_read_512 %lu %lu Buffer:%p\n", Lba, BufferSize / 512, Buffer);
 
     CurBuf = (UINT8 *)Buffer;
 

GRUB2/MOD_SRC/grub-2.04/grub-core/Makefile.core.def

@@ -1603,6 +1603,7 @@ module = {
 module = {
   name = ventoy;
   common = ventoy/ventoy.c;
+  common = ventoy/ventoy_cmd.c;
   common = ventoy/ventoy_linux.c;
   common = ventoy/ventoy_unix.c;
   common = ventoy/ventoy_windows.c;

GRUB2/MOD_SRC/grub-2.04/grub-core/commands/hashsum.c

@@ -0,0 +1,343 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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/dl.h>
+#include <grub/extcmd.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/crypto.h>
+#include <grub/normal.h>
+#include <grub/i18n.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"hash", 'h', 0, N_("Specify hash to use."), N_("HASH"), ARG_TYPE_STRING},
+  {"check", 'c', 0, N_("Check hashes of files with hash list FILE."),
+   N_("FILE"), ARG_TYPE_STRING},
+  {"prefix", 'p', 0, N_("Base directory for hash list."), N_("DIR"),
+   ARG_TYPE_STRING},
+  {"keep-going", 'k', 0, N_("Don't stop after first error."), 0, 0},
+  {"uncompress", 'u', 0, N_("Uncompress file before checksumming."), 0, 0},
+  {0, 0, 0, 0, 0, 0}
+};
+
+static struct { const char *name; const char *hashname; } aliases[] = 
+  {
+    {"sha256sum", "sha256"},
+    {"sha512sum", "sha512"},
+    {"sha1sum", "sha1"},
+    {"md5sum", "md5"},
+    {"crc", "crc32"},
+  };
+
+static inline int
+hextoval (char c)
+{
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  if (c >= 'a' && c <= 'f')
+    return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+  return -1;
+}
+
+static grub_err_t
+hash_file (grub_file_t file, const gcry_md_spec_t *hash, void *result)
+{
+  int progress = 0;
+  grub_uint64_t ro = 0;
+  grub_uint64_t div = 0;
+  grub_uint64_t total = 0;
+  void *context;
+  grub_uint8_t *readbuf;
+#define BUF_SIZE 4096
+  readbuf = grub_malloc (BUF_SIZE);
+  if (!readbuf)
+    return grub_errno;
+  context = grub_zalloc (hash->contextsize);
+  if (!readbuf || !context)
+    goto fail;
+
+  if (file->size > 16 * 1024 * 1024)
+    progress = 1;
+
+  hash->init (context);
+  while (1)
+    {
+      grub_ssize_t r;
+      r = grub_file_read (file, readbuf, BUF_SIZE);
+      if (r < 0)
+	goto fail;
+      if (r == 0)
+	break;
+      hash->write (context, readbuf, r);
+      if (progress)
+      {
+          total += r;
+          div = grub_divmod64(total * 100, (grub_uint64_t)file->size, &ro);
+          grub_printf("\rCalculating   %d%%    ", (int)div);
+          grub_refresh();
+      }
+    }
+  hash->final (context);
+  grub_memcpy (result, hash->read (context), hash->mdlen);
+
+  grub_free (readbuf);
+  grub_free (context);
+  if (progress)
+  {
+    grub_printf("\rCalculating   100%%    \n\r\n");
+    grub_refresh();      
+  }
+  return GRUB_ERR_NONE;
+
+ fail:
+  grub_free (readbuf);
+  grub_free (context);
+  return grub_errno;
+}
+
+static grub_err_t
+check_list (const gcry_md_spec_t *hash, const char *hashfilename,
+	    const char *prefix, int keep, int uncompress)
+{
+  grub_file_t hashlist, file;
+  char *buf = NULL;
+  grub_uint8_t expected[GRUB_CRYPTO_MAX_MDLEN];
+  grub_uint8_t actual[GRUB_CRYPTO_MAX_MDLEN];
+  grub_err_t err;
+  unsigned i;
+  unsigned unread = 0, mismatch = 0;
+
+  if (hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
+    return grub_error (GRUB_ERR_BUG, "mdlen is too long");
+
+  hashlist = grub_file_open (hashfilename, GRUB_FILE_TYPE_HASHLIST);
+  if (!hashlist)
+    return grub_errno;
+  
+  while (grub_free (buf), (buf = grub_file_getline (hashlist)))
+    {
+      const char *p = buf;
+      while (grub_isspace (p[0]))
+	p++;
+      for (i = 0; i < hash->mdlen; i++)
+	{
+	  int high, low;
+	  high = hextoval (*p++);
+	  low = hextoval (*p++);
+	  if (high < 0 || low < 0)
+	    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid hash list");
+	  expected[i] = (high << 4) | low;
+	}
+      if ((p[0] != ' ' && p[0] != '\t') || (p[1] != ' ' && p[1] != '\t'))
+	return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid hash list");
+      p += 2;
+      if (prefix)
+	{
+	  char *filename;
+	  
+	  filename = grub_xasprintf ("%s/%s", prefix, p);
+	  if (!filename)
+	    return grub_errno;
+	  file = grub_file_open (filename, GRUB_FILE_TYPE_TO_HASH
+				 | (!uncompress ? GRUB_FILE_TYPE_NO_DECOMPRESS
+				    : GRUB_FILE_TYPE_NONE));
+	  grub_free (filename);
+	}
+      else
+	file = grub_file_open (p, GRUB_FILE_TYPE_TO_HASH
+			       | (!uncompress ? GRUB_FILE_TYPE_NO_DECOMPRESS
+				  : GRUB_FILE_TYPE_NONE));
+      if (!file)
+	{
+	  grub_file_close (hashlist);
+	  grub_free (buf);
+	  return grub_errno;
+	}
+      err = hash_file (file, hash, actual);
+      grub_file_close (file);
+      if (err)
+	{
+	  grub_printf_ (N_("%s: READ ERROR\n"), p);
+	  if (!keep)
+	    {
+	      grub_file_close (hashlist);
+	      grub_free (buf);
+	      return err;
+	    }
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      if (grub_crypto_memcmp (expected, actual, hash->mdlen) != 0)
+	{
+	  grub_printf_ (N_("%s: HASH MISMATCH\n"), p);
+	  if (!keep)
+	    {
+	      grub_file_close (hashlist);
+	      grub_free (buf);
+	      return grub_error (GRUB_ERR_TEST_FAILURE,
+				 "hash of '%s' mismatches", p);
+	    }
+	  mismatch++;
+	  continue;	  
+	}
+      grub_printf_ (N_("%s: OK\n"), p);
+    }
+  if (mismatch || unread)
+    return grub_error (GRUB_ERR_TEST_FAILURE,
+		       "%d files couldn't be read and hash "
+		       "of %d files mismatches", unread, mismatch);
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_cmd_hashsum (struct grub_extcmd_context *ctxt,
+		  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  const char *hashname = NULL;
+  const char *prefix = NULL;
+  const gcry_md_spec_t *hash;
+  unsigned i;
+  int keep = state[3].set;
+  int uncompress = state[4].set;
+  unsigned unread = 0;
+
+  for (i = 0; i < ARRAY_SIZE (aliases); i++)
+    if (grub_strcmp (ctxt->extcmd->cmd->name, aliases[i].name) == 0)
+      hashname = aliases[i].hashname;
+  if (state[0].set)
+    hashname = state[0].arg;
+
+  if (!hashname)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no hash specified");
+
+  hash = grub_crypto_lookup_md_by_name (hashname);
+  if (!hash)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown hash");
+
+  if (hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
+    return grub_error (GRUB_ERR_BUG, "mdlen is too long");
+
+  if (state[2].set)
+    prefix = state[2].arg;
+
+  if (state[1].set)
+    {
+      if (argc != 0)
+	return grub_error (GRUB_ERR_BAD_ARGUMENT,
+			   "--check is incompatible with file list");
+      return check_list (hash, state[1].arg, prefix, keep, uncompress);
+    }
+
+  for (i = 0; i < (unsigned) argc; i++)
+    {
+      GRUB_PROPERLY_ALIGNED_ARRAY (result, GRUB_CRYPTO_MAX_MDLEN);
+      grub_file_t file;
+      grub_err_t err;
+      unsigned j;
+      file = grub_file_open (args[i], GRUB_FILE_TYPE_TO_HASH
+			     | (!uncompress ? GRUB_FILE_TYPE_NO_DECOMPRESS
+				: GRUB_FILE_TYPE_NONE));
+      if (!file)
+	{
+	  if (!keep)
+	    return grub_errno;
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      err = hash_file (file, hash, result);
+      grub_file_close (file);
+      if (err)
+	{
+	  if (!keep)
+	    return err;
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      for (j = 0; j < hash->mdlen; j++)
+	grub_printf ("%02x", ((grub_uint8_t *) result)[j]);
+      grub_printf ("  %s\n", args[i]);
+    }
+
+  if (unread)
+    return grub_error (GRUB_ERR_TEST_FAILURE, "%d files couldn't be read",
+		       unread);
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd, cmd_md5, cmd_sha1, cmd_sha256, cmd_sha512, cmd_crc;
+
+GRUB_MOD_INIT(hashsum)
+{
+  cmd = grub_register_extcmd ("hashsum", grub_cmd_hashsum, 0,
+			      N_("-h HASH [-c FILE [-p PREFIX]] "
+				 "[FILE1 [FILE2 ...]]"),
+			      /* TRANSLATORS: "hash checksum" is just to
+				 be a bit more precise, you can treat it as
+				 just "hash".  */
+			      N_("Compute or check hash checksum."),
+			      options);
+  cmd_md5 = grub_register_extcmd ("md5sum", grub_cmd_hashsum, 0,
+				  N_("[-c FILE [-p PREFIX]] "
+				     "[FILE1 [FILE2 ...]]"),
+				  N_("Compute or check hash checksum."),
+				  options);
+  cmd_sha1 = grub_register_extcmd ("sha1sum", grub_cmd_hashsum, 0,
+				   N_("[-c FILE [-p PREFIX]] "
+				      "[FILE1 [FILE2 ...]]"),
+				   N_("Compute or check hash checksum."),
+				   options);
+  cmd_sha256 = grub_register_extcmd ("sha256sum", grub_cmd_hashsum, 0,
+				     N_("[-c FILE [-p PREFIX]] "
+					"[FILE1 [FILE2 ...]]"),
+				     N_("Compute or check hash checksum."),
+				     options);
+  cmd_sha512 = grub_register_extcmd ("sha512sum", grub_cmd_hashsum, 0,
+				     N_("[-c FILE [-p PREFIX]] "
+					"[FILE1 [FILE2 ...]]"),
+				     N_("Compute or check hash checksum."),
+				     options);
+
+  cmd_crc = grub_register_extcmd ("crc", grub_cmd_hashsum, 0,
+				     N_("[-c FILE [-p PREFIX]] "
+					"[FILE1 [FILE2 ...]]"),
+				     N_("Compute or check hash checksum."),
+				     options);
+}
+
+GRUB_MOD_FINI(hashsum)
+{
+  grub_unregister_extcmd (cmd);
+  grub_unregister_extcmd (cmd_md5);
+  grub_unregister_extcmd (cmd_sha1);
+  grub_unregister_extcmd (cmd_sha256);
+  grub_unregister_extcmd (cmd_sha512);
+  grub_unregister_extcmd (cmd_crc);
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/gfxmenu/gui_label.c

@@ -29,6 +29,7 @@
 extern int g_ventoy_memdisk_mode;
 extern int g_ventoy_iso_raw;
 extern int g_ventoy_grub2_mode;
+extern int g_ventoy_wimboot_mode;
 extern int g_ventoy_iso_uefi_drv;
 
 static const char *align_options[] =
@@ -209,6 +210,9 @@ label_set_property (void *vself, const char *name, const char *value)
        else if (grub_strcmp (value, "@VTOY_GRUB2_MODE@") == 0) {
             value = g_ventoy_grub2_mode ? grub_env_get("VTOY_GRUB2_MODE_STR") : " ";
        }
+       else if (grub_strcmp (value, "@VTOY_WIMBOOT_MODE@") == 0) {
+            value = g_ventoy_wimboot_mode ? grub_env_get("VTOY_WIMBOOT_MODE_STR") : " ";
+       }
        else if (grub_strcmp (value, "@VTOY_ISO_UEFI_DRV@") == 0) {
             value = g_ventoy_iso_uefi_drv ? grub_env_get("VTOY_ISO_UEFI_DRV_STR") : " ";
        }

GRUB2/MOD_SRC/grub-2.04/grub-core/kern/efi/efi.c

@@ -964,3 +964,20 @@ void * grub_efi_allocate_iso_buf(grub_uint64_t size)
     
     return (void *)(unsigned long)address;
 }
+
+void * grub_efi_allocate_chain_buf(grub_uint64_t size)
+{
+    grub_efi_boot_services_t *b;
+    grub_efi_status_t status;
+    grub_efi_physical_address_t address = 0;
+    grub_efi_uintn_t pages = GRUB_EFI_BYTES_TO_PAGES(size);
+
+    b = grub_efi_system_table->boot_services;
+    status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ANY_PAGES, GRUB_EFI_LOADER_DATA, pages, &address);
+    if (status != GRUB_EFI_SUCCESS)
+    {
+        return NULL;
+    }
+    
+    return (void *)(unsigned long)address;
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/loader/linux.c

@@ -0,0 +1,316 @@
+#include <grub/types.h>
+#include <grub/err.h>
+#include <grub/linux.h>
+#include <grub/misc.h>
+#include <grub/file.h>
+#include <grub/mm.h>
+#include <grub/env.h>
+#include <grub/term.h>
+
+struct newc_head
+{
+  char magic[6];
+  char ino[8];
+  char mode[8];
+  char uid[8];
+  char gid[8];
+  char nlink[8];
+  char mtime[8];
+  char filesize[8];
+  char devmajor[8];
+  char devminor[8];
+  char rdevmajor[8];
+  char rdevminor[8];
+  char namesize[8];
+  char check[8];
+} GRUB_PACKED;
+
+struct grub_linux_initrd_component
+{
+  grub_file_t file;
+  char *newc_name;
+  grub_off_t size;
+};
+
+struct dir
+{
+  char *name;
+  struct dir *next;
+  struct dir *child;
+};
+
+static char
+hex (grub_uint8_t val)
+{
+  if (val < 10)
+    return '0' + val;
+  return 'a' + val - 10;
+}
+
+static void
+set_field (char *var, grub_uint32_t val)
+{
+  int i;
+  char *ptr = var;
+  for (i = 28; i >= 0; i -= 4)
+    *ptr++ = hex((val >> i) & 0xf);
+}
+
+static grub_uint8_t *
+make_header (grub_uint8_t *ptr,
+	     const char *name, grub_size_t len,
+	     grub_uint32_t mode,
+	     grub_off_t fsize)
+{
+  struct newc_head *head = (struct newc_head *) ptr;
+  grub_uint8_t *optr;
+  grub_size_t oh = 0;
+  grub_memcpy (head->magic, "070701", 6);
+  set_field (head->ino, 0);
+  set_field (head->mode, mode);
+  set_field (head->uid, 0);
+  set_field (head->gid, 0);
+  set_field (head->nlink, 1);
+  set_field (head->mtime, 0);
+  set_field (head->filesize, fsize);
+  set_field (head->devmajor, 0);
+  set_field (head->devminor, 0);
+  set_field (head->rdevmajor, 0);
+  set_field (head->rdevminor, 0);
+  set_field (head->namesize, len);
+  set_field (head->check, 0);
+  optr = ptr;
+  ptr += sizeof (struct newc_head);
+  grub_memcpy (ptr, name, len);
+  ptr += len;
+  oh = ALIGN_UP_OVERHEAD (ptr - optr, 4);
+  grub_memset (ptr, 0, oh);
+  ptr += oh;
+  return ptr;
+}
+
+static void
+free_dir (struct dir *root)
+{
+  if (!root)
+    return;
+  free_dir (root->next);
+  free_dir (root->child);
+  grub_free (root->name);
+  grub_free (root);
+}
+
+static grub_size_t
+insert_dir (const char *name, struct dir **root,
+	    grub_uint8_t *ptr)
+{
+  struct dir *cur, **head = root;
+  const char *cb, *ce = name;
+  grub_size_t size = 0;
+  while (1)
+    {
+      for (cb = ce; *cb == '/'; cb++);
+      for (ce = cb; *ce && *ce != '/'; ce++);
+      if (!*ce)
+	break;
+
+      for (cur = *root; cur; cur = cur->next)
+	if (grub_memcmp (cur->name, cb, ce - cb)
+	    && cur->name[ce - cb] == 0)
+	  break;
+      if (!cur)
+	{
+	  struct dir *n;
+	  n = grub_zalloc (sizeof (*n));
+	  if (!n)
+	    return 0;
+	  n->next = *head;
+	  n->name = grub_strndup (cb, ce - cb);
+	  if (ptr)
+	    {
+	      grub_dprintf ("linux", "Creating directory %s, %s\n", name, ce);
+	      ptr = make_header (ptr, name, ce - name,
+				 040777, 0);
+	    }
+	  size += ALIGN_UP ((ce - (char *) name)
+			    + sizeof (struct newc_head), 4);
+	  *head = n;
+	  cur = n;
+	}
+      root = &cur->next;
+    }
+  return size;
+}
+
+grub_err_t
+grub_initrd_init (int argc, char *argv[],
+		  struct grub_linux_initrd_context *initrd_ctx)
+{
+  int i;
+  int newc = 0;
+  struct dir *root = 0;
+
+  initrd_ctx->nfiles = 0;
+  initrd_ctx->components = 0;
+
+  initrd_ctx->components = grub_zalloc (argc
+					* sizeof (initrd_ctx->components[0]));
+  if (!initrd_ctx->components)
+    return grub_errno;
+
+  initrd_ctx->size = 0;
+
+  for (i = 0; i < argc; i++)
+    {
+      const char *fname = argv[i];
+
+      initrd_ctx->size = ALIGN_UP (initrd_ctx->size, 4);
+
+      if (grub_memcmp (argv[i], "newc:", 5) == 0)
+	{
+	  const char *ptr, *eptr;
+	  ptr = argv[i] + 5;
+	  while (*ptr == '/')
+	    ptr++;
+	  eptr = grub_strchr (ptr, ':');
+	  if (eptr)
+	    {
+	      initrd_ctx->components[i].newc_name = grub_strndup (ptr, eptr - ptr);
+	      if (!initrd_ctx->components[i].newc_name)
+		{
+		  grub_initrd_close (initrd_ctx);
+		  return grub_errno;
+		}
+	      initrd_ctx->size
+		+= ALIGN_UP (sizeof (struct newc_head)
+			    + grub_strlen (initrd_ctx->components[i].newc_name),
+			     4);
+	      initrd_ctx->size += insert_dir (initrd_ctx->components[i].newc_name,
+					      &root, 0);
+	      newc = 1;
+	      fname = eptr + 1;
+	    }
+	}
+      else if (newc)
+	{
+	  initrd_ctx->size += ALIGN_UP (sizeof (struct newc_head)
+					+ sizeof ("TRAILER!!!") - 1, 4);
+	  free_dir (root);
+	  root = 0;
+	  newc = 0;
+	}
+      initrd_ctx->components[i].file = grub_file_open (fname,
+						       GRUB_FILE_TYPE_LINUX_INITRD
+						       | GRUB_FILE_TYPE_NO_DECOMPRESS);
+      if (!initrd_ctx->components[i].file)
+	{
+	  grub_initrd_close (initrd_ctx);
+	  return grub_errno;
+	}
+      initrd_ctx->nfiles++;
+      initrd_ctx->components[i].size
+	= grub_file_size (initrd_ctx->components[i].file);
+      initrd_ctx->size += initrd_ctx->components[i].size;
+    }
+
+  if (newc)
+    {
+      initrd_ctx->size = ALIGN_UP (initrd_ctx->size, 4);
+      initrd_ctx->size += ALIGN_UP (sizeof (struct newc_head)
+				    + sizeof ("TRAILER!!!") - 1, 4);
+      free_dir (root);
+      root = 0;
+    }
+  
+  return GRUB_ERR_NONE;
+}
+
+grub_size_t
+grub_get_initrd_size (struct grub_linux_initrd_context *initrd_ctx)
+{
+  return initrd_ctx->size;
+}
+
+void
+grub_initrd_close (struct grub_linux_initrd_context *initrd_ctx)
+{
+  int i;
+  if (!initrd_ctx->components)
+    return;
+  for (i = 0; i < initrd_ctx->nfiles; i++)
+    {
+      grub_free (initrd_ctx->components[i].newc_name);
+      grub_file_close (initrd_ctx->components[i].file);
+    }
+  grub_free (initrd_ctx->components);
+  initrd_ctx->components = 0;
+}
+
+extern int ventoy_need_prompt_load_file(void);
+extern grub_ssize_t ventoy_load_file_with_prompt(grub_file_t file, void *buf, grub_ssize_t size);
+grub_err_t
+grub_initrd_load (struct grub_linux_initrd_context *initrd_ctx,
+		  char *argv[], void *target)
+{
+  grub_uint8_t *ptr = target;
+  int i;
+  int newc = 0;
+  struct dir *root = 0;
+  grub_ssize_t cursize = 0;
+  grub_ssize_t readsize = 0;
+  
+  for (i = 0; i < initrd_ctx->nfiles; i++)
+    {
+      grub_memset (ptr, 0, ALIGN_UP_OVERHEAD (cursize, 4));
+      ptr += ALIGN_UP_OVERHEAD (cursize, 4);
+
+      if (initrd_ctx->components[i].newc_name)
+	{
+	  ptr += insert_dir (initrd_ctx->components[i].newc_name,
+			     &root, ptr);
+	  ptr = make_header (ptr, initrd_ctx->components[i].newc_name,
+			     grub_strlen (initrd_ctx->components[i].newc_name),
+			     0100777,
+			     initrd_ctx->components[i].size);
+	  newc = 1;
+	}
+      else if (newc)
+	{
+	  ptr = make_header (ptr, "TRAILER!!!", sizeof ("TRAILER!!!") - 1,
+			     0, 0);
+	  free_dir (root);
+	  root = 0;
+	  newc = 0;
+	}
+
+    cursize = initrd_ctx->components[i].size;
+    if (ventoy_need_prompt_load_file() && initrd_ctx->components[i].newc_name && 
+        grub_strcmp(initrd_ctx->components[i].newc_name, "boot.wim") == 0)
+    {
+        readsize = ventoy_load_file_with_prompt(initrd_ctx->components[i].file, ptr, cursize);
+    }
+    else
+    {
+        readsize = grub_file_read (initrd_ctx->components[i].file, ptr, cursize);
+    }
+
+      if (readsize != cursize)
+	{
+	  if (!grub_errno)
+	    grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
+			argv[i]);
+	  grub_initrd_close (initrd_ctx);
+	  return grub_errno;
+	}
+      ptr += cursize;
+    }
+  if (newc)
+    {
+      grub_memset (ptr, 0, ALIGN_UP_OVERHEAD (cursize, 4));
+      ptr += ALIGN_UP_OVERHEAD (cursize, 4);
+      ptr = make_header (ptr, "TRAILER!!!", sizeof ("TRAILER!!!") - 1, 0, 0);
+    }
+  free_dir (root);
+  root = 0;
+  return GRUB_ERR_NONE;
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/normal/menu.c

@@ -38,6 +38,7 @@ int g_ventoy_menu_refresh = 0;
 int g_ventoy_memdisk_mode = 0;
 int g_ventoy_iso_raw = 0;
 int g_ventoy_grub2_mode = 0;
+int g_ventoy_wimboot_mode = 0;
 int g_ventoy_iso_uefi_drv = 0;
 int g_ventoy_last_entry = -1;
 int g_ventoy_suppress_esc = 0;
@@ -904,6 +905,12 @@ run_menu (grub_menu_t menu, int nested, int *auto_boot)
             g_ventoy_menu_refresh = 1;
             goto refresh;
             
+        case (GRUB_TERM_CTRL | 'w'):
+            menu_fini ();
+            g_ventoy_wimboot_mode = 1 - g_ventoy_wimboot_mode;
+            g_ventoy_menu_refresh = 1;
+            goto refresh;
+            
         case (GRUB_TERM_CTRL | 'u'):
             menu_fini ();
             g_ventoy_iso_uefi_drv = 1 - g_ventoy_iso_uefi_drv;

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_def.h

@@ -29,6 +29,8 @@
 
 #define VTOY_SIZE_1GB     1073741824
 #define VTOY_SIZE_1MB     (1024 * 1024)
+#define VTOY_SIZE_2MB     (2 * 1024 * 1024)
+#define VTOY_SIZE_4MB     (4 * 1024 * 1024)
 #define VTOY_SIZE_512KB   (512 * 1024)
 #define VTOY_SIZE_1KB     1024
 
@@ -140,6 +142,7 @@ typedef struct cpio_newc_header
 typedef int (*grub_char_check_func)(int c);
 #define ventoy_is_decimal(str)  ventoy_string_check(str, grub_isdigit)
 
+#define OFFSET_OF(TYPE, MEMBER) ((grub_size_t) &((TYPE *)0)->MEMBER)
 
 #pragma pack(1)
 typedef struct ventoy_patch_vhd
@@ -193,12 +196,14 @@ typedef struct ventoy_iso9660_vd
 
 #pragma pack()
 
-#define img_type_iso  0
-#define img_type_wim  1
-#define img_type_efi  2
-#define img_type_img  3
-#define img_type_vhd  4
-#define img_type_vtoy 5
+#define img_type_start 0
+#define img_type_iso   0
+#define img_type_wim   1
+#define img_type_efi   2
+#define img_type_img   3
+#define img_type_vhd   4
+#define img_type_vtoy  5
+#define img_type_max   6
 
 typedef struct img_info
 {
@@ -281,6 +286,7 @@ extern ventoy_img_chunk_list g_img_chunk_list;
 extern ventoy_img_chunk_list g_wimiso_chunk_list;
 extern char *g_wimiso_path;
 extern char g_arch_mode_suffix[64];
+extern const char *g_menu_prefix[img_type_max];
 
 extern int g_ventoy_debug;
 void ventoy_debug(const char *fmt, ...);
@@ -553,10 +559,16 @@ int ventoy_is_dir_exist(const char *fmt, ...);
 int ventoy_fill_data(grub_uint32_t buflen, char *buffer);
 grub_err_t ventoy_cmd_load_plugin(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_wimdows_reset(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_is_pe64(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_windows_chain_data(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_windows_wimboot_data(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_wim_chain_data(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_wim_check_bootable(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_dump_wim_patch(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_sel_wimboot(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_set_wim_prompt(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_ssize_t ventoy_load_file_with_prompt(grub_file_t file, void *buf, grub_ssize_t size);
+int ventoy_need_prompt_load_file(void);
 
 VTOY_JSON *vtoy_json_find_item
 (
@@ -766,8 +778,17 @@ typedef struct file_fullpath
     char path[256];
 }file_fullpath;
 
+typedef struct theme_list
+{
+    file_fullpath theme;
+    struct theme_list *next;
+}theme_list;
+
+#define auto_install_type_file   0
+#define auto_install_type_parent 1
 typedef struct install_template
 {
+    int type;
     int pathlen;
     char isopath[256];
 
@@ -861,8 +882,11 @@ typedef struct conf_replace
     struct conf_replace *next;
 }conf_replace;
 
+#define injection_type_file   0
+#define injection_type_parent 1
 typedef struct injection_config
 {
+    int type;
     int pathlen;
     char isopath[256];
     char archive[256];
@@ -899,8 +923,12 @@ typedef struct vtoy_password
     grub_uint8_t md5[16];
 }vtoy_password;
 
+#define vtoy_menu_pwd_file   0
+#define vtoy_menu_pwd_parent 1
+
 typedef struct menu_password
 {
+    int type;
     int pathlen;
     char isopath[256];
 
@@ -915,6 +943,7 @@ extern int g_ventoy_last_entry;
 extern int g_ventoy_memdisk_mode;
 extern int g_ventoy_iso_raw;
 extern int g_ventoy_grub2_mode;
+extern int g_ventoy_wimboot_mode;
 extern int g_ventoy_iso_uefi_drv;
 extern int g_ventoy_case_insensitive;
 extern grub_uint8_t g_ventoy_chain_type;
@@ -932,6 +961,8 @@ extern grub_uint8_t *g_conf_replace_new_buf;
 extern int g_conf_replace_new_len;
 extern int g_conf_replace_new_len_align;
 extern grub_uint64_t g_ventoy_disk_size;
+extern grub_uint64_t g_ventoy_disk_part_size[2];
+extern grub_uint32_t g_ventoy_plat_data;
 
 #define ventoy_unix_fill_virt(new_data, new_len) \
 { \
@@ -949,12 +980,16 @@ extern grub_uint64_t g_ventoy_disk_size;
     chain->virt_img_size_in_bytes += data_secs * 2048; \
 }
 
+#define ventoy_syscall0(name) grub_##name()
+#define ventoy_syscall1(name, a) grub_##name(a)
+
 char * ventoy_get_line(char *start);
 int ventoy_cmp_img(img_info *img1, img_info *img2);
 void ventoy_swap_img(img_info *img1, img_info *img2);
 char * ventoy_plugin_get_cur_install_template(const char *isopath);
 install_template * ventoy_plugin_find_install_template(const char *isopath);
 persistence_config * ventoy_plugin_find_persistent(const char *isopath);
+grub_uint64_t ventoy_get_vtoy_partsize(int part);
 void ventoy_plugin_dump_injection(void);
 void ventoy_plugin_dump_auto_install(void);
 int ventoy_fill_windows_rtdata(void *buf, char *isopath);
@@ -970,6 +1005,7 @@ int ventoy_plugin_load_dud(dud *node, const char *isopart);
 int ventoy_get_block_list(grub_file_t file, ventoy_img_chunk_list *chunklist, grub_disk_addr_t start);
 int ventoy_check_block_list(grub_file_t file, ventoy_img_chunk_list *chunklist, grub_disk_addr_t start);
 void ventoy_plugin_dump_persistence(void);
+grub_err_t ventoy_cmd_set_theme(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_plugin_check_json(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_check_password(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_linux_get_main_initrd_index(grub_extcmd_context_t ctxt, int argc, char **args);
@@ -994,11 +1030,22 @@ grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char *
 grub_err_t ventoy_cmd_raw_chain_data(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char **args);
 int ventoy_check_password(const vtoy_password *pwd, int retry);
-int ventoy_gzip_compress(void *mem_in, int mem_in_len, void *mem_out, int mem_out_len);
-grub_uint64_t ventoy_get_part1_size(ventoy_gpt_info *gpt);
 int ventoy_plugin_add_custom_boot(const char *vcfgpath);
 const char * ventoy_plugin_get_custom_boot(const char *isopath);
 grub_err_t ventoy_cmd_dump_custom_boot(grub_extcmd_context_t ctxt, int argc, char **args);
+int ventoy_gzip_compress(void *mem_in, int mem_in_len, void *mem_out, int mem_out_len);
+int ventoy_load_part_table(const char *diskname);
+int ventoy_env_init(void);
+int ventoy_register_all_cmd(void);
+int ventoy_unregister_all_cmd(void);
+int ventoy_chain_file_size(const char *path);
+int ventoy_chain_file_read(const char *path, int offset, int len, void *buf);
+
+#define VTOY_CMD_CHECK(a) if (33554432 != g_ventoy_disk_part_size[a]) ventoy_syscall0(exit)
+
+#define vtoy_theme_random_boot_second  0
+#define vtoy_theme_random_boot_day     1
+#define vtoy_theme_random_boot_month   2
 
 #endif /* __VENTOY_DEF_H__ */
 

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_plugin.c

@@ -43,6 +43,7 @@ GRUB_MOD_LICENSE ("GPLv3+");
 char g_arch_mode_suffix[64];
 static char g_iso_disk_name[128];
 static vtoy_password g_boot_pwd;
+static vtoy_password g_file_type_pwd[img_type_max];
 static install_template *g_install_template_head = NULL;
 static dud *g_dud_head = NULL;
 static menu_password *g_pwd_head = NULL;
@@ -55,6 +56,32 @@ static auto_memdisk *g_auto_memdisk_head = NULL;
 static image_list *g_image_list_head = NULL;
 static conf_replace *g_conf_replace_head = NULL;
 
+static int g_theme_num = 0;
+static theme_list *g_theme_head = NULL;
+static int g_theme_random = vtoy_theme_random_boot_second;
+static char g_theme_single_file[256];
+
+static int ventoy_plugin_is_parent(const char *pat, int patlen, const char *isopath)
+{
+    if (patlen > 1)
+    {
+        if (isopath[patlen] == '/' && ventoy_strncmp(pat, isopath, patlen) == 0 &&
+            grub_strchr(isopath + patlen + 1, '/') == NULL)
+        {
+            return 1;
+        }
+    }
+    else
+    {
+        if (pat[0] == '/' && grub_strchr(isopath + 1, '/') == NULL)
+        {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
 static int ventoy_plugin_control_check(VTOY_JSON *json, const char *isodisk)
 {
     int rc = 0;
@@ -155,6 +182,38 @@ static int ventoy_plugin_theme_check(VTOY_JSON *json, const char *isodisk)
             return 1;
         }
     }
+    else
+    {
+        node = vtoy_json_find_item(json->pstChild, JSON_TYPE_ARRAY, "file");
+        if (node)
+        {
+            for (node = node->pstChild; node; node = node->pstNext)
+            {
+                value = node->unData.pcStrVal;
+                grub_printf("file: %s\n", value);
+                if (value[0] == '/')
+                {
+                    exist = ventoy_is_file_exist("%s%s", isodisk, value);
+                }
+                else
+                {
+                    exist = ventoy_is_file_exist("%s/ventoy/%s", isodisk, value);
+                }
+
+                if (exist == 0)
+                {
+                    grub_printf("Theme file %s does NOT exist\n", value);
+                    return 1;
+                }
+            }
+
+            value = vtoy_json_get_string_ex(json->pstChild, "random");
+            if (value)
+            {
+                grub_printf("random: %s\n", value);
+            }
+        }
+    }
     
     value = vtoy_json_get_string_ex(json->pstChild, "gfxmode");
     if (value)
@@ -222,8 +281,10 @@ static int ventoy_plugin_theme_entry(VTOY_JSON *json, const char *isodisk)
 {
     const char *value;
     char filepath[256];
-    VTOY_JSON *node;
-    
+    VTOY_JSON *node = NULL;
+    theme_list *tail = NULL;
+    theme_list *themenode = NULL;
+
     value = vtoy_json_get_string_ex(json->pstChild, "file");
     if (value)
     {
@@ -236,7 +297,7 @@ static int ventoy_plugin_theme_entry(VTOY_JSON *json, const char *isodisk)
             grub_snprintf(filepath, sizeof(filepath), "%s/ventoy/%s", isodisk, value);
         }
         
-        if (ventoy_is_file_exist(filepath) == 0)
+        if (ventoy_check_file_exist(filepath) == 0)
         {
             debug("Theme file %s does not exist\n", filepath);
             return 0;
@@ -244,6 +305,65 @@ static int ventoy_plugin_theme_entry(VTOY_JSON *json, const char *isodisk)
 
         debug("vtoy_theme %s\n", filepath);
         grub_env_set("vtoy_theme", filepath);
+        grub_snprintf(g_theme_single_file, sizeof(g_theme_single_file), "%s", filepath);
+    }
+    else
+    {
+        node = vtoy_json_find_item(json->pstChild, JSON_TYPE_ARRAY, "file");
+        if (node)
+        {
+            for (node = node->pstChild; node; node = node->pstNext)
+            {
+                value = node->unData.pcStrVal;
+                if (value[0] == '/')
+                {
+                    grub_snprintf(filepath, sizeof(filepath), "%s%s", isodisk, value);
+                }
+                else
+                {
+                    grub_snprintf(filepath, sizeof(filepath), "%s/ventoy/%s", isodisk, value);
+                }
+
+                if (ventoy_check_file_exist(filepath) == 0)
+                {
+                    continue;
+                }
+
+                themenode = grub_zalloc(sizeof(theme_list));
+                if (themenode)
+                {
+                    grub_snprintf(themenode->theme.path, sizeof(themenode->theme.path), "%s", filepath);
+                    if (g_theme_head)
+                    {
+                        tail->next = themenode;
+                    }
+                    else
+                    {
+                        g_theme_head = themenode;
+                    }
+                    tail = themenode;
+                    g_theme_num++;
+                }
+            }
+
+            grub_env_set("vtoy_theme", "random");
+            value = vtoy_json_get_string_ex(json->pstChild, "random");
+            if (value)
+            {
+                if (grub_strcmp(value, "boot_second") == 0)
+                {
+                    g_theme_random = vtoy_theme_random_boot_second;
+                }
+                else if (grub_strcmp(value, "boot_day") == 0)
+                {
+                    g_theme_random = vtoy_theme_random_boot_day;
+                }
+                else if (grub_strcmp(value, "boot_month") == 0)
+                {
+                    g_theme_random = vtoy_theme_random_boot_month;
+                }
+            }
+        }
     }
     
     value = vtoy_json_get_string_ex(json->pstChild, "gfxmode");
@@ -498,8 +618,7 @@ static int ventoy_plugin_auto_install_check(VTOY_JSON *json, const char *isodisk
             grub_printf("NOT object type\n");
         }
     
-        iso = vtoy_json_get_string_ex(pNode->pstChild, "image");
-        if (iso)
+        if ((iso = vtoy_json_get_string_ex(pNode->pstChild, "image")) != NULL)
         {
             pos = grub_strchr(iso, '*');
             if (pos || 0 == ventoy_plugin_check_path(isodisk, iso))
@@ -524,6 +643,30 @@ static int ventoy_plugin_auto_install_check(VTOY_JSON *json, const char *isodisk
                 grub_printf("image: %s [FAIL]\n", iso);
             }
         }
+        else if ((iso = vtoy_json_get_string_ex(pNode->pstChild, "parent")) != NULL)
+        {
+            if (ventoy_is_dir_exist("%s%s", isodisk, iso))
+            {
+                grub_printf("parent: %s [OK]\n", iso);
+                ventoy_plugin_check_fullpath(pNode->pstChild, isodisk, "template", &pathnum);
+                
+                if (JSON_SUCCESS == vtoy_json_get_int(pNode->pstChild, "autosel", &autosel))
+                {
+                    if (autosel >= 0 && autosel <= pathnum)
+                    {
+                        grub_printf("autosel: %d [OK]\n", autosel);
+                    }
+                    else
+                    {
+                        grub_printf("autosel: %d [FAIL]\n", autosel);
+                    }
+                }
+            }
+            else
+            {
+                grub_printf("parent: %s [FAIL]\n", iso);
+            }
+        }
         else
         {
             grub_printf("image not found\n");
@@ -535,6 +678,7 @@ static int ventoy_plugin_auto_install_check(VTOY_JSON *json, const char *isodisk
 
 static int ventoy_plugin_auto_install_entry(VTOY_JSON *json, const char *isodisk)
 {
+    int type = 0;
     int pathnum = 0;
     int autosel = 0;
     const char *iso = NULL;
@@ -563,7 +707,14 @@ static int ventoy_plugin_auto_install_entry(VTOY_JSON *json, const char *isodisk
 
     for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
     {
+        type = auto_install_type_file;
         iso = vtoy_json_get_string_ex(pNode->pstChild, "image");
+        if (!iso)
+        {
+            type = auto_install_type_parent;
+            iso = vtoy_json_get_string_ex(pNode->pstChild, "parent");
+        }
+        
         if (iso && iso[0] == '/')
         {
             if (0 == ventoy_plugin_parse_fullpath(pNode->pstChild, isodisk, "template", &templatepath, &pathnum))
@@ -571,6 +722,7 @@ static int ventoy_plugin_auto_install_entry(VTOY_JSON *json, const char *isodisk
                 node = grub_zalloc(sizeof(install_template));
                 if (node)
                 {
+                    node->type = type;
                     node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", iso);
                     node->templatepath = templatepath;
                     node->templatenum = pathnum;
@@ -809,8 +961,26 @@ static int ventoy_plugin_parse_pwdstr(char *pwdstr, vtoy_password *pwd)
     return 0;
 }
 
+static int ventoy_plugin_get_pwd_type(const char *pwd)
+{
+    int i;
+    char pwdtype[64];
+
+    for (i = 0; pwd && i < (int)ARRAY_SIZE(g_menu_prefix); i++)
+    {
+        grub_snprintf(pwdtype, sizeof(pwdtype), "%spwd", g_menu_prefix[i]);
+        if (grub_strcmp(pwdtype, pwd) == 0)
+        {
+            return img_type_start + i; 
+        }
+    }
+    
+    return -1;
+}
+
 static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
 {
+    int type = -1;
     const char *iso = NULL;
     const char *pwd = NULL;
     VTOY_JSON *pNode = NULL;
@@ -844,6 +1014,10 @@ static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
         {
             ventoy_plugin_parse_pwdstr(pNode->unData.pcStrVal, &g_boot_pwd);
         }
+        else if ((type = ventoy_plugin_get_pwd_type(pNode->pcName)) >= 0)
+        {
+            ventoy_plugin_parse_pwdstr(pNode->unData.pcStrVal, g_file_type_pwd + type);
+        }
         else if (pNode->pcName && grub_strcmp("menupwd", pNode->pcName) == 0)
         {
             for (pCNode = pNode->pstChild; pCNode; pCNode = pCNode->pstNext)
@@ -853,13 +1027,21 @@ static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
                     continue;
                 }
 
+                type = vtoy_menu_pwd_file;
                 iso = vtoy_json_get_string_ex(pCNode->pstChild, "file");
+                if (!iso)
+                {
+                    type = vtoy_menu_pwd_parent;
+                    iso = vtoy_json_get_string_ex(pCNode->pstChild, "parent");                    
+                }                
+                
                 pwd = vtoy_json_get_string_ex(pCNode->pstChild, "pwd");
                 if (iso && pwd && iso[0] == '/')
                 {
                     node = grub_zalloc(sizeof(menu_password));
                     if (node)
                     {
+                        node->type = type;
                         node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", iso);
 
                         if (ventoy_plugin_parse_pwdstr((char *)pwd, &(node->password)))
@@ -888,6 +1070,7 @@ static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
 
 static int ventoy_plugin_pwd_check(VTOY_JSON *json, const char *isodisk)
 {
+    int type = -1;
     char *pos = NULL;
     const char *iso = NULL;
     const char *pwd = NULL;
@@ -913,6 +1096,17 @@ static int ventoy_plugin_pwd_check(VTOY_JSON *json, const char *isodisk)
                 grub_printf("Invalid bootpwd.\n");
             }
         }
+        else if ((type = ventoy_plugin_get_pwd_type(pNode->pcName)) >= 0)
+        {
+            if (0 == ventoy_plugin_parse_pwdstr(pNode->unData.pcStrVal, NULL))
+            {
+                grub_printf("%s:<%s>\n", pNode->pcName, pNode->unData.pcStrVal);
+            }
+            else
+            {
+                grub_printf("Invalid pwd <%s>\n", pNode->unData.pcStrVal);
+            }
+        }
         else if (pNode->pcName && grub_strcmp("menupwd", pNode->pcName) == 0)
         {
             grub_printf("\n");
@@ -924,8 +1118,7 @@ static int ventoy_plugin_pwd_check(VTOY_JSON *json, const char *isodisk)
                     continue;
                 }
 
-                iso = vtoy_json_get_string_ex(pCNode->pstChild, "file");
-                if (iso)
+                if ((iso = vtoy_json_get_string_ex(pCNode->pstChild, "file")) != NULL)
                 {
                     pos = grub_strchr(iso, '*');
                     if (pos || 0 == ventoy_plugin_check_path(isodisk, iso))
@@ -947,6 +1140,26 @@ static int ventoy_plugin_pwd_check(VTOY_JSON *json, const char *isodisk)
                         grub_printf("<%s%s> not found\n", isodisk, iso);
                     }
                 }
+                else if ((iso = vtoy_json_get_string_ex(pCNode->pstChild, "parent")) != NULL)
+                {
+                    if (ventoy_is_dir_exist("%s%s", isodisk, iso))
+                    {
+                        pwd = vtoy_json_get_string_ex(pCNode->pstChild, "pwd");
+                        if (0 == ventoy_plugin_parse_pwdstr((char *)pwd, NULL))
+                        {
+                            grub_printf("dir:<%s> [%s]\n", iso, (pos ? "*" : "OK"));
+                            grub_printf("pwd:<%s>\n\n", pwd);
+                        }
+                        else
+                        {
+                            grub_printf("Invalid password for <%s>\n", iso);
+                        }
+                    }
+                    else
+                    {
+                        grub_printf("<%s%s> not found\n", isodisk, iso);
+                    }
+                }
                 else
                 {
                     grub_printf("No file item found in json.\n");
@@ -1207,6 +1420,7 @@ static int ventoy_plugin_menualias_entry(VTOY_JSON *json, const char *isodisk)
 
 static int ventoy_plugin_injection_check(VTOY_JSON *json, const char *isodisk)
 {
+    int type = 0;
     const char *path = NULL;
     const char *archive = NULL;
     VTOY_JSON *pNode = NULL;
@@ -1221,11 +1435,17 @@ static int ventoy_plugin_injection_check(VTOY_JSON *json, const char *isodisk)
 
     for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
     {
+        type = injection_type_file;
         path = vtoy_json_get_string_ex(pNode->pstChild, "image");
         if (!path)
         {
-            grub_printf("image not found\n");
-            continue;
+            type = injection_type_parent;
+            path = vtoy_json_get_string_ex(pNode->pstChild, "parent");
+            if (!path)
+            {
+                grub_printf("image/parent not found\n");
+                continue;
+            }
         }
 
         archive = vtoy_json_get_string_ex(pNode->pstChild, "archive");
@@ -1235,13 +1455,21 @@ static int ventoy_plugin_injection_check(VTOY_JSON *json, const char *isodisk)
             continue;
         }
 
-        if (grub_strchr(path, '*'))
+        if (type == injection_type_file)
         {
-            grub_printf("image: <%s> [*]\n", path);
+            if (grub_strchr(path, '*'))
+            {
+                grub_printf("image: <%s> [*]\n", path);
+            }
+            else
+            {
+                grub_printf("image: <%s> [%s]\n", path, ventoy_check_file_exist("%s%s", isodisk, path) ? "OK" : "NOT EXIST");            
+            }
         }
         else
         {
-            grub_printf("image: <%s> [%s]\n", path, ventoy_check_file_exist("%s%s", isodisk, path) ? "OK" : "NOT EXIST");            
+            grub_printf("parent: <%s> [%s]\n", path, 
+                ventoy_is_dir_exist("%s%s", isodisk, path) ? "OK" : "NOT EXIST");
         }
 
         grub_printf("archive: <%s> [%s]\n\n", archive, ventoy_check_file_exist("%s%s", isodisk, archive) ? "OK" : "NOT EXIST");
@@ -1252,6 +1480,7 @@ static int ventoy_plugin_injection_check(VTOY_JSON *json, const char *isodisk)
 
 static int ventoy_plugin_injection_entry(VTOY_JSON *json, const char *isodisk)
 {
+    int type = 0;
     const char *path = NULL;
     const char *archive = NULL;
     VTOY_JSON *pNode = NULL;
@@ -1279,13 +1508,21 @@ static int ventoy_plugin_injection_entry(VTOY_JSON *json, const char *isodisk)
 
     for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
     {
+        type = injection_type_file;
         path = vtoy_json_get_string_ex(pNode->pstChild, "image");
+        if (!path)
+        {
+            type = injection_type_parent;
+            path = vtoy_json_get_string_ex(pNode->pstChild, "parent");
+        }
+        
         archive = vtoy_json_get_string_ex(pNode->pstChild, "archive");
         if (path && path[0] == '/' && archive && archive[0] == '/')
         {
             node = grub_zalloc(sizeof(injection_config));
             if (node)
             {
+                node->type = type;
                 node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", path);
                 grub_snprintf(node->archive, sizeof(node->archive), "%s", archive);
 
@@ -1977,7 +2214,7 @@ void ventoy_plugin_dump_injection(void)
 
     for (node = g_injection_head; node; node = node->next)
     {
-        grub_printf("\nIMAGE:<%s>\n", node->isopath);
+        grub_printf("\n%s:<%s>\n", (node->type == injection_type_file) ? "IMAGE" : "PARENT", node->isopath);
         grub_printf("ARCHIVE:<%s>\n", node->archive);
     }
 
@@ -1992,7 +2229,9 @@ void ventoy_plugin_dump_auto_install(void)
 
     for (node = g_install_template_head; node; node = node->next)
     {
-        grub_printf("\nIMAGE:<%s> <%d>\n", node->isopath, node->templatenum);
+        grub_printf("\n%s:<%s> <%d>\n", 
+            (node->type == auto_install_type_file) ? "IMAGE" : "PARENT",
+            node->isopath, node->templatenum);
         for (i = 0; i < node->templatenum; i++)
         {
             grub_printf("SCRIPT %d:<%s>\n", i, node->templatepath[i].path);            
@@ -2045,9 +2284,23 @@ install_template * ventoy_plugin_find_install_template(const char *isopath)
     len = (int)grub_strlen(isopath);
     for (node = g_install_template_head; node; node = node->next)
     {
-        if (node->pathlen == len && ventoy_strcmp(node->isopath, isopath) == 0)
+        if (node->type == auto_install_type_file)
         {
-            return node;
+            if (node->pathlen == len && ventoy_strcmp(node->isopath, isopath) == 0)
+            {
+                return node;
+            }
+        }
+    }
+    
+    for (node = g_install_template_head; node; node = node->next)
+    {
+        if (node->type == auto_install_type_parent)
+        {
+            if (node->pathlen < len && ventoy_plugin_is_parent(node->isopath, node->pathlen, isopath))
+            {
+                return node;
+            }
         }
     }
 
@@ -2166,9 +2419,23 @@ const char * ventoy_plugin_get_injection(const char *isopath)
     len = (int)grub_strlen(isopath);
     for (node = g_injection_head; node; node = node->next)
     {
-        if (node->pathlen == len && ventoy_strcmp(node->isopath, isopath) == 0)
+        if (node->type == injection_type_file)
         {
-            return node->archive;
+            if (node->pathlen == len && ventoy_strcmp(node->isopath, isopath) == 0)
+            {
+                return node->archive;
+            }
+        }
+    }
+    
+    for (node = g_injection_head; node; node = node->next)
+    {
+        if (node->type == injection_type_parent)
+        {
+            if (node->pathlen < len && ventoy_plugin_is_parent(node->isopath, node->pathlen, isopath))
+            {
+                return node->archive;
+            }
         }
     }
 
@@ -2200,7 +2467,8 @@ const char * ventoy_plugin_get_menu_alias(int type, const char *isopath)
 
 const char * ventoy_plugin_get_menu_class(int type, const char *name, const char *path)
 {
-    int len;
+    int namelen;
+    int pathlen;
     menu_class *node = NULL;
 
     if (!g_menu_class_head)
@@ -2208,6 +2476,9 @@ const char * ventoy_plugin_get_menu_class(int type, const char *name, const char
         return NULL;
     }
     
+    namelen = (int)grub_strlen(name); 
+    pathlen = (int)grub_strlen(path); 
+    
     if (vtoy_class_image_file == type)
     {
         for (node = g_menu_class_head; node; node = node->next)
@@ -2219,17 +2490,14 @@ const char * ventoy_plugin_get_menu_class(int type, const char *name, const char
 
             if (node->parent)
             {
-                len = (int)grub_strlen(path);
-                if ((node->patlen < len) && (path[node->patlen] == '/') &&
-                    (grub_strncmp(path, node->pattern, node->patlen) == 0))
+                if ((node->patlen < pathlen) && ventoy_plugin_is_parent(node->pattern, node->patlen, path))
                 {
                     return node->class;
                 }
             }
             else
             {
-                len = (int)grub_strlen(name);
-                if ((node->patlen < len) && grub_strstr(name, node->pattern))
+                if ((node->patlen < namelen) && grub_strstr(name, node->pattern))
                 {
                     return node->class;
                 }
@@ -2238,10 +2506,9 @@ const char * ventoy_plugin_get_menu_class(int type, const char *name, const char
     }
     else
     {
-        len = (int)grub_strlen(name);
         for (node = g_menu_class_head; node; node = node->next)
         {
-            if (node->type == type && node->patlen == len && grub_strncmp(name, node->pattern, len) == 0)
+            if (node->type == type && node->patlen == namelen && grub_strncmp(name, node->pattern, namelen) == 0)
             {
                 return node->class;
             }
@@ -2475,20 +2742,59 @@ int ventoy_plugin_load_dud(dud *node, const char *isopart)
 
 static const vtoy_password * ventoy_plugin_get_password(const char *isopath)
 {
+    int i;
     int len;
+    const char *pos = NULL;
     menu_password *node = NULL;
 
-    if ((!g_pwd_head) || (!isopath))
+    if (!isopath)
     {
         return NULL;
     }
 
-    len = (int)grub_strlen(isopath);    
-    for (node = g_pwd_head; node; node = node->next)
+    if (g_pwd_head)
     {
-        if (node->pathlen == len && ventoy_strncmp(node->isopath, isopath, len) == 0)
+        len = (int)grub_strlen(isopath);    
+        for (node = g_pwd_head; node; node = node->next)
         {
-            return &(node->password);
+            if (node->type == vtoy_menu_pwd_file)
+            {
+                if (node->pathlen == len && ventoy_strncmp(node->isopath, isopath, len) == 0)
+                {
+                    return &(node->password);
+                }
+            }
+        }
+
+        for (node = g_pwd_head; node; node = node->next)
+        {   
+            if (node->type == vtoy_menu_pwd_parent)
+            {
+                if (node->pathlen < len && ventoy_plugin_is_parent(node->isopath, node->pathlen, isopath))
+                {
+                    return &(node->password);
+                }
+            }
+        }
+    }
+
+    while (*isopath)
+    {
+        if (*isopath == '.')
+        {
+            pos = isopath;
+        }
+        isopath++;
+    }
+
+    if (pos)
+    {
+        for (i = 0; i < (int)ARRAY_SIZE(g_menu_prefix); i++)
+        {
+            if (g_file_type_pwd[i].type && 0 == grub_strcasecmp(pos + 1, g_menu_prefix[i]))
+            {
+                return g_file_type_pwd + i;
+            }
         }
     }
 
@@ -2608,3 +2914,62 @@ end:
     return 0;
 }
 
+grub_err_t ventoy_cmd_set_theme(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    grub_uint32_t i = 0;
+    grub_uint32_t mod = 0;
+    theme_list *node = g_theme_head;
+    struct grub_datetime datetime;
+    
+    (void)argc;
+    (void)args;
+    (void)ctxt;
+
+    if (g_theme_single_file[0])
+    {
+        debug("single theme %s\n", g_theme_single_file);
+        grub_env_set("theme", g_theme_single_file);
+        goto end;
+    }
+
+    debug("g_theme_num = %d\n", g_theme_num);
+    
+    if (g_theme_num == 0)
+    {
+        goto end;
+    }
+
+    grub_memset(&datetime, 0, sizeof(datetime));
+    grub_get_datetime(&datetime);
+
+    if (g_theme_random == vtoy_theme_random_boot_second)
+    {
+        grub_divmod32((grub_uint32_t)datetime.second, (grub_uint32_t)g_theme_num, &mod);
+    }
+    else if (g_theme_random == vtoy_theme_random_boot_day)
+    {
+        grub_divmod32((grub_uint32_t)datetime.day, (grub_uint32_t)g_theme_num, &mod);
+    }
+    else if (g_theme_random == vtoy_theme_random_boot_month)
+    {
+        grub_divmod32((grub_uint32_t)datetime.month, (grub_uint32_t)g_theme_num, &mod);
+    }
+
+    debug("%04d/%02d/%02d %02d:%02d:%02d radom:%d mod:%d\n",
+          datetime.year, datetime.month, datetime.day,
+          datetime.hour, datetime.minute, datetime.second,
+          g_theme_random, mod);
+
+    for (i = 0; i < mod && node; i++)
+    {
+        node = node->next;
+    }
+
+    debug("random theme %s\n", node->theme.path);
+    grub_env_set("theme", node->theme.path);
+
+end:
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
+

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_unix.c

@@ -720,7 +720,7 @@ grub_err_t ventoy_cmd_unix_fill_image_desc(grub_extcmd_context_t ctxt, int argc,
 
     desc = (ventoy_image_desc *)(byte + i);
     desc->disk_size = g_ventoy_disk_size;
-    desc->part1_size = ventoy_get_part1_size(g_ventoy_part_info);
+    desc->part1_size = g_ventoy_disk_part_size[0];
     grub_memcpy(desc->disk_uuid, g_ventoy_part_info->MBR.BootCode + 0x180, 16);
     grub_memcpy(desc->disk_signature, g_ventoy_part_info->MBR.BootCode + 0x1B8, 4);
 

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_vhd.c

@@ -44,14 +44,12 @@
 
 GRUB_MOD_LICENSE ("GPLv3+");
 
-static int g_vhdboot_bcd_offset = 0;
-static int g_vhdboot_bcd_len = 0;
 static int g_vhdboot_isolen = 0;
 static char *g_vhdboot_totbuf = NULL;
 static char *g_vhdboot_isobuf = NULL;
 static grub_uint64_t g_img_trim_head_secnum = 0;
 
-static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen)
+static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen, const char *path)
 {
     grub_uint32_t offset;
     grub_file_t file;
@@ -61,10 +59,9 @@ static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen)
     
     grub_script_execute_sourcecode(cmdbuf);
 
-    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", "(vhdiso)/boot/bcd");
+    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "(vhdiso)%s", path);
     if (!file)
     {
-        grub_printf("Failed to open bcd file in the image file\n");
         return 1;
     }
 
@@ -83,13 +80,15 @@ static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen)
     return 0;
 }
 
-static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2)
+static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2, 
+    int bcdoffset, int bcdlen)
 {
     int i;
     int cnt = 0;
     char *pos;
     grub_size_t pathlen;
     const char *plat;
+    char *newpath = NULL;
     grub_uint16_t *unicode_path;
     const grub_uint8_t winloadexe[] = 
     {
@@ -97,6 +96,11 @@ static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy
         0x65, 0x00, 0x78, 0x00, 0x65, 0x00 
     };
 
+    while ((*vhdpath) != '/')
+    {
+        vhdpath++;
+    }
+
     pathlen = sizeof(grub_uint16_t) * (grub_strlen(vhdpath) + 1);
     debug("unicode path for <%s> len:%d\n", vhdpath, (int)pathlen);
     
@@ -110,10 +114,10 @@ static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy
 
     if (plat && (plat[0] == 'e')) /* UEFI */
     {
-        pos = g_vhdboot_isobuf + g_vhdboot_bcd_offset;
+        pos = g_vhdboot_isobuf + bcdoffset;
     
         /* winload.exe ==> winload.efi */
-        for (i = 0; i + (int)sizeof(winloadexe) < g_vhdboot_bcd_len; i++)
+        for (i = 0; i + (int)sizeof(winloadexe) < bcdlen; i++)
         {
             if (*((grub_uint32_t *)(pos + i)) == 0x00690077 && 
                 grub_memcmp(pos + i, winloadexe, sizeof(winloadexe)) == 0)
@@ -127,7 +131,8 @@ static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy
         debug("winload patch %d times\n", cnt);
     }
 
-    for (pos = vhdpath; *pos; pos++)
+    newpath = grub_strdup(vhdpath);
+    for (pos = newpath; *pos; pos++)
     {
         if (*pos == '/')
         {
@@ -135,40 +140,159 @@ static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy
         }
     }
     
-    grub_utf8_to_utf16(unicode_path, pathlen, (grub_uint8_t *)vhdpath, -1, NULL);
+    grub_utf8_to_utf16(unicode_path, pathlen, (grub_uint8_t *)newpath, -1, NULL);
     grub_memcpy(patch1->vhd_file_path, unicode_path, pathlen);
     grub_memcpy(patch2->vhd_file_path, unicode_path, pathlen);
 
+    grub_free(newpath);
     return 0;
 }
 
-static int ventoy_vhd_patch_disk(ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2)
+static int ventoy_vhd_read_parttbl(const char *filename, ventoy_gpt_info *gpt, int *index)
 {
+    int i;
+    int ret = 1;
+    grub_uint64_t start;
+    grub_file_t file = NULL;
+    grub_disk_t disk = NULL;
+    grub_uint8_t zeroguid[16] = {0};
+
+    file = grub_file_open(filename, VENTOY_FILE_TYPE);
+    if (!file)
+    {
+        goto end;
+    }
+
+    disk = grub_disk_open(file->device->disk->name);
+    if (!disk)
+    {
+        goto end;
+    }
+
+    grub_disk_read(disk, 0, 0, sizeof(ventoy_gpt_info), gpt);
+
+    start = file->device->disk->partition->start;
+
+    if (grub_memcmp(gpt->Head.Signature, "EFI PART", 8) == 0)
+    {
+        debug("GPT part start: %llu\n", (ulonglong)start);
+        for (i = 0; i < 128; i++)
+        {
+            if (grub_memcmp(gpt->PartTbl[i].PartGuid, zeroguid, 16))
+            {
+                if (start == gpt->PartTbl[i].StartLBA)
+                {
+                    *index = i;
+                    break;
+                }
+            }
+        }
+    }
+    else
+    {
+        debug("MBR part start: %llu\n", (ulonglong)start);
+        for (i = 0; i < 4; i++)
+        {
+            if ((grub_uint32_t)start == gpt->MBR.PartTbl[i].StartSectorId)
+            {
+                *index = i;
+                break;
+            }
+        }
+    }    
+
+    ret = 0;
+
+end:
+    check_free(file, grub_file_close);
+    check_free(disk, grub_disk_close);
+
+    return ret;
+}
+
+static int ventoy_vhd_patch_disk(const char *vhdpath, ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2)
+{
+    int partIndex = 0;
+    grub_uint64_t offset = 0;
     char efipart[16] = {0};
+    ventoy_gpt_info *gpt = NULL;
 
-    grub_memcpy(efipart, g_ventoy_part_info->Head.Signature, sizeof(g_ventoy_part_info->Head.Signature));
+    if (vhdpath[0] == '/')
+    {
+        gpt = g_ventoy_part_info;  
+        partIndex = 0;
+        debug("This is Ventoy ISO partIndex %d %s\n", partIndex, vhdpath);
+    }
+    else
+    {
+        gpt = grub_zalloc(sizeof(ventoy_gpt_info));
+        ventoy_vhd_read_parttbl(vhdpath, gpt, &partIndex);
+        debug("This is HDD partIndex %d %s\n", partIndex, vhdpath);
+    }
 
-    debug("part1 type: 0x%x <%s>\n", g_ventoy_part_info->MBR.PartTbl[0].FsFlag, efipart);
+    grub_memcpy(efipart, gpt->Head.Signature, sizeof(gpt->Head.Signature));
+
+    grub_memset(patch1, 0, OFFSET_OF(ventoy_patch_vhd, vhd_file_path));
+    grub_memset(patch2, 0, OFFSET_OF(ventoy_patch_vhd, vhd_file_path));
 
     if (grub_strncmp(efipart, "EFI PART", 8) == 0)
     {
-        ventoy_debug_dump_guid("GPT disk GUID: ", g_ventoy_part_info->Head.DiskGuid);
-        ventoy_debug_dump_guid("GPT part GUID: ", g_ventoy_part_info->PartTbl[0].PartGuid);
+        ventoy_debug_dump_guid("GPT disk GUID: ", gpt->Head.DiskGuid);
+        ventoy_debug_dump_guid("GPT partIndex GUID: ", gpt->PartTbl[partIndex].PartGuid);
         
-        grub_memcpy(patch1->disk_signature_or_guid, g_ventoy_part_info->Head.DiskGuid, 16);
-        grub_memcpy(patch1->part_offset_or_guid, g_ventoy_part_info->PartTbl[0].PartGuid, 16);
-        grub_memcpy(patch2->disk_signature_or_guid, g_ventoy_part_info->Head.DiskGuid, 16);
-        grub_memcpy(patch2->part_offset_or_guid, g_ventoy_part_info->PartTbl[0].PartGuid, 16);
+        grub_memcpy(patch1->disk_signature_or_guid, gpt->Head.DiskGuid, 16);
+        grub_memcpy(patch1->part_offset_or_guid, gpt->PartTbl[partIndex].PartGuid, 16);
+        grub_memcpy(patch2->disk_signature_or_guid, gpt->Head.DiskGuid, 16);
+        grub_memcpy(patch2->part_offset_or_guid, gpt->PartTbl[partIndex].PartGuid, 16);
 
         patch1->part_type = patch2->part_type = 0;
     }
     else
     {
-        debug("MBR disk signature: %02x%02x%02x%02x\n",
-            g_ventoy_part_info->MBR.BootCode[0x1b8 + 0], g_ventoy_part_info->MBR.BootCode[0x1b8 + 1],
-            g_ventoy_part_info->MBR.BootCode[0x1b8 + 2], g_ventoy_part_info->MBR.BootCode[0x1b8 + 3]);
-        grub_memcpy(patch1->disk_signature_or_guid, g_ventoy_part_info->MBR.BootCode + 0x1b8, 4);
-        grub_memcpy(patch2->disk_signature_or_guid, g_ventoy_part_info->MBR.BootCode + 0x1b8, 4);
+        offset = gpt->MBR.PartTbl[partIndex].StartSectorId;
+        offset *= 512;
+    
+        debug("MBR disk signature: %02x%02x%02x%02x Part(%d) offset:%llu\n",
+            gpt->MBR.BootCode[0x1b8 + 0], gpt->MBR.BootCode[0x1b8 + 1],
+            gpt->MBR.BootCode[0x1b8 + 2], gpt->MBR.BootCode[0x1b8 + 3],
+            partIndex + 1, offset);
+
+        grub_memcpy(patch1->part_offset_or_guid, &offset, 8);
+        grub_memcpy(patch2->part_offset_or_guid, &offset, 8);
+        
+        grub_memcpy(patch1->disk_signature_or_guid, gpt->MBR.BootCode + 0x1b8, 4);
+        grub_memcpy(patch2->disk_signature_or_guid, gpt->MBR.BootCode + 0x1b8, 4);
+
+        patch1->part_type = patch2->part_type = 1;
+    }
+
+    if (gpt != g_ventoy_part_info)
+    {
+        grub_free(gpt);
+    }
+
+    return 0;
+}
+
+static int ventoy_find_vhdpatch_offset(int bcdoffset, int bcdlen, int *offset)
+{
+    int i;
+    int cnt = 0;
+    grub_uint8_t *buf = (grub_uint8_t *)(g_vhdboot_isobuf + bcdoffset);
+    grub_uint8_t magic[16] = { 
+        0x5C, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00 
+    };
+
+    for (i = 0; i < bcdlen - 16 && cnt < 2; i++)
+    {
+        if (*(grub_uint32_t *)(buf + i) == 0x0058005C)
+        {
+            if (grub_memcmp(magic, buf + i, 16) == 0)
+            {
+                *offset++ = i - (int)OFFSET_OF(ventoy_patch_vhd, vhd_file_path); 
+                cnt++;
+            }
+        }
     }
 
     return 0;
@@ -177,6 +301,8 @@ static int ventoy_vhd_patch_disk(ventoy_patch_vhd *patch1, ventoy_patch_vhd *pat
 grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     int rc;
+    int bcdoffset, bcdlen;
+    int patchoffset[2];
     ventoy_patch_vhd *patch1;
     ventoy_patch_vhd *patch2;
     char envbuf[64];
@@ -194,18 +320,39 @@ grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char *
         return 0;
     }
 
-    rc = ventoy_vhd_find_bcd(&g_vhdboot_bcd_offset, &g_vhdboot_bcd_len);
+    rc = ventoy_vhd_find_bcd(&bcdoffset, &bcdlen, "/boot/bcd");
     if (rc)
     {
         debug("failed to get bcd location %d\n", rc);
-        return 0;
+    }
+    else
+    {
+        ventoy_find_vhdpatch_offset(bcdoffset, bcdlen, patchoffset);
+        patch1 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[0]);
+        patch2 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[1]);
+
+        debug("Find /boot/bcd (%d %d) now patch it (offset: 0x%x 0x%x) ...\n", 
+              bcdoffset, bcdlen, patchoffset[0], patchoffset[1]);
+        ventoy_vhd_patch_disk(args[0], patch1, patch2);
+        ventoy_vhd_patch_path(args[0], patch1, patch2, bcdoffset, bcdlen);
     }
 
-    patch1 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + g_vhdboot_bcd_offset + 0x495a);
-    patch2 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + g_vhdboot_bcd_offset + 0x50aa);
-
-    ventoy_vhd_patch_disk(patch1, patch2);
-    ventoy_vhd_patch_path(args[0], patch1, patch2);
+    rc = ventoy_vhd_find_bcd(&bcdoffset, &bcdlen, "/boot/BCD");
+    if (rc)
+    {
+        debug("No file /boot/BCD \n");
+    }
+    else
+    {
+        ventoy_find_vhdpatch_offset(bcdoffset, bcdlen, patchoffset);
+        patch1 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[0]);
+        patch2 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[1]);
+        
+        debug("Find /boot/BCD (%d %d) now patch it (offset: 0x%x 0x%x) ...\n", 
+              bcdoffset, bcdlen, patchoffset[0], patchoffset[1]);
+        ventoy_vhd_patch_disk(args[0], patch1, patch2);
+        ventoy_vhd_patch_path(args[0], patch1, patch2, bcdoffset, bcdlen);
+    }
 
     /* set buffer and size */
 #ifdef GRUB_MACHINE_EFI
@@ -220,7 +367,7 @@ grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char *
     grub_env_set("vtoy_vhd_buf_size", envbuf);
 #endif
 
-    return 0;
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
 grub_err_t ventoy_cmd_load_vhdboot(grub_extcmd_context_t ctxt, int argc, char **args)
@@ -396,7 +543,7 @@ grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char *
     }
 
     grub_env_set(args[1], type);
-    debug("<%s> vtoy type: <%s> ", args[0], type);
+    debug("<%s> vtoy type: <%s> offset:%d\n", args[0], type, offset);
     
     if (offset >= 0)
     {
@@ -451,6 +598,14 @@ grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char *
                         altboot = 1;
                         grub_env_set(args[3], "1");                        
                     }
+                    else
+                    {
+                        debug("offset data=0x%x\n", data);
+                    }
+                }
+                else
+                {
+                    debug("BootCode: 0x%x\n", gpt->MBR.BootCode[92]);
                 }
             }
         }

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_windows.c

@@ -314,6 +314,90 @@ static int ventoy_is_pe64(grub_uint8_t *buffer)
     return 0;
 }
 
+grub_err_t ventoy_cmd_is_pe64(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int ret = 1;
+    grub_file_t file;
+    grub_uint8_t buf[512];
+    
+    (void)ctxt;
+    (void)argc;
+
+    file = grub_file_open(args[0], VENTOY_FILE_TYPE);
+    if (!file)
+    {
+        return 1;
+    }
+
+    grub_memset(buf, 0, 512);
+    grub_file_read(file, buf, 512);
+    if (ventoy_is_pe64(buf))
+    {
+        debug("%s is PE64\n", args[0]);
+        ret = 0;
+    }
+    else
+    {
+        debug("%s is PE32\n", args[0]);
+    }
+    grub_file_close(file);
+
+    return ret;
+}
+
+grub_err_t ventoy_cmd_sel_wimboot(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int size;
+    char *buf = NULL;
+    char configfile[128];
+    
+    (void)ctxt;
+    (void)argc;
+    (void)args;
+
+    debug("select wimboot argc:%d\n", argc);
+
+    buf = (char *)grub_malloc(8192);
+    if (!buf)
+    {
+        return 0;
+    }
+
+    size = (int)grub_snprintf(buf, 8192, 
+        "menuentry \"Windows Setup (32-bit)\" {\n"
+        "    set vtoy_wimboot_sel=32\n"
+        "}\n"
+        "menuentry \"Windows Setup (64-bit)\" {\n"
+        "    set vtoy_wimboot_sel=64\n"
+        "}\n"
+        );
+    buf[size] = 0;
+
+    g_ventoy_menu_esc = 1;
+    g_ventoy_suppress_esc = 1;
+
+    grub_snprintf(configfile, sizeof(configfile), "configfile mem:0x%llx:size:%d", (ulonglong)(ulong)buf, size);
+    grub_script_execute_sourcecode(configfile);
+    
+    g_ventoy_menu_esc = 0;
+    g_ventoy_suppress_esc = 0;
+
+    grub_free(buf);
+
+    if (g_ventoy_last_entry == 0)
+    {
+        debug("last entry=%d %s=32\n", g_ventoy_last_entry, args[0]);
+        grub_env_set(args[0], "32");
+    }
+    else
+    {
+        debug("last entry=%d %s=64\n", g_ventoy_last_entry, args[0]);
+        grub_env_set(args[0], "64");
+    }
+
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
 grub_err_t ventoy_cmd_wimdows_reset(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     wim_patch *next = NULL;
@@ -1330,6 +1414,54 @@ end:
     return rc;
 }
 
+grub_err_t ventoy_cmd_windows_wimboot_data(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    grub_uint32_t size = 0;
+    const char *addr = NULL;
+    ventoy_chain_head *chain = NULL;
+    ventoy_os_param *param = NULL;
+    char envbuf[64];
+
+    (void)ctxt;
+    (void)argc;
+    (void)args;
+
+    addr = grub_env_get("vtoy_chain_mem_addr");
+    if (!addr)
+    {
+        debug("Failed to find vtoy_chain_mem_addr\n");
+        return 1;
+    }
+
+    chain = (ventoy_chain_head *)(void *)grub_strtoul(addr, NULL, 16);
+
+    if (grub_memcmp(&g_ventoy_guid, &chain->os_param.guid, 16) != 0)
+    {
+        debug("os_param.guid not match\n");
+        return 1;
+    }
+
+    size = sizeof(ventoy_os_param) + sizeof(ventoy_windows_data);
+    param = (ventoy_os_param *)grub_zalloc(size);
+    if (!param)
+    {
+        return 1;
+    }
+
+    grub_memcpy(param, &chain->os_param, sizeof(ventoy_os_param));
+    ventoy_fill_windows_rtdata(param + 1, param->vtoy_img_path);
+
+    grub_snprintf(envbuf, sizeof(envbuf), "0x%lx", (unsigned long)param);
+    grub_env_set("vtoy_wimboot_mem_addr", envbuf);
+    debug("vtoy_wimboot_mem_addr: %s\n", envbuf);
+    
+    grub_snprintf(envbuf, sizeof(envbuf), "%u", size);
+    grub_env_set("vtoy_wimboot_mem_size", envbuf);
+    debug("vtoy_wimboot_mem_size: %s\n", envbuf);
+    
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
 grub_err_t ventoy_cmd_windows_chain_data(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     int unknown_image = 0;
@@ -1762,3 +1894,29 @@ grub_err_t ventoy_cmd_wim_chain_data(grub_extcmd_context_t ctxt, int argc, char
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
+int ventoy_chain_file_size(const char *path)
+{
+    int size;
+    grub_file_t file;
+
+    file = grub_file_open(path, VENTOY_FILE_TYPE);
+    size = (int)(file->size);
+
+    grub_file_close(file);
+    
+    return size;
+}
+
+int ventoy_chain_file_read(const char *path, int offset, int len, void *buf)
+{
+    int size;
+    grub_file_t file;
+
+    file = grub_file_open(path, VENTOY_FILE_TYPE);
+    grub_file_seek(file, offset);
+    size = grub_file_read(file, buf, len);
+    grub_file_close(file);
+    
+    return size;
+}
+

GRUB2/MOD_SRC/grub-2.04/include/grub/efi/efi.h

@@ -87,6 +87,7 @@ EXPORT_FUNC (grub_efi_compare_device_paths) (const grub_efi_device_path_t *dp1,
 					     const grub_efi_device_path_t *dp2);
 
 void * EXPORT_FUNC (grub_efi_allocate_iso_buf) (grub_uint64_t size);
+void * EXPORT_FUNC (grub_efi_allocate_chain_buf) (grub_uint64_t size);
 
 
 extern void (*EXPORT_VAR(grub_efi_net_config)) (grub_efi_handle_t hnd, 

GRUB2/MOD_SRC/grub-2.04/util/setup.c

@@ -0,0 +1,878 @@
+/* grub-setup.c - make GRUB usable */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011  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 <config.h>
+#include <grub/types.h>
+#include <grub/emu/misc.h>
+#include <grub/util/misc.h>
+#include <grub/device.h>
+#include <grub/disk.h>
+#include <grub/file.h>
+#include <grub/fs.h>
+#include <grub/partition.h>
+#include <grub/env.h>
+#include <grub/emu/hostdisk.h>
+#include <grub/term.h>
+#include <grub/i18n.h>
+
+#ifdef GRUB_SETUP_SPARC64
+#include <grub/util/ofpath.h>
+#include <grub/sparc64/ieee1275/boot.h>
+#include <grub/sparc64/ieee1275/kernel.h>
+#else
+#include <grub/i386/pc/boot.h>
+#include <grub/i386/pc/kernel.h>
+#endif
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <assert.h>
+#include <grub/emu/getroot.h>
+#include "progname.h"
+#include <grub/reed_solomon.h>
+#include <grub/msdos_partition.h>
+#include <grub/crypto.h>
+#include <grub/util/install.h>
+#include <grub/emu/hostfile.h>
+
+#include <errno.h>
+
+/* On SPARC this program fills in various fields inside of the 'boot' and 'core'
+ * image files.
+ *
+ * The 'boot' image needs to know the OBP path name of the root
+ * device.  It also needs to know the initial block number of
+ * 'core' (which is 'diskboot' concatenated with 'kernel' and
+ * all the modules, this is created by grub-mkimage).  This resulting
+ * 'boot' image is 512 bytes in size and is placed in the second block
+ * of a partition.
+ *
+ * The initial 'diskboot' block acts as a loader for the actual GRUB
+ * kernel.  It contains the loading code and then a block list.
+ *
+ * The block list of 'core' starts at the end of the 'diskboot' image
+ * and works it's way backwards towards the end of the code of 'diskboot'.
+ *
+ * We patch up the images with the necessary values and write out the
+ * result.
+ */
+
+#ifdef GRUB_SETUP_SPARC64
+#define grub_target_to_host16(x)	grub_be_to_cpu16(x)
+#define grub_target_to_host32(x)	grub_be_to_cpu32(x)
+#define grub_target_to_host64(x)	grub_be_to_cpu64(x)
+#define grub_host_to_target16(x)	grub_cpu_to_be16(x)
+#define grub_host_to_target32(x)	grub_cpu_to_be32(x)
+#define grub_host_to_target64(x)	grub_cpu_to_be64(x)
+#elif defined (GRUB_SETUP_BIOS)
+#define grub_target_to_host16(x)	grub_le_to_cpu16(x)
+#define grub_target_to_host32(x)	grub_le_to_cpu32(x)
+#define grub_target_to_host64(x)	grub_le_to_cpu64(x)
+#define grub_host_to_target16(x)	grub_cpu_to_le16(x)
+#define grub_host_to_target32(x)	grub_cpu_to_le32(x)
+#define grub_host_to_target64(x)	grub_cpu_to_le64(x)
+#else
+#error Complete this
+#endif
+
+static void
+write_rootdev (grub_device_t root_dev,
+	       char *boot_img, grub_uint64_t first_sector)
+{
+#ifdef GRUB_SETUP_BIOS
+  {
+    grub_uint8_t *boot_drive;
+    void *kernel_sector;
+    boot_drive = (grub_uint8_t *) (boot_img + GRUB_BOOT_MACHINE_BOOT_DRIVE);
+    kernel_sector = (boot_img + GRUB_BOOT_MACHINE_KERNEL_SECTOR);
+
+    /* FIXME: can this be skipped?  */
+    *boot_drive = 0xFF;
+
+    grub_set_unaligned64 (kernel_sector, grub_cpu_to_le64 (first_sector));
+  }
+#endif
+#ifdef GRUB_SETUP_SPARC64
+  {
+    void *kernel_byte;
+    kernel_byte = (boot_img + GRUB_BOOT_AOUT_HEADER_SIZE
+		   + GRUB_BOOT_MACHINE_KERNEL_BYTE);
+    grub_set_unaligned64 (kernel_byte,
+			  grub_cpu_to_be64 (first_sector << GRUB_DISK_SECTOR_BITS));
+  }
+#endif
+}
+
+#ifdef GRUB_SETUP_SPARC64
+#define BOOT_SECTOR 1
+#else
+#define BOOT_SECTOR 0
+#endif
+
+/* Helper for setup.  */
+
+struct blocklists
+{
+  struct grub_boot_blocklist *first_block, *block;
+#ifdef GRUB_SETUP_BIOS
+  grub_uint16_t current_segment;
+#endif
+#ifdef GRUB_SETUP_SPARC64
+  grub_uint64_t gpt_offset;
+#endif
+  grub_uint16_t last_length;
+  grub_disk_addr_t first_sector;
+};
+
+/* Helper for setup.  */
+static void
+save_blocklists (grub_disk_addr_t sector, unsigned offset, unsigned length,
+		 void *data)
+{
+  struct blocklists *bl = data;
+  struct grub_boot_blocklist *prev = bl->block + 1;
+  grub_uint64_t seclen;
+
+#ifdef GRUB_SETUP_SPARC64
+  sector -= bl->gpt_offset;
+#endif
+
+  grub_util_info ("saving <%"  GRUB_HOST_PRIuLONG_LONG ",%u,%u>",
+		  (unsigned long long) sector, offset, length);
+
+  if (bl->first_sector == (grub_disk_addr_t) -1)
+    {
+      if (offset != 0 || length < GRUB_DISK_SECTOR_SIZE)
+	grub_util_error ("%s", _("the first sector of the core file is not sector-aligned"));
+
+      bl->first_sector = sector;
+      sector++;
+      length -= GRUB_DISK_SECTOR_SIZE;
+      if (!length)
+	return;
+    }
+
+  if (offset != 0 || bl->last_length != 0)
+    grub_util_error ("%s", _("non-sector-aligned data is found in the core file"));
+
+  seclen = (length + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS;
+
+  if (bl->block != bl->first_block
+      && (grub_target_to_host64 (prev->start)
+	  + grub_target_to_host16 (prev->len)) == sector)
+    {
+      grub_uint16_t t = grub_target_to_host16 (prev->len);
+      t += seclen;
+      prev->len = grub_host_to_target16 (t);
+    }
+  else
+    {
+      bl->block->start = grub_host_to_target64 (sector);
+      bl->block->len = grub_host_to_target16 (seclen);
+#ifdef GRUB_SETUP_BIOS
+      bl->block->segment = grub_host_to_target16 (bl->current_segment);
+#endif
+
+      bl->block--;
+      if (bl->block->len)
+	grub_util_error ("%s", _("the sectors of the core file are too fragmented"));
+    }
+
+  bl->last_length = length & (GRUB_DISK_SECTOR_SIZE - 1);
+#ifdef GRUB_SETUP_BIOS
+  bl->current_segment += seclen << (GRUB_DISK_SECTOR_BITS - 4);
+#endif
+}
+
+/* Context for setup/identify_partmap.  */
+struct identify_partmap_ctx
+{
+  grub_partition_map_t dest_partmap;
+  grub_partition_t container;
+  int multiple_partmaps;
+};
+
+/* Helper for setup.
+   Unlike root_dev, with dest_dev we're interested in the partition map even
+   if dest_dev itself is a whole disk.  */
+static int
+identify_partmap (grub_disk_t disk __attribute__ ((unused)),
+		  const grub_partition_t p, void *data)
+{
+  struct identify_partmap_ctx *ctx = data;
+
+  if (p->parent != ctx->container)
+    return 0;
+  /* NetBSD and OpenBSD subpartitions have metadata inside a partition,
+     so they are safe to ignore.
+   */
+  if (grub_strcmp (p->partmap->name, "netbsd") == 0
+      || grub_strcmp (p->partmap->name, "openbsd") == 0)
+    return 0;
+  if (ctx->dest_partmap == NULL)
+    {
+      ctx->dest_partmap = p->partmap;
+      return 0;
+    }
+  if (ctx->dest_partmap == p->partmap)
+    return 0;
+  ctx->multiple_partmaps = 1;
+  return 1;
+}
+
+#ifdef GRUB_SETUP_BIOS
+#define SETUP grub_util_bios_setup
+#elif GRUB_SETUP_SPARC64
+#define SETUP grub_util_sparc_setup
+#else
+#error "Shouldn't happen"
+#endif
+
+void
+SETUP (const char *dir,
+       const char *boot_file, const char *core_file,
+       const char *dest, int force,
+       int fs_probe, int allow_floppy,
+       int add_rs_codes __attribute__ ((unused))) /* unused on sparc64 */
+{
+  char *core_path;
+  char *boot_img, *core_img, *boot_path;
+  char *root = 0;
+  size_t boot_size, core_size;
+  grub_uint16_t core_sectors;
+  grub_device_t root_dev = 0, dest_dev, core_dev;
+  grub_util_fd_t fp;
+  struct blocklists bl;
+
+  bl.first_sector = (grub_disk_addr_t) -1;
+
+#ifdef GRUB_SETUP_BIOS
+  bl.current_segment =
+    GRUB_BOOT_I386_PC_KERNEL_SEG + (GRUB_DISK_SECTOR_SIZE >> 4);
+#endif
+  bl.last_length = 0;
+
+  /* Read the boot image by the OS service.  */
+  boot_path = grub_util_get_path (dir, boot_file);
+  boot_size = grub_util_get_image_size (boot_path);
+  if (boot_size != GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is not %u"),
+		     boot_path, GRUB_DISK_SECTOR_SIZE);
+  boot_img = grub_util_read_image (boot_path);
+  free (boot_path);
+
+  core_path = grub_util_get_path (dir, core_file);
+  core_size = grub_util_get_image_size (core_path);
+  core_sectors = ((core_size + GRUB_DISK_SECTOR_SIZE - 1)
+		  >> GRUB_DISK_SECTOR_BITS);
+  if (core_size < GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is too small"), core_path);
+#ifdef GRUB_SETUP_BIOS
+  if (core_size > 0xFFFF * GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is too large"), core_path);
+#endif
+
+  core_img = grub_util_read_image (core_path);
+
+  /* Have FIRST_BLOCK to point to the first blocklist.  */
+  bl.first_block = (struct grub_boot_blocklist *) (core_img
+						   + GRUB_DISK_SECTOR_SIZE
+						   - sizeof (*bl.block));
+
+  grub_util_info ("Opening dest `%s'", dest);
+  dest_dev = grub_device_open (dest);
+  if (! dest_dev)
+    grub_util_error ("%s", grub_errmsg);
+
+  core_dev = dest_dev;
+
+  {
+    char **root_devices = grub_guess_root_devices (dir);
+    char **cur;
+    int found = 0;
+
+    if (!root_devices)
+      grub_util_error (_("cannot find a device for %s (is /dev mounted?)"), dir);
+
+    for (cur = root_devices; *cur; cur++)
+      {
+	char *drive;
+	grub_device_t try_dev;
+
+	drive = grub_util_get_grub_dev (*cur);
+	if (!drive)
+	  continue;
+	try_dev = grub_device_open (drive);
+	if (! try_dev)
+	  {
+	    free (drive);
+	    continue;
+	  }
+	if (!found && try_dev->disk->id == dest_dev->disk->id
+	    && try_dev->disk->dev->id == dest_dev->disk->dev->id)
+	  {
+	    if (root_dev)
+	      grub_device_close (root_dev);
+	    free (root);
+	    root_dev = try_dev;
+	    root = drive;
+	    found = 1;
+	    continue;
+	  }
+	if (!root_dev)
+	  {
+	    root_dev = try_dev;
+	    root = drive;
+	    continue;
+	  }
+	grub_device_close (try_dev);	
+	free (drive);
+      }
+    if (!root_dev)
+      {
+        root = grub_util_get_grub_dev ("/dev/sda");
+        root_dev = grub_device_open (root);
+        if (root_dev)
+	        grub_util_info ("guessing the root device failed, because of `%s'", grub_errmsg);
+	    else
+    	    grub_util_error ("guessing the root device failed, because of `%s'", grub_errmsg);
+      }
+    grub_util_info ("guessed root_dev `%s' from "
+		    "dir `%s'", root_dev->disk->name, dir);
+
+    for (cur = root_devices; *cur; cur++)
+      free (*cur);
+    free (root_devices);
+  }
+
+  grub_util_info ("setting the root device to `%s'", root);
+  if (grub_env_set ("root", root) != GRUB_ERR_NONE)
+    grub_util_error ("%s", grub_errmsg);
+
+  {
+#ifdef GRUB_SETUP_BIOS
+    char *tmp_img;
+    grub_uint8_t *boot_drive_check;
+
+    /* Read the original sector from the disk.  */
+    tmp_img = xmalloc (GRUB_DISK_SECTOR_SIZE);
+    if (grub_disk_read (dest_dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, tmp_img))
+      grub_util_error ("%s", grub_errmsg);
+    
+    boot_drive_check = (grub_uint8_t *) (boot_img
+					  + GRUB_BOOT_MACHINE_DRIVE_CHECK);
+    /* Copy the possible DOS BPB.  */
+    memcpy (boot_img + GRUB_BOOT_MACHINE_BPB_START,
+	    tmp_img + GRUB_BOOT_MACHINE_BPB_START,
+	    GRUB_BOOT_MACHINE_BPB_END - GRUB_BOOT_MACHINE_BPB_START);
+
+    /* If DEST_DRIVE is a hard disk, enable the workaround, which is
+       for buggy BIOSes which don't pass boot drive correctly. Instead,
+       they pass 0x00 or 0x01 even when booted from 0x80.  */
+    if (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk))
+      {
+	/* Replace the jmp (2 bytes) with double nop's.  */
+	boot_drive_check[0] = 0x90;
+	boot_drive_check[1] = 0x90;
+      }
+#endif
+
+    struct identify_partmap_ctx ctx = {
+      .dest_partmap = NULL,
+      .container = dest_dev->disk->partition,
+      .multiple_partmaps = 0
+    };
+    int is_ldm;
+    grub_err_t err;
+    grub_disk_addr_t *sectors;
+    int i;
+    grub_fs_t fs;
+    unsigned int nsec, maxsec;
+
+    grub_partition_iterate (dest_dev->disk, identify_partmap, &ctx);
+
+#ifdef GRUB_SETUP_BIOS
+    /* Copy the partition table.  */
+    if (ctx.dest_partmap ||
+        (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk)))
+      memcpy (boot_img + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC,
+	      tmp_img + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC,
+	      GRUB_BOOT_MACHINE_PART_END - GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC);
+
+    free (tmp_img);
+#endif
+
+    if (ctx.container
+	&& grub_strcmp (ctx.container->partmap->name, "msdos") == 0
+	&& ctx.dest_partmap
+	&& (ctx.container->msdostype == GRUB_PC_PARTITION_TYPE_NETBSD
+	    || ctx.container->msdostype == GRUB_PC_PARTITION_TYPE_OPENBSD))
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a disk with multiple partition labels or both partition label and filesystem.  This is not supported yet."));
+	goto unable_to_embed;
+      }
+
+    fs = grub_fs_probe (dest_dev);
+    if (!fs)
+      grub_errno = GRUB_ERR_NONE;
+
+    is_ldm = grub_util_is_ldm (dest_dev->disk);
+
+    if (fs_probe)
+      {
+	if (!fs && !ctx.dest_partmap)
+	  grub_util_error (_("unable to identify a filesystem in %s; safety check can't be performed"),
+			   dest_dev->disk->name);
+	if (fs && !fs->reserved_first_sector)
+	  /* TRANSLATORS: Filesystem may reserve the space just GRUB isn't sure about it.  */
+	  grub_util_error (_("%s appears to contain a %s filesystem which isn't known to "
+			     "reserve space for DOS-style boot.  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"), dest_dev->disk->name, fs->name);
+
+	if (ctx.dest_partmap && strcmp (ctx.dest_partmap->name, "msdos") != 0
+	    && strcmp (ctx.dest_partmap->name, "gpt") != 0
+	    && strcmp (ctx.dest_partmap->name, "bsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "netbsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "openbsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "sunpc") != 0)
+	  /* TRANSLATORS: Partition map may reserve the space just GRUB isn't sure about it.  */
+	  grub_util_error (_("%s appears to contain a %s partition map which isn't known to "
+			     "reserve space for DOS-style boot.  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"), dest_dev->disk->name, ctx.dest_partmap->name);
+	if (is_ldm && ctx.dest_partmap && strcmp (ctx.dest_partmap->name, "msdos") != 0
+	    && strcmp (ctx.dest_partmap->name, "gpt") != 0)
+	  grub_util_error (_("%s appears to contain a %s partition map and "
+			     "LDM which isn't known to be a safe combination."
+			     "  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data"
+			     " is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"),
+			   dest_dev->disk->name, ctx.dest_partmap->name);
+
+      }
+
+    if (! ctx.dest_partmap && ! fs && !is_ldm)
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a partitionless disk or to a partition.  This is a BAD idea."));
+	goto unable_to_embed;
+      }
+    if (ctx.multiple_partmaps || (ctx.dest_partmap && fs) || (is_ldm && fs))
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a disk with multiple partition labels.  This is not supported yet."));
+	goto unable_to_embed;
+      }
+
+    if (ctx.dest_partmap && !ctx.dest_partmap->embed)
+      {
+	grub_util_warn (_("Partition style `%s' doesn't support embedding"),
+			ctx.dest_partmap->name);
+	goto unable_to_embed;
+      }
+
+    if (fs && !fs->fs_embed)
+      {
+	grub_util_warn (_("File system `%s' doesn't support embedding"),
+			fs->name);
+	goto unable_to_embed;
+      }
+
+    nsec = core_sectors;
+
+    if (add_rs_codes)
+      maxsec = 2 * core_sectors;
+    else
+      maxsec = core_sectors;
+
+#ifdef GRUB_SETUP_BIOS
+    if (maxsec > ((0x78000 - GRUB_KERNEL_I386_PC_LINK_ADDR)
+		>> GRUB_DISK_SECTOR_BITS))
+      maxsec = ((0x78000 - GRUB_KERNEL_I386_PC_LINK_ADDR)
+		>> GRUB_DISK_SECTOR_BITS);
+#endif
+
+#ifdef GRUB_SETUP_SPARC64
+    /*
+     * On SPARC we need two extra. One is because we are combining the
+     * core.img with the boot.img. The other is because the boot sector
+     * starts at 1.
+     */
+    nsec += 2;
+    maxsec += 2;
+#endif
+
+    if (is_ldm)
+      err = grub_util_ldm_embed (dest_dev->disk, &nsec, maxsec,
+				 GRUB_EMBED_PCBIOS, &sectors);
+    else if (ctx.dest_partmap)
+      err = ctx.dest_partmap->embed (dest_dev->disk, &nsec, maxsec,
+				     GRUB_EMBED_PCBIOS, &sectors);
+    else
+      err = fs->fs_embed (dest_dev, &nsec, maxsec,
+			  GRUB_EMBED_PCBIOS, &sectors);
+    if (!err && nsec < core_sectors)
+      {
+	err = grub_error (GRUB_ERR_OUT_OF_RANGE,
+			  N_("Your embedding area is unusually small.  "
+			     "core.img won't fit in it."));
+      }
+    
+    if (err)
+      {
+	grub_util_warn ("%s", grub_errmsg);
+	grub_errno = GRUB_ERR_NONE;
+	goto unable_to_embed;
+      }
+
+    assert (nsec <= maxsec);
+
+    /* Clean out the blocklists.  */
+    bl.block = bl.first_block;
+    while (bl.block->len)
+      {
+	grub_memset (bl.block, 0, sizeof (*bl.block));
+      
+	bl.block--;
+
+	if ((char *) bl.block <= core_img)
+	  grub_util_error ("%s", _("no terminator in the core image"));
+      }
+
+    bl.block = bl.first_block;
+    for (i = 0; i < nsec; i++)
+      save_blocklists (sectors[i] + grub_partition_get_start (ctx.container),
+		       0, GRUB_DISK_SECTOR_SIZE, &bl);
+
+    /* Make sure that the last blocklist is a terminator.  */
+    if (bl.block == bl.first_block)
+      bl.block--;
+    bl.block->start = 0;
+    bl.block->len = 0;
+#ifdef GRUB_SETUP_BIOS
+    bl.block->segment = 0;
+#endif
+
+#ifdef GRUB_SETUP_SPARC64
+    {
+      /*
+       * On SPARC, the block-list entries need to be based off the beginning
+       * of the parition, not the beginning of the disk.
+       */
+      struct grub_boot_blocklist *block;
+      block = bl.first_block;
+
+      while (block->len)
+        {
+          block->start -= bl.first_sector;
+          block--;
+        }
+    }
+
+    /*
+     * Reserve space for the boot block since it can not be in the
+     * Parition table on SPARC.
+     */
+    assert (bl.first_block->len > 2);
+    bl.first_block->start += 2;
+    bl.first_block->len -= 2;
+    write_rootdev (root_dev, boot_img, sectors[BOOT_SECTOR + 1] - bl.first_sector);
+#endif
+
+#ifdef GRUB_SETUP_BIOS
+    write_rootdev (root_dev, boot_img, bl.first_sector);
+#endif
+
+    /* Round up to the nearest sector boundary, and zero the extra memory */
+    core_img = xrealloc (core_img, nsec * GRUB_DISK_SECTOR_SIZE);
+    assert (core_img && (nsec * GRUB_DISK_SECTOR_SIZE >= core_size));
+    memset (core_img + core_size, 0, nsec * GRUB_DISK_SECTOR_SIZE - core_size);
+
+    bl.first_block = (struct grub_boot_blocklist *) (core_img
+						     + GRUB_DISK_SECTOR_SIZE
+						     - sizeof (*bl.block));
+#if GRUB_SETUP_BIOS
+    grub_size_t no_rs_length;
+    no_rs_length = grub_target_to_host16 
+      (grub_get_unaligned16 (core_img
+			     + GRUB_DISK_SECTOR_SIZE
+			     + GRUB_KERNEL_I386_PC_NO_REED_SOLOMON_LENGTH));
+
+    if (no_rs_length == 0xffff)
+      grub_util_error ("%s", _("core.img version mismatch"));
+
+    if (add_rs_codes)
+      {
+	grub_set_unaligned32 ((core_img + GRUB_DISK_SECTOR_SIZE
+			       + GRUB_KERNEL_I386_PC_REED_SOLOMON_REDUNDANCY),
+			      grub_host_to_target32 (nsec * GRUB_DISK_SECTOR_SIZE - core_size));
+
+	void *tmp = xmalloc (core_size);
+	grub_memcpy (tmp, core_img, core_size);
+	grub_reed_solomon_add_redundancy (core_img + no_rs_length + GRUB_DISK_SECTOR_SIZE,
+					  core_size - no_rs_length - GRUB_DISK_SECTOR_SIZE,
+					  nsec * GRUB_DISK_SECTOR_SIZE
+					  - core_size);
+	assert (grub_memcmp (tmp, core_img, core_size) == 0);
+	free (tmp);
+      }
+
+    /* Write the core image onto the disk.  */
+    for (i = 0; i < nsec; i++)
+      grub_disk_write (dest_dev->disk, sectors[i], 0,
+		       GRUB_DISK_SECTOR_SIZE,
+		       core_img + i * GRUB_DISK_SECTOR_SIZE);
+#endif
+
+#ifdef GRUB_SETUP_SPARC64
+    {
+      int isec = BOOT_SECTOR;
+
+      /* Write the boot image onto the disk. */
+      if (grub_disk_write (dest_dev->disk, sectors[isec++], 0,
+                           GRUB_DISK_SECTOR_SIZE, boot_img))
+        grub_util_error ("%s", grub_errmsg);
+
+      /* Write the core image onto the disk. */
+      for (i = 0 ; isec < nsec; i++, isec++)
+        {
+          if (grub_disk_write (dest_dev->disk, sectors[isec], 0,
+                               GRUB_DISK_SECTOR_SIZE,
+                               core_img  + i * GRUB_DISK_SECTOR_SIZE))
+            grub_util_error ("%s", grub_errmsg);
+        }
+    }
+
+#endif
+    grub_free (sectors);
+
+    goto finish;
+  }
+
+unable_to_embed:
+
+  if (dest_dev->disk->dev->id != root_dev->disk->dev->id)
+    grub_util_error ("%s", _("embedding is not possible, but this is required for "
+			     "RAID and LVM install"));
+
+  {
+    grub_fs_t fs;
+    fs = grub_fs_probe (root_dev);
+    if (!fs)
+      grub_util_error (_("can't determine filesystem on %s"), root);
+
+    if (!fs->blocklist_install)
+      grub_util_error (_("filesystem `%s' doesn't support blocklists"),
+		       fs->name);
+  }
+
+#ifdef GRUB_SETUP_BIOS
+  if (dest_dev->disk->id != root_dev->disk->id
+      || dest_dev->disk->dev->id != root_dev->disk->dev->id)
+    /* TRANSLATORS: cross-disk refers to /boot being on one disk
+       but MBR on another.  */
+    grub_util_error ("%s", _("embedding is not possible, but this is required for "
+			     "cross-disk install"));
+#else
+  core_dev = root_dev;
+#endif
+
+  grub_util_warn ("%s", _("Embedding is not possible.  GRUB can only be installed in this "
+			  "setup by using blocklists.  However, blocklists are UNRELIABLE and "
+			  "their use is discouraged."));
+  if (! force)
+    /* TRANSLATORS: Here GRUB refuses to continue with blocklist install.  */
+    grub_util_error ("%s", _("will not proceed with blocklists"));
+
+  /* The core image must be put on a filesystem unfortunately.  */
+  grub_util_info ("will leave the core image on the filesystem");
+
+  grub_util_biosdisk_flush (root_dev->disk);
+
+  /* Clean out the blocklists.  */
+  bl.block = bl.first_block;
+  while (bl.block->len)
+    {
+      bl.block->start = 0;
+      bl.block->len = 0;
+#ifdef GRUB_SETUP_BIOS
+      bl.block->segment = 0;
+#endif
+
+      bl.block--;
+
+      if ((char *) bl.block <= core_img)
+	grub_util_error ("%s", _("no terminator in the core image"));
+    }
+
+  bl.block = bl.first_block;
+
+#ifdef GRUB_SETUP_SPARC64
+  {
+    grub_partition_t container = root_dev->disk->partition;
+    bl.gpt_offset = 0;
+
+    if (grub_strstr (container->partmap->name, "gpt"))
+      bl.gpt_offset = grub_partition_get_start (container);
+  }
+#endif
+
+  grub_install_get_blocklist (root_dev, core_path, core_img, core_size,
+			      save_blocklists, &bl);
+
+  if (bl.first_sector == (grub_disk_addr_t)-1)
+    grub_util_error ("%s", _("can't retrieve blocklists"));
+
+#ifdef GRUB_SETUP_SPARC64
+  {
+    char *boot_devpath;
+    boot_devpath = (char *) (boot_img
+			     + GRUB_BOOT_AOUT_HEADER_SIZE
+			     + GRUB_BOOT_MACHINE_BOOT_DEVPATH);
+    if (dest_dev->disk->id != root_dev->disk->id
+	|| dest_dev->disk->dev->id != root_dev->disk->dev->id)
+      {
+	char *dest_ofpath;
+	dest_ofpath
+	  = grub_util_devname_to_ofpath (grub_util_biosdisk_get_osdev (root_dev->disk));
+	/* FIXME handle NULL result */
+	grub_util_info ("dest_ofpath is `%s'", dest_ofpath);
+	strncpy (boot_devpath, dest_ofpath,
+		 GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		 - GRUB_BOOT_MACHINE_BOOT_DEVPATH - 1);
+	boot_devpath[GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		   - GRUB_BOOT_MACHINE_BOOT_DEVPATH - 1] = 0;
+	free (dest_ofpath);
+      }
+    else
+      {
+	grub_util_info ("non cross-disk install");
+	memset (boot_devpath, 0, GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		- GRUB_BOOT_MACHINE_BOOT_DEVPATH);
+      }
+    grub_util_info ("boot device path %s", boot_devpath);
+  }
+#endif
+
+  write_rootdev (root_dev, boot_img, bl.first_sector);
+
+  /* Write the first two sectors of the core image onto the disk.  */
+  grub_util_info ("opening the core image `%s'", core_path);
+  fp = grub_util_fd_open (core_path, GRUB_UTIL_FD_O_WRONLY);
+  if (! GRUB_UTIL_FD_IS_VALID (fp))
+    grub_util_error (_("cannot open `%s': %s"), core_path,
+		     grub_util_fd_strerror ());
+
+  if (grub_util_fd_write (fp, core_img, GRUB_DISK_SECTOR_SIZE * 2)
+      != GRUB_DISK_SECTOR_SIZE * 2)
+    grub_util_error (_("cannot write to `%s': %s"),
+		     core_path, strerror (errno));
+  if (grub_util_fd_sync (fp) < 0)
+    grub_util_error (_("cannot sync `%s': %s"), core_path, strerror (errno));
+  if (grub_util_fd_close (fp) < 0)
+    grub_util_error (_("cannot close `%s': %s"), core_path, strerror (errno));
+  grub_util_biosdisk_flush (root_dev->disk);
+
+  grub_disk_cache_invalidate_all ();
+
+  {
+    char *buf, *ptr = core_img;
+    size_t len = core_size;
+    grub_uint64_t blk, offset = 0;
+    grub_partition_t container = core_dev->disk->partition;
+    grub_err_t err;
+
+    core_dev->disk->partition = 0;
+#ifdef GRUB_SETUP_SPARC64
+    offset = bl.gpt_offset;
+#endif
+
+    buf = xmalloc (core_size);
+    blk = bl.first_sector;
+    err = grub_disk_read (core_dev->disk, blk + offset, 0, GRUB_DISK_SECTOR_SIZE, buf);
+    if (err)
+      grub_util_error (_("cannot read `%s': %s"), core_dev->disk->name,
+		       grub_errmsg);
+    if (grub_memcmp (buf, ptr, GRUB_DISK_SECTOR_SIZE) != 0)
+      grub_util_error ("%s", _("blocklists are invalid"));
+
+    ptr += GRUB_DISK_SECTOR_SIZE;
+    len -= GRUB_DISK_SECTOR_SIZE;
+
+    bl.block = bl.first_block;
+    while (bl.block->len)
+      {
+	size_t cur = grub_target_to_host16 (bl.block->len) << GRUB_DISK_SECTOR_BITS;
+	blk = grub_target_to_host64 (bl.block->start);
+
+	if (cur > len)
+	  cur = len;
+
+	err = grub_disk_read (core_dev->disk, blk + offset, 0, cur, buf);
+	if (err)
+	  grub_util_error (_("cannot read `%s': %s"), core_dev->disk->name,
+			   grub_errmsg);
+
+	if (grub_memcmp (buf, ptr, cur) != 0)
+	  grub_util_error ("%s", _("blocklists are invalid"));
+
+	ptr += cur;
+	len -= cur;
+	bl.block--;
+	
+	if ((char *) bl.block <= core_img)
+	  grub_util_error ("%s", _("no terminator in the core image"));
+      }
+    if (len)
+      grub_util_error ("%s", _("blocklists are incomplete"));
+    core_dev->disk->partition = container;
+    free (buf);
+  }
+
+#ifdef GRUB_SETUP_BIOS
+ finish:
+#endif
+
+  /* Write the boot image onto the disk.  */
+  if (grub_disk_write (dest_dev->disk, BOOT_SECTOR,
+		       0, GRUB_DISK_SECTOR_SIZE, boot_img))
+    grub_util_error ("%s", grub_errmsg);
+
+#ifdef GRUB_SETUP_SPARC64
+ finish:
+#endif
+
+  grub_util_biosdisk_flush (root_dev->disk);
+  grub_util_biosdisk_flush (dest_dev->disk);
+
+  free (core_path);
+  free (core_img);
+  free (boot_img);
+  grub_device_close (dest_dev);
+  grub_device_close (root_dev);
+}
+

IMG/cpio/ventoy/hook/rhel7/ventoy-hook.sh

@@ -96,6 +96,12 @@ if $GREP -q el8 /proc/version; then
     vtNeedRepo="yes"
 fi
 
+if $GREP -i -q Fedora /proc/version; then
+    if $GREP -q 'Server Edition' /etc/os-release; then
+        vtNeedRepo="yes"
+    fi
+fi
+
 if [ "$vtNeedRepo" = "yes" ]; then
     $BUSYBOX_PATH/cp -a $VTOY_PATH/hook/rhel7/ventoy-repo.sh /lib/dracut/hooks/pre-pivot/99-ventoy-repo.sh
 fi

INSTALL/CreatePersistentImg.sh

@@ -4,6 +4,7 @@ size=1024
 fstype=ext4
 label=casper-rw
 config=''
+outputfile=persistence.dat
 
 print_usage() {
     echo 'Usage:  CreatePersistentImg.sh [ -s size ] [ -t fstype ] [ -l LABEL ] [ -c CFG ]'
@@ -12,6 +13,7 @@ print_usage() {
     echo '   -t filesystem type, default is ext4  ext2/ext3/ext4/xfs are supported now'
     echo '   -l label, default is casper-rw'
     echo '   -c configfile name inside the persistence file. File content is "/ union"'
+    echo '   -o outputfile name, default is persistence.dat'
     echo ''
 }
 
@@ -28,6 +30,9 @@ while [ -n "$1" ]; do
     elif [ "$1" = "-c" ]; then
         shift
         config=$1
+    elif [ "$1" = "-o" ]; then
+        shift
+        outputfile=$1
     elif [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
         print_usage
         exit 0
@@ -69,13 +74,17 @@ else
     exit 1
 fi
 
+if [ "$outputdir" != "persistence.dat" ]; then
+    mkdir -p "$(dirname "$outputfile")"
+fi
+
 # 00->ff avoid sparse file
-dd if=/dev/zero  bs=1M count=$size | tr '\000' '\377' > persistence.dat
+dd if=/dev/zero  bs=1M count=$size | tr '\000' '\377' > "$outputfile"
 sync
 
 freeloop=$(losetup -f)
 
-losetup $freeloop persistence.dat
+losetup $freeloop "$outputfile"
 
 mkfs -t $fstype $fsopt -L $label $freeloop 
 

INSTALL/ExtendPersistentImg.sh

@@ -0,0 +1,97 @@
+#!/bin/sh
+
+print_usage() {
+    echo 'Usage:  ExtendPersistentImg.sh file size'
+    echo '   file   persistent dat file'
+    echo '   size   extend size in MB'
+    echo 'Example:'
+    echo '   sh ExtendPersistentImg.sh ubuntu.dat 2048'
+    echo ''
+}
+
+if [ -z "$1" -o "$1" = "-h" ]; then
+    print_usage
+    exit 1
+fi
+
+if [ -z "$2" ]; then
+    print_usage
+    exit 1
+fi
+
+file=$1
+size=$2
+
+if [ ! -f "$file" ]; then
+    echo "$file not exist."
+    exit 1
+fi
+
+if echo $size | grep -q "[^0-9]"; then
+    print_usage
+    exit 1
+fi
+
+fsize=$(stat -c '%s' $file)
+
+fsmod=$(expr $fsize % 1024)
+if [ $fsmod -ne 0 ]; then
+    echo "File size of $file is not aligned by 1MB, please check."
+    exit 1
+fi
+
+
+fsMB=$(expr $fsize / 1024 / 1024)
+total=$(expr $fsMB + $size)
+
+magic=$(hexdump -n3 -e  '3/1 "%02X"' $file)
+if [ "$magic" = "584653" ]; then
+    if which xfs_growfs >/dev/null 2>&1; then
+        cmd=xfs_growfs
+    else
+        echo 'xfs_growfs not found, please install xfsprogs first'
+        exit 1
+    fi
+else
+    if which resize2fs >/dev/null 2>&1; then
+        cmd=resize2fs
+    else
+        echo 'resize2fs not found, please install e2fsprogs first'
+        exit 1
+    fi
+fi
+
+
+echo "Extend dat file... (current is ${fsMB}MB, append ${size}MB, total ${total}MB)"
+dd if=/dev/zero bs=1M count=$size status=none >> "$file"
+sync
+
+freeloop=$(losetup -f)
+losetup $freeloop "$file"
+
+if [ "$cmd" = "resize2fs" ]; then    
+    echo "Extend ext filesystem by resize2fs ..."
+    echo "resize2fs $freeloop ${total}M"
+    e2fsck -f $freeloop
+    resize2fs $freeloop ${total}M
+    ret=$?
+else
+    echo "Extend xfs filesystem by xfs_growfs ..."
+
+    tmpdir=$(mktemp -d)
+    mount $freeloop $tmpdir
+    xfs_growfs $freeloop
+    ret=$?
+    umount $tmpdir && rm -rf $tmpdir
+fi
+
+losetup -d $freeloop
+
+echo ""
+if [ $ret -eq 0 ]; then
+    echo "======= SUCCESS ========="
+else
+    echo "======= FAILED ========="
+fi
+echo ""
+

INSTALL/README

@@ -38,5 +38,12 @@ Please refer https://www.ventoy.net/en/plugin_persistence.html for details.
 
 
 
+========== ExtendPersistentImg.sh ===============
+sudo sh ExtendPersistentImg.sh  file size   
+For example:
+sh ExtendPersistentImg.sh persistence.dat 2048  ---->  Extend persistence.dat by 2048MB
+That is to say, persistence.dat file will grow to 3GB size (assume that it is 1GB size before extend)
+
+Please refer https://www.ventoy.net/en/plugin_persistence.html for details.
 
 

INSTALL/grub/arm64-efi/moddep.lst

@@ -23,7 +23,7 @@ sfs: fshelp
 reiserfs: fshelp
 part_sunpc:
 zstd:
-gfxmenu: video_colors trig bitmap_scale gfxterm font normal bitmap video
+gfxmenu: trig video_colors bitmap_scale gfxterm font normal bitmap video
 jfs:
 help: extcmd normal
 configfile: normal
@@ -68,7 +68,7 @@ gfxterm_background: video_colors bitmap_scale gfxterm extcmd video bitmap
 search_fs_uuid:
 gcry_dsa: pgp mpi
 keystatus: extcmd
-linux: verifiers boot fdt
+linux: ventoy verifiers boot fdt
 geli: cryptodisk crypto gcry_sha512 pbkdf2 gcry_sha256
 cmdline_cat_test: font functional_test normal procfs video_fb
 part_sun:
@@ -93,7 +93,7 @@ terminal:
 div:
 crypto:
 part_bsd: part_msdos
-ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd normal video gcry_sha1 iso9660
+ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd datetime div normal video gcry_sha1 iso9660
 gcry_sha512: crypto
 password: crypto normal
 fshelp:

INSTALL/grub/grub.cfg

@@ -131,7 +131,7 @@ function get_os_type {
 function vt_check_compatible_pe {
     #Check for PE without external tools
     if [ -f "$1/HBCD_PE.ini" ]; then
-        set ventoy_compatible=YES        
+        set ventoy_compatible=YES
     fi
 }
 
@@ -535,6 +535,10 @@ function uefi_windows_menu_func {
     vt_windows_chain_data "${1}${chosen_path}"
     ventoy_debug_pause
     
+    if vt_check_mode 4; then
+        vtoy_windows_wimboot_func
+    fi
+    
     if [ -n "$vtoy_chain_mem_addr" ]; then
         ventoy_acpi_param ${vtoy_chain_mem_addr} 2048
         ventoy_cli_console
@@ -805,6 +809,86 @@ function uefi_iso_memdisk {
 }
 
 
+function vtoy_windows_wimboot_func {
+    if [ -f (loop)/x86/sources/boot.wim -a -f (loop)/x64/sources/boot.wim ]; then
+        vt_sel_wimboot vtoy_wimboot_bit
+        if [ "$vtoy_wimboot_bit" = "32" ]; then
+            set vtoy_wimboot_prefix=(loop)/x86
+        else
+            set vtoy_wimboot_prefix=(loop)/x64
+        fi
+    else
+        set vtoy_wimboot_prefix=(loop)
+        if vt_is_pe64 $vtoy_wimboot_prefix/setup.exe; then
+            set vtoy_wimboot_bit=64
+        else
+            set vtoy_wimboot_bit=32
+        fi
+    fi
+
+    if [ -n "${vtdebug_flag}" ]; then
+        echo vtoy_wimboot_prefix=$vtoy_wimboot_prefix vtoy_wimboot_bit=$vtoy_wimboot_bit
+    fi
+
+    for wmfile in sources/boot.wim boot/bcd boot/boot.sdi; do
+        if [ ! -f $vtoy_wimboot_prefix/$wmfile ]; then
+            return
+        fi
+    done
+
+    if [ -f $vtoy_wimboot_prefix/sources/install.wim -o -f $vtoy_wimboot_prefix/sources/install.esd ]; then
+        vt_windows_wimboot_data
+    else
+        return
+    fi
+    
+    if [ "$grub_platform" = "pc" ]; then
+        set vt_wimkernel=wimboot.x86_64.xz
+        
+        linux16  "$vtoy_path/$vt_wimkernel"  quiet
+        ventoy_debug_pause
+
+        vt_set_wim_load_prompt 1 "Loading files......"
+        initrd16 newc:vtoyjump.exe:$vtoy_path/vtoyjump${vtoy_wimboot_bit}.exe \
+             newc:wimboot.data:mem:${vtoy_wimboot_mem_addr}:size:${vtoy_wimboot_mem_size} \
+             newc:winpeshl.ini:mem:${vtoy_winpeshl_ini_addr}:size:${vtoy_winpeshl_ini_size} \
+             newc:bcd:$vtoy_wimboot_prefix/boot/bcd \
+             newc:boot.sdi:$vtoy_wimboot_prefix/boot/boot.sdi \
+             newc:boot.wim:$vtoy_wimboot_prefix/sources/boot.wim
+        vt_set_wim_load_prompt 0
+        boot
+    else
+        if [ "$grub_cpu" = "i386" ]; then
+            set vt_wimkernel=wimboot.i386.efi.xz
+        else
+            set vt_wimkernel=wimboot.x86_64.xz
+        fi
+
+        vt_set_wim_load_prompt 1 "Loading files......"
+        vt_load_file_to_mem "nodecompress" $vtoy_wimboot_prefix/sources/boot.wim vtoy_wimfile_mem
+        vt_set_wim_load_prompt 0
+
+        if [ $? -eq 0 ]; then
+            set vtoy_wimfile_path=mem:${vtoy_wimfile_mem_addr}:size:${vtoy_wimfile_mem_size}
+        else
+            set vtoy_wimfile_path=$vtoy_wimboot_prefix/sources/boot.wim
+        fi
+
+        ventoy_cli_console
+        chainloader "$vtoy_path/$vt_wimkernel" quiet \
+            "vf=wimboot.data:mem:${vtoy_wimboot_mem_addr}:size:${vtoy_wimboot_mem_size}" \
+            "vf=winpeshl.ini:mem:${vtoy_winpeshl_ini_addr}:size:${vtoy_winpeshl_ini_size}" \
+            "vf=vtoyjump.exe:$vtoy_path/vtoyjump${vtoy_wimboot_bit}.exe" \
+            "vf=bcd:$vtoy_wimboot_prefix/boot/bcd" \
+            "vf=boot.sdi:$vtoy_wimboot_prefix/boot/boot.sdi" \
+            "vf=boot.wim:$vtoy_wimfile_path" \
+            pfsize=$vtoy_chain_file_size  \
+            pfread=$vtoy_chain_file_read
+        boot
+        ventoy_gui_console
+    fi
+}
+
 function legacy_windows_menu_func {
     vt_windows_reset
     
@@ -833,7 +917,11 @@ function legacy_windows_menu_func {
 
     vt_windows_chain_data "${1}${chosen_path}"
     ventoy_debug_pause    
-    
+
+    if vt_check_mode 4; then
+        vtoy_windows_wimboot_func
+    fi
+
     if [ -n "$vtoy_chain_mem_addr" ]; then
         ventoy_acpi_param ${vtoy_chain_mem_addr} 2048
         linux16   $vtoy_path/ipxe.krn ${vtdebug_flag} ibft mem:${vtoy_chain_mem_addr}:size:${vtoy_chain_mem_size}        
@@ -1230,6 +1318,30 @@ function efi_unsupport_menuentry {
     common_unsupport_menuentry
 }
 
+function vhdboot_common_func {
+    vt_patch_vhdboot "$1"
+    
+    ventoy_debug_pause    
+    
+    if [ -n "$vtoy_vhd_buf_addr" ]; then
+        if [ "$grub_platform" = "pc" ]; then
+            ventoy_cli_console
+            linux16   $vtoy_path/memdisk iso raw    
+            initrd16  mem:${vtoy_vhd_buf_addr}:size:${vtoy_vhd_buf_size}            
+            boot
+            ventoy_gui_console
+        else
+            ventoy_cli_console
+            chainloader ${vtoy_path}/ventoy_${VTOY_EFI_ARCH}.efi memdisk env_param=${env_param} isoefi=${LoadIsoEfiDriver} ${vtdebug_flag} mem:${vtoy_vhd_buf_addr}:size:${vtoy_vhd_buf_size}
+            boot
+            ventoy_gui_console
+        fi
+    else
+        echo "Please put the right ventoy_vhdboot.img file to the 1st partition"
+        ventoy_pause
+    fi
+}
+
 function vhd_common_menuentry {
 
     if [ "$VTOY_VHD_NO_WARNING" != "1" ]; then
@@ -1252,25 +1364,7 @@ function vhd_common_menuentry {
         return
     fi
     
-    vt_patch_vhdboot "$vt_chosen_path"
-    
-    ventoy_debug_pause    
-    
-    if [ -n "$vtoy_vhd_buf_addr" ]; then
-        if [ "$grub_platform" = "pc" ]; then
-            linux16   $vtoy_path/memdisk iso raw    
-            initrd16  mem:${vtoy_vhd_buf_addr}:size:${vtoy_vhd_buf_size}            
-            boot
-        else
-            ventoy_cli_console
-            chainloader ${vtoy_path}/ventoy_${VTOY_EFI_ARCH}.efi memdisk env_param=${env_param} isoefi=${LoadIsoEfiDriver} ${vtdebug_flag} mem:${vtoy_vhd_buf_addr}:size:${vtoy_vhd_buf_size}
-            boot
-            ventoy_gui_console
-        fi        
-    else
-        echo "Please put the right ventoy_vhdboot.img file to the 1st partition"
-        ventoy_pause
-    fi
+    vhdboot_common_func "${vt_chosen_path}"
 }
 
 function vhd_unsupport_menuentry {
@@ -1702,7 +1796,7 @@ function img_unsupport_menuentry {
 #############################################################
 #############################################################
 
-set VENTOY_VERSION="1.0.42"
+set VENTOY_VERSION="1.0.45"
 
 #ACPI not compatible with Window7/8, so disable by default
 set VTOY_PARAM_NO_ACPI=1
@@ -1715,6 +1809,7 @@ set VTOY_DEFAULT_MENU_MODE=0
 set VTOY_MEM_DISK_STR="[Memdisk]"
 set VTOY_ISO_RAW_STR="Compatible Mode"
 set VTOY_GRUB2_MODE_STR="GRUB2 Mode"
+set VTOY_WIMBOOT_MODE_STR="WIMBOOT Mode"
 set VTOY_ISO_UEFI_DRV_STR="UEFI FS"
 
 set VTOY_F2_CMD="ventoy_power"
@@ -1837,7 +1932,7 @@ elif [ "$vtoy_display_mode" = "serial_console" ]; then
     terminal_output  serial console    
 else    
     if [ -n "$vtoy_theme" ]; then
-        set theme=$vtoy_theme
+        vt_set_theme
     else
         set theme=$prefix/themes/ventoy/theme.txt
     fi

INSTALL/grub/i386-efi/moddep.lst

@@ -26,7 +26,7 @@ sfs: fshelp
 reiserfs: fshelp
 part_sunpc:
 zstd:
-gfxmenu: video_colors trig bitmap_scale gfxterm font normal bitmap video
+gfxmenu: trig video_colors bitmap_scale gfxterm font normal bitmap video
 backtrace:
 jfs:
 help: extcmd normal
@@ -82,7 +82,7 @@ gfxterm_background: video_colors bitmap_scale gfxterm extcmd video bitmap
 search_fs_uuid:
 gcry_dsa: pgp mpi
 keystatus: extcmd
-linux: verifiers video boot relocator mmap
+linux: ventoy verifiers video boot relocator mmap
 geli: cryptodisk crypto gcry_sha512 pbkdf2 gcry_sha256
 cmdline_cat_test: font functional_test normal procfs video_fb
 rdmsr: extcmd
@@ -120,7 +120,7 @@ ehci: cs5536 usb boot
 crypto:
 part_bsd: part_msdos
 cs5536:
-ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd normal video gcry_sha1 iso9660
+ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd datetime div normal video gcry_sha1 iso9660
 gcry_sha512: crypto
 password: crypto normal
 fshelp:

INSTALL/grub/i386-pc/moddep.lst

@@ -26,7 +26,7 @@ sfs: fshelp
 reiserfs: fshelp
 part_sunpc:
 zstd:
-gfxmenu: video_colors trig bitmap_scale gfxterm font normal bitmap video
+gfxmenu: trig video_colors bitmap_scale gfxterm font normal bitmap video
 backtrace:
 jfs:
 help: extcmd normal
@@ -82,7 +82,7 @@ gfxterm_background: video_colors bitmap_scale gfxterm extcmd video bitmap
 search_fs_uuid:
 gcry_dsa: pgp mpi
 keystatus: extcmd
-linux: verifiers normal vbe video boot relocator mmap
+linux: ventoy verifiers normal vbe video boot relocator mmap
 geli: cryptodisk crypto gcry_sha512 pbkdf2 gcry_sha256
 cmdline_cat_test: font functional_test normal procfs video_fb
 rdmsr: extcmd
@@ -123,7 +123,7 @@ crypto:
 part_bsd: part_msdos
 cs5536: pci
 biosdisk:
-ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd normal video gcry_sha1 iso9660 acpi
+ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf datetime div extcmd normal video gcry_sha1 iso9660 acpi
 lsapm:
 gcry_sha512: crypto
 password: crypto normal

INSTALL/grub/themes/ventoy/theme.txt

@@ -78,6 +78,14 @@ terminal-box: "terminal_box_*.png"
     + label {text = "@VTOY_GRUB2_MODE@" color = "red" align = "left"} 
 }
 
++ hbox{ 
+    left = 30%+200
+    top = 95%-25
+    width = 10%
+    height = 25
+    + label {text = "@VTOY_WIMBOOT_MODE@" color = "red" align = "left"} 
+}
+
 + hbox{ 
     left = 90%
     top = 55 

INSTALL/grub/x86_64-efi/moddep.lst

@@ -26,7 +26,7 @@ sfs: fshelp
 reiserfs: fshelp
 part_sunpc:
 zstd:
-gfxmenu: video_colors trig bitmap_scale gfxterm font normal bitmap video
+gfxmenu: trig video_colors bitmap_scale gfxterm font normal bitmap video
 backtrace:
 jfs:
 help: extcmd normal
@@ -81,7 +81,7 @@ gfxterm_background: video_colors bitmap_scale gfxterm extcmd video bitmap
 search_fs_uuid:
 gcry_dsa: pgp mpi
 keystatus: extcmd
-linux: verifiers video boot relocator mmap
+linux: ventoy verifiers video boot relocator mmap
 geli: cryptodisk crypto gcry_sha512 pbkdf2 gcry_sha256
 cmdline_cat_test: font functional_test normal procfs video_fb
 rdmsr: extcmd
@@ -120,7 +120,7 @@ ehci: cs5536 usb boot
 crypto:
 part_bsd: part_msdos
 cs5536:
-ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd normal video gcry_sha1 iso9660
+ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd datetime div normal video gcry_sha1 iso9660
 gcry_sha512: crypto
 password: crypto normal
 fshelp:

INSTALL/plugin/ventoy/theme/theme.txt

@@ -70,6 +70,22 @@ terminal-box: "terminal_box_*.png"
 }
 
 
++ hbox{ 
+    left = 30%+200
+    top = 95%-50
+    width = 10%
+    height = 25
+    + label {text = "@VTOY_GRUB2_MODE@" color = "red" align = "left"} 
+}
+
++ hbox{ 
+    left = 30%+200
+    top = 95%-25
+    width = 10%
+    height = 25
+    + label {text = "@VTOY_WIMBOOT_MODE@" color = "red" align = "left"} 
+}
+
 + hbox{ 
     left = 90%
     top = 55 

INSTALL/tool/VentoyWorker.sh

@@ -365,11 +365,15 @@ else
     
     oldver=$(get_disk_ventoy_version $DISK)
     if [ $? -ne 0 ]; then
-        vtwarn "$DISK does not contain Ventoy or data corrupted"
-        echo ""
-        vtwarn "Please use -i option if you want to install ventoy to $DISK"
-        echo ""
-        exit 1
+        if is_disk_contains_ventoy $DISK; then
+            oldver="Unknown"
+        else
+            vtwarn "$DISK does not contain Ventoy or data corrupted"
+            echo ""
+            vtwarn "Please use -i option if you want to install ventoy to $DISK"
+            echo ""
+            exit 1
+        fi
     fi
 
     #reserve secure boot option

INSTALL/ventoy_pack.sh

@@ -106,11 +106,13 @@ cp $OPT VentoyWebDeepin.sh $tmpdir/
 cp $OPT README $tmpdir/
 cp $OPT plugin $tmpdir/
 cp $OPT CreatePersistentImg.sh $tmpdir/
+cp $OPT ExtendPersistentImg.sh $tmpdir/
 dos2unix -q $tmpdir/Ventoy2Disk.sh
 dos2unix -q $tmpdir/VentoyWeb.sh
 dos2unix -q $tmpdir/VentoyWebDeepin.sh
 #dos2unix -q $tmpdir/Ventoy.desktop
 dos2unix -q $tmpdir/CreatePersistentImg.sh
+dos2unix -q $tmpdir/ExtendPersistentImg.sh
 
 cp $OPT ../LinuxGUI/WebUI $tmpdir/
 sed 's/.*SCRIPT_DEL_THIS \(.*\)/\1/g' -i $tmpdir/WebUI/index.html
@@ -151,7 +153,7 @@ tar -czvf ventoy-${curver}-linux.tar.gz $tmpdir
 
 rm -f ventoy-${curver}-windows.zip
 cp $OPT Ventoy2Disk*.exe $tmpdir/
-cp $OPT $LANG_DIR/languages.ini $tmpdir/ventoy/
+cp $OPT $LANG_DIR/languages.json $tmpdir/ventoy/
 rm -rf $tmpdir/tool
 rm -f $tmpdir/*.sh
 rm -rf $tmpdir/WebUI

LANGUAGES/README

@@ -0,0 +1,17 @@
+
+File encoding: UTF-8
+
+language name must in the format: "Language-XXX (YYY)"
+    1. Language- fixed 9 characters
+    2. XXX: name in English
+    3. a space (ASCII: 0x20)
+    4. a left brace (ASCII: 0x28)
+    5. YYY: name in the specified language
+    6. a right brace (ASCII: 0x29)
+
+string translation:
+      all the String Define
+      #@ will be replaced with \r\n
+
+All the languages will be sorted by the name
+

LANGUAGES/check.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+VTOY_PATH=$1
+
+if [ ! -f $VTOY_PATH/LANGUAGES/languages.json ]; then
+    exit 1
+fi
+
+gcc -DFOR_VTOY_JSON_CHECK $VTOY_PATH/Ventoy2Disk/Ventoy2Disk/VentoyJson.c -I $VTOY_PATH/Ventoy2Disk/Ventoy2Disk/ -o checkjson
+
+./checkjson $VTOY_PATH/LANGUAGES/languages.json
+ret=$?
+
+rm -f ./checkjson
+[ $ret -eq 0 ]
+
+

License/license-wimboot.txt

@@ -1,5 +1,4 @@
 wimboot follows GPLv2+ license (see gpl-2.0.txt)
 
-Ventoy use the lzx decompress file from wimboot. These code follow the same license as wimboot.
-
+Ventoy modified the code and follow the same license as wimboot.
 

LinuxGUI/Ventoy2Disk/Core/ventoy_disk.c

@@ -514,6 +514,8 @@ int ventoy_get_vtoy_data(ventoy_disk *info, int *ppartstyle)
     vdebug("ventoy partition layout check OK: [%llu %llu] [%llu %llu]\n", 
                part1_start_sector, part1_sector_count, part2_start_sector, part2_sector_count);
 
+    vtoy->ventoy_valid = 1;
+
     vdebug("now check secure boot for %s ...\n", info->disk_path);
 
     g_fatlib_media_fd = fd;
@@ -526,7 +528,6 @@ int ventoy_get_vtoy_data(ventoy_disk *info, int *ppartstyle)
         if (ret == 0 && vtoy->ventoy_ver[0])
         {
             vtoy->secure_boot_flag = fatlib_is_secure_boot_enable();            
-            vtoy->ventoy_valid = 1;
         }
         else
         {
@@ -542,6 +543,11 @@ int ventoy_get_vtoy_data(ventoy_disk *info, int *ppartstyle)
     g_fatlib_media_fd = -1;
     g_fatlib_media_offset = 0;
 
+    if (vtoy->ventoy_ver[0] == 0)
+    {
+        vtoy->ventoy_ver[0] = '?';
+    }
+
     if (0 == vtoy->ventoy_valid)
     {
         goto end;

LinuxGUI/language.sh

@@ -1,37 +1,19 @@
 #!/bin/bash
 
-echo "generating languages.js ..."
+VTOY_PATH=$PWD/../
 
-iconv -f utf-16 -t utf-8 ../LANGUAGES/languages.ini  | egrep -v '=STR|^;' | egrep  'Language-|STR_' > languages.js
+echo "checking languages.json ..."
+sh $VTOY_PATH/LANGUAGES/check.sh $VTOY_PATH || exit 1
+
+echo "generating languages.json ..."
+
+echo "var vtoy_language_data = " > languages.js
+cat $VTOY_PATH/LANGUAGES/languages.json  >> languages.js
+echo ";" >> languages.js
 
 dos2unix languages.js
 
-sed 's/\(STR_.*\)=/"\1":/g' -i languages.js
-
-sed "s/: *'/:\"/g" -i languages.js
-
-sed "s/'\s*$/\",/g" -i languages.js
-
-sed 's/\[Language-\(.*\)\].*/"STR_XXX":""},{"name":"\1",/g' -i languages.js
-
-sed "1s/.*\},/var vtoy_language_data = \[/" -i languages.js
-
-sed 's/\("STR_WEB_COMMUNICATION_ERR"[^,]*\)/\1,/g' -i languages.js
-sed 's/,,/,/g' -i languages.js
-
-CNT=$(grep -v -c ',$' languages.js)
-
-if [ $CNT -gt 0 ]; then
-    echo "====== FAILED ========="
-    grep -v -n ',$' languages.js
-    exit 1
-fi
-
-
-echo '"STR_XXX":""}' >> languages.js
-echo '];' >> languages.js
-
 rm -f WebUI/static/js/languages.js
 mv languages.js WebUI/static/js/
 
-echo "====== SUCCESS =========="
+echo "====== SUCCESS =========="

Ventoy2Disk/Ventoy2Disk/Language.h

@@ -101,13 +101,19 @@ typedef enum OPT_SUBMENU
 #define VTOY_MENU_LANGUAGE_BEGIN  0xB000
 
 
-#define VENTOY_LANGUAGE_INI  TEXT(".\\ventoy\\languages.ini")
+#define VENTOY_LANGUAGE_INI     TEXT(".\\ventoy\\languages.ini")
+#define VENTOY_LANGUAGE_JSON    TEXT(".\\ventoy\\languages.json")
+#define VENTOY_LANGUAGE_INI_A   ".\\ventoy\\languages.ini"
+#define VENTOY_LANGUAGE_JSON_A  ".\\ventoy\\languages.json"
+
 #define VENTOY_CFG_INI     TEXT(".\\Ventoy2Disk.ini")
 #define VENTOY_CFG_INI_A   ".\\Ventoy2Disk.ini"
 #define VENTOY_MAX_LANGUAGE	 200
 
 #define GET_INI_STRING(Section, Key, Buf) GetPrivateProfileString(Section, Key, TEXT("#"), Buf, sizeof(Buf), VENTOY_LANGUAGE_INI)
 
+
+
 typedef struct VENTOY_LANGUAGE
 {
 	WCHAR Name[128];

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.c

@@ -283,6 +283,12 @@ static int FilterPhysicalDrive(PHY_DRIVE_INFO *pDriveList, DWORD DriveCount)
             CurDrive->PartStyle = (MBR.PartTbl[0].FsFlag == 0xEE) ? 1 : 0;
             GetVentoyVerInPhyDrive(CurDrive, Part2StartSector, CurDrive->VentoyVersion, sizeof(CurDrive->VentoyVersion), &(CurDrive->SecureBootSupport));
             Log("PhyDrive %d is Ventoy Disk ver:%s SecureBoot:%u", CurDrive->PhyDrive, CurDrive->VentoyVersion, CurDrive->SecureBootSupport);
+
+            if (CurDrive->VentoyVersion[0] == 0)
+            {
+                CurDrive->VentoyVersion[0] = '?';
+                Log("Unknown Ventoy Version");
+            }
         }
     }
 

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.h

@@ -148,7 +148,7 @@ typedef struct PHY_DRIVE_INFO
     STORAGE_BUS_TYPE BusType;
 
     CHAR DriveLetters[64];
-
+   
     CHAR VentoyVersion[32];
 
     BOOL SecureBootSupport;

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj

@@ -110,6 +110,7 @@
     <ClCompile Include="process.c" />
     <ClCompile Include="Utility.c" />
     <ClCompile Include="Ventoy2Disk.c" />
+    <ClCompile Include="VentoyJson.c" />
     <ClCompile Include="WinDialog.c" />
     <ClCompile Include="xz-embedded-20130513\linux\lib\decompress_unxz.c" />
   </ItemGroup>
@@ -133,6 +134,7 @@
     <ClInclude Include="process.h" />
     <ClInclude Include="resource.h" />
     <ClInclude Include="Ventoy2Disk.h" />
+    <ClInclude Include="VentoyJson.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Ventoy2Disk.rc" />

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj.filters

@@ -78,6 +78,9 @@
     <ClCompile Include="crc32.c">
       <Filter>源文件</Filter>
     </ClCompile>
+    <ClCompile Include="VentoyJson.c">
+      <Filter>源文件</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Ventoy2Disk.h">
@@ -137,6 +140,9 @@
     <ClInclude Include="process.h">
       <Filter>头文件</Filter>
     </ClInclude>
+    <ClInclude Include="VentoyJson.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Ventoy2Disk.rc">

Ventoy2Disk/Ventoy2Disk/VentoyJson.c

@@ -0,0 +1,771 @@
+/******************************************************************************
+ * VentoyJson.c
+ *
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef FOR_VTOY_JSON_CHECK
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#else
+#include <Windows.h>
+#include "Ventoy2Disk.h"
+#endif
+
+#include "VentoyJson.h"
+
+static void vtoy_json_free(VTOY_JSON *pstJsonHead)
+{
+    VTOY_JSON *pstNext = NULL;
+
+    while (NULL != pstJsonHead)
+    {
+        pstNext = pstJsonHead->pstNext;
+        if ((pstJsonHead->enDataType < JSON_TYPE_BUTT) && (NULL != pstJsonHead->pstChild))
+        {
+            vtoy_json_free(pstJsonHead->pstChild);
+        }
+
+        free(pstJsonHead);
+        pstJsonHead = pstNext;
+    }
+
+    return;
+}
+
+static char *vtoy_json_skip(const char *pcData)
+{
+    while ((NULL != pcData) && ('\0' != *pcData) && (*pcData <= 32))
+    {
+        pcData++;
+    }
+
+    return (char *)pcData;
+}
+
+VTOY_JSON *vtoy_json_find_item
+(
+    VTOY_JSON *pstJson,
+    JSON_TYPE  enDataType,
+    const char *szKey
+)
+{
+    while (NULL != pstJson)
+    {
+        if ((enDataType == pstJson->enDataType) && 
+            (0 == strcmp(szKey, pstJson->pcName)))
+        {
+            return pstJson;
+        }
+        pstJson = pstJson->pstNext;
+    }
+    
+    return NULL;
+}
+
+static int vtoy_json_parse_number
+(
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    unsigned long Value;
+
+    Value = strtoul(pcData, (char **)ppcEnd, 10);
+    if (*ppcEnd == pcData)
+    {
+        Log("Failed to parse json number %s.", pcData);
+        return JSON_FAILED;
+    }
+
+    pstJson->enDataType = JSON_TYPE_NUMBER;
+    pstJson->unData.lValue = Value;
+    
+    return JSON_SUCCESS;
+}
+
+static int vtoy_json_parse_string
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    UINT32 uiLen = 0;
+    const char *pcPos = NULL;
+    const char *pcTmp = pcData + 1;
+    
+    *ppcEnd = pcData;
+
+    if ('\"' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcPos = strchr(pcTmp, '\"');
+    if ((NULL == pcPos) || (pcPos < pcTmp))
+    {
+        Log("Invalid string %s.", pcData);
+        return JSON_FAILED;
+    }
+
+    *ppcEnd = pcPos + 1;
+    uiLen = (UINT32)(unsigned long)(pcPos - pcTmp);    
+    
+    pstJson->enDataType = JSON_TYPE_STRING;
+    pstJson->unData.pcStrVal = pcNewStart + (pcTmp - pcRawStart);
+    pstJson->unData.pcStrVal[uiLen] = '\0';
+    
+    return JSON_SUCCESS;
+}
+
+static int vtoy_json_parse_array
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    int Ret = JSON_SUCCESS;
+    VTOY_JSON *pstJsonChild = NULL;
+    VTOY_JSON *pstJsonItem = NULL;
+    const char *pcTmp = pcData + 1;
+
+    *ppcEnd = pcData;
+    pstJson->enDataType = JSON_TYPE_ARRAY;
+
+    if ('[' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(pcTmp);
+
+    if (']' == *pcTmp)
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+
+    JSON_NEW_ITEM(pstJson->pstChild, JSON_FAILED);
+
+    Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJson->pstChild, pcTmp, ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pstJsonChild = pstJson->pstChild;
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    while ((NULL != pcTmp) && (',' == *pcTmp))
+    {
+        JSON_NEW_ITEM(pstJsonItem, JSON_FAILED);
+        pstJsonChild->pstNext = pstJsonItem;
+        pstJsonItem->pstPrev = pstJsonChild;
+        pstJsonChild = pstJsonItem;
+
+        Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+        pcTmp = vtoy_json_skip(*ppcEnd);
+    }
+
+    if ((NULL != pcTmp) && (']' == *pcTmp))
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+    else
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+}
+
+static int vtoy_json_parse_object
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    int Ret = JSON_SUCCESS;
+    VTOY_JSON *pstJsonChild = NULL;
+    VTOY_JSON *pstJsonItem = NULL;
+    const char *pcTmp = pcData + 1;
+
+    *ppcEnd = pcData;
+    pstJson->enDataType = JSON_TYPE_OBJECT;
+
+    if ('{' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(pcTmp);
+    if ('}' == *pcTmp)
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+
+    JSON_NEW_ITEM(pstJson->pstChild, JSON_FAILED);
+
+    Ret = vtoy_json_parse_string(pcNewStart, pcRawStart, pstJson->pstChild, pcTmp, ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pstJsonChild = pstJson->pstChild;
+    pstJsonChild->pcName = pstJsonChild->unData.pcStrVal;
+    pstJsonChild->unData.pcStrVal = NULL;
+
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    if ((NULL == pcTmp) || (':' != *pcTmp))
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+
+    Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    while ((NULL != pcTmp) && (',' == *pcTmp))
+    {
+        JSON_NEW_ITEM(pstJsonItem, JSON_FAILED);
+        pstJsonChild->pstNext = pstJsonItem;
+        pstJsonItem->pstPrev = pstJsonChild;
+        pstJsonChild = pstJsonItem;
+
+        Ret = vtoy_json_parse_string(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+
+        pcTmp = vtoy_json_skip(*ppcEnd);
+        pstJsonChild->pcName = pstJsonChild->unData.pcStrVal;
+        pstJsonChild->unData.pcStrVal = NULL;
+        if ((NULL == pcTmp) || (':' != *pcTmp))
+        {
+            *ppcEnd = pcTmp;
+            return JSON_FAILED;
+        }
+
+        Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+
+        pcTmp = vtoy_json_skip(*ppcEnd);
+    }
+
+    if ((NULL != pcTmp) && ('}' == *pcTmp))
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+    else
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+}
+
+int vtoy_json_parse_value
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    pcData = vtoy_json_skip(pcData);
+    
+    switch (*pcData)
+    {
+        case 'n':
+        {
+            if (0 == strncmp(pcData, "null", 4))
+            {
+                pstJson->enDataType = JSON_TYPE_NULL;
+                *ppcEnd = pcData + 4;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case 'f':
+        {
+            if (0 == strncmp(pcData, "false", 5))
+            {
+                pstJson->enDataType = JSON_TYPE_BOOL;
+                pstJson->unData.lValue = 0;
+                *ppcEnd = pcData + 5;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case 't':
+        {
+            if (0 == strncmp(pcData, "true", 4))
+            {
+                pstJson->enDataType = JSON_TYPE_BOOL;
+                pstJson->unData.lValue = 1;
+                *ppcEnd = pcData + 4;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case '\"':
+        {
+            return vtoy_json_parse_string(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '[':
+        {
+            return vtoy_json_parse_array(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '{':
+        {
+            return vtoy_json_parse_object(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '-':
+        {
+            return vtoy_json_parse_number(pstJson, pcData, ppcEnd);
+        }
+        default :
+        {
+            if (*pcData >= '0' && *pcData <= '9')
+            {
+                return vtoy_json_parse_number(pstJson, pcData, ppcEnd);
+            }
+        }
+    }
+
+    *ppcEnd = pcData;
+    Log("Invalid json data %u.", (UINT8)(*pcData));
+    return JSON_FAILED;
+}
+
+VTOY_JSON * vtoy_json_create(void)
+{
+    VTOY_JSON *pstJson = NULL;
+
+    pstJson = (VTOY_JSON *)malloc(sizeof(VTOY_JSON));
+    if (NULL == pstJson)
+    {
+        return NULL;
+    }
+    memset(pstJson, 0, sizeof(VTOY_JSON));
+    return pstJson;
+}
+
+int vtoy_json_parse(VTOY_JSON *pstJson, const char *szJsonData)
+{
+    UINT32 uiMemSize = 0;
+    int Ret = JSON_SUCCESS;
+    char *pcNewBuf = NULL;
+    const char *pcEnd = NULL;
+
+    uiMemSize = strlen(szJsonData) + 1;
+    pcNewBuf = (char *)malloc(uiMemSize);
+    if (NULL == pcNewBuf)
+    {
+        Log("Failed to alloc new buf.");
+        return JSON_FAILED;
+    }
+    memcpy(pcNewBuf, szJsonData, uiMemSize);
+    pcNewBuf[uiMemSize - 1] = 0;
+
+    Ret = vtoy_json_parse_value(pcNewBuf, (char *)szJsonData, pstJson, szJsonData, &pcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse json data start=%p, end=%p", szJsonData, pcEnd);
+        return JSON_FAILED;
+    }
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_parse
+(
+    const VTOY_JSON    *pstJson,
+    UINT32       uiParseNum,
+    JSON_PARSE         *pstJsonParse
+)
+{   
+    UINT32 i = 0;
+    const VTOY_JSON *pstJsonCur = NULL;
+    JSON_PARSE *pstCurParse = NULL;
+
+    for (pstJsonCur = pstJson; NULL != pstJsonCur; pstJsonCur = pstJsonCur->pstNext)
+    {
+        if ((JSON_TYPE_OBJECT == pstJsonCur->enDataType) ||
+            (JSON_TYPE_ARRAY == pstJsonCur->enDataType))
+        {
+            continue;
+        }
+
+        for (i = 0, pstCurParse = NULL; i < uiParseNum; i++)
+        {
+            if (0 == strcmp(pstJsonParse[i].pcKey, pstJsonCur->pcName))
+            {   
+                pstCurParse = pstJsonParse + i;
+                break;
+            }
+        }
+
+        if (NULL == pstCurParse)
+        {
+            continue;
+        }
+    
+        switch (pstJsonCur->enDataType)
+        {
+            case JSON_TYPE_NUMBER:
+            {
+                if (sizeof(UINT32) == pstCurParse->uiBufSize)
+                {
+                    *(UINT32 *)(pstCurParse->pDataBuf) = (UINT32)pstJsonCur->unData.lValue;
+                }
+                else if (sizeof(UINT16) == pstCurParse->uiBufSize)
+                {
+                    *(UINT16 *)(pstCurParse->pDataBuf) = (UINT16)pstJsonCur->unData.lValue;
+                }
+                else if (sizeof(UINT8) == pstCurParse->uiBufSize)
+                {
+                    *(UINT8 *)(pstCurParse->pDataBuf) = (UINT8)pstJsonCur->unData.lValue;
+                }
+                else if ((pstCurParse->uiBufSize > sizeof(UINT64)))
+                {
+                    sprintf_s((char *)pstCurParse->pDataBuf, pstCurParse->uiBufSize, "%llu",
+                        (unsigned long long)(pstJsonCur->unData.lValue));
+                }
+                else
+                {
+                    Log("Invalid number data buf size %u.", pstCurParse->uiBufSize);
+                }
+                break;
+            }
+            case JSON_TYPE_STRING:
+            {
+                strcpy_s((char *)pstCurParse->pDataBuf, pstCurParse->uiBufSize, pstJsonCur->unData.pcStrVal);
+                break;
+            }
+            case JSON_TYPE_BOOL:
+            {
+                *(UINT8 *)(pstCurParse->pDataBuf) = (pstJsonCur->unData.lValue) > 0 ? 1 : 0;
+                break;
+            }
+            default :
+            {
+                break;
+            }
+        }
+    }
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_array
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_ARRAY, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *ppstArrayItem = pstJsonItem;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_array_ex
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_ARRAY, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+    
+    *ppstArrayItem = pstJsonItem->pstChild;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_object
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstObjectItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_OBJECT, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *ppstObjectItem = pstJsonItem;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_int
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    int *piValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *piValue = (int)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_uint
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT32 *puiValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *puiValue = (UINT32)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_uint64
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT64 *pui64Value
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *pui64Value = (UINT64)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_bool
+(
+    VTOY_JSON *pstJson,
+    const char *szKey, 
+    UINT8 *pbValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_BOOL, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *pbValue = pstJsonItem->unData.lValue > 0 ? 1 : 0;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_string
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     UINT32  uiBufLen,
+     char *pcBuf
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_STRING, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    strcpy_s(pcBuf, uiBufLen, pstJsonItem->unData.pcStrVal);
+
+    return JSON_SUCCESS;
+}
+
+const char * vtoy_json_get_string_ex(VTOY_JSON *pstJson,  const char *szKey)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+
+    if ((NULL == pstJson) || (NULL == szKey))
+    {
+        return NULL;
+    }
+
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_STRING, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return NULL;
+    }
+
+    return pstJsonItem->unData.pcStrVal;
+}
+
+int vtoy_json_destroy(VTOY_JSON *pstJson)
+{
+    if (NULL == pstJson)
+    {   
+        return JSON_SUCCESS;
+    }
+
+    if (NULL != pstJson->pstChild)
+    {
+        vtoy_json_free(pstJson->pstChild);
+    }
+
+    if (NULL != pstJson->pstNext)
+    {
+        vtoy_json_free(pstJson->pstNext);
+    }
+
+    free(pstJson);
+    
+    return JSON_SUCCESS;
+}
+
+
+#ifdef FOR_VTOY_JSON_CHECK
+
+int main(int argc, char**argv)
+{
+    int ret = 1;
+    int FileSize;
+    FILE *fp;
+    void *Data = NULL;
+    VTOY_JSON *json = NULL;
+
+    fp = fopen(argv[1], "rb");
+    if (!fp)
+    {
+        Log("Failed to open %s\n", argv[1]);
+        goto out;
+    }
+
+    fseek(fp, 0, SEEK_END);
+    FileSize = (int)ftell(fp);
+    fseek(fp, 0, SEEK_SET);
+
+    Data = malloc(FileSize + 4);
+    if (!Data)
+    {
+        Log("Failed to malloc %d\n", FileSize + 4);
+        goto out;
+    }
+    *((char *)Data + FileSize) = 0;
+
+    fread(Data, 1, FileSize, fp);
+
+    json = vtoy_json_create();
+    if (!json)
+    {
+        Log("Failed vtoy_json_create\n");
+        goto out;
+    }
+
+    if (vtoy_json_parse(json, (char *)Data) != JSON_SUCCESS)
+    {
+        goto out;
+    }
+
+    ret = 0;
+
+out:
+    if (fp) fclose(fp);
+    if (Data) free(Data);
+    if (json) vtoy_json_destroy(json);
+
+    printf("\n");
+    return ret;
+}
+
+#endif

Ventoy2Disk/Ventoy2Disk/VentoyJson.h

@@ -0,0 +1,164 @@
+/******************************************************************************
+ * VentoyJson.h
+ *
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __VENTOY_JSON_H__
+#define __VENTOY_JSON_H__
+
+#ifdef FOR_VTOY_JSON_CHECK
+typedef unsigned char      UINT8;
+typedef unsigned short     UINT16;
+typedef unsigned int       UINT32;
+typedef unsigned long long UINT64;
+
+#define Log printf
+#define strcpy_s(a, b, c) strncpy(a, c, b)
+#define sprintf_s snprintf
+#endif
+
+#define JSON_SUCCESS    0
+#define JSON_FAILED     1
+#define JSON_NOT_FOUND  2
+
+typedef enum _JSON_TYPE
+{
+    JSON_TYPE_NUMBER = 0,
+    JSON_TYPE_STRING,
+    JSON_TYPE_BOOL,
+    JSON_TYPE_ARRAY,
+    JSON_TYPE_OBJECT,
+    JSON_TYPE_NULL,
+    JSON_TYPE_BUTT
+}JSON_TYPE;
+
+
+typedef struct _VTOY_JSON
+{
+    struct _VTOY_JSON *pstPrev;
+    struct _VTOY_JSON *pstNext;
+    struct _VTOY_JSON *pstChild;
+
+    JSON_TYPE enDataType;
+    union 
+    {
+        char  *pcStrVal;
+        int   iNumVal;
+        UINT64 lValue;
+    }unData;
+
+    char *pcName;
+}VTOY_JSON;
+
+typedef struct _JSON_PARSE
+{
+    char *pcKey;
+    void *pDataBuf;
+    UINT32  uiBufSize;
+}JSON_PARSE;
+
+#define JSON_NEW_ITEM(pstJson, ret) \
+{ \
+    (pstJson) = (VTOY_JSON *)malloc(sizeof(VTOY_JSON)); \
+    if (NULL == (pstJson)) \
+    { \
+        Log("Failed to alloc memory for json.\n"); \
+        return (ret); \
+    } \
+    memset((pstJson), 0, sizeof(VTOY_JSON));\
+}
+
+VTOY_JSON *vtoy_json_find_item
+(
+    VTOY_JSON *pstJson,
+    JSON_TYPE  enDataType,
+    const char *szKey
+);
+int vtoy_json_parse_value
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+);
+VTOY_JSON * vtoy_json_create(void);
+int vtoy_json_parse(VTOY_JSON *pstJson, const char *szJsonData);
+
+int vtoy_json_scan_parse
+(
+    const VTOY_JSON    *pstJson,
+    UINT32              uiParseNum,
+    JSON_PARSE         *pstJsonParse
+);
+
+int vtoy_json_scan_array
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+);
+
+int vtoy_json_scan_array_ex
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+);
+int vtoy_json_scan_object
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+    VTOY_JSON **ppstObjectItem
+);
+int vtoy_json_get_int
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    int *piValue
+);
+int vtoy_json_get_uint
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT32     *puiValue
+);
+int vtoy_json_get_uint64
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT64 *pui64Value
+);
+int vtoy_json_get_bool
+(
+    VTOY_JSON *pstJson,
+    const char *szKey, 
+    UINT8 *pbValue
+);
+int vtoy_json_get_string
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     UINT32  uiBufLen,
+     char *pcBuf
+);
+const char * vtoy_json_get_string_ex(VTOY_JSON *pstJson,  const char *szKey);
+int vtoy_json_destroy(VTOY_JSON *pstJson);
+
+#endif /* __VENTOY_JSON_H__ */
+

VtoyTool/vtoydump.c

@@ -464,10 +464,13 @@ static int vtoy_check_device(ventoy_os_param *param, const char *device)
 
 static int vtoy_print_os_param(ventoy_os_param *param, char *diskname)
 {
-    int   cnt = 0;
+    int fd, size;
+    int cnt = 0;
     char *path = param->vtoy_img_path;
     const char *fs;
-
+    char diskpath[256] = {0};
+    char sizebuf[64] = {0};
+    
     cnt = vtoy_find_disk_by_size(param->vtoy_disk_size, diskname);
     debug("find disk by size %llu, cnt=%d...\n", (unsigned long long)param->vtoy_disk_size, cnt);
     if (1 == cnt)
@@ -494,6 +497,37 @@ static int vtoy_print_os_param(ventoy_os_param *param, char *diskname)
 
     if (1 == cnt)
     {
+        if (strstr(diskname, "nvme") || strstr(diskname, "mmc") || strstr(diskname, "nbd"))
+        {
+            snprintf(diskpath, sizeof(diskpath) - 1, "/sys/class/block/%sp2/size", diskname);
+        }
+        else
+        {
+            snprintf(diskpath, sizeof(diskpath) - 1, "/sys/class/block/%s2/size", diskname);
+        }
+
+        if (access(diskpath, F_OK) >= 0)
+        {
+            debug("get part size from sysfs for %s\n", diskpath);
+
+            fd = open(diskpath, O_RDONLY | O_BINARY);
+            if (fd >= 0)
+            {
+                read(fd, sizebuf, sizeof(sizebuf));
+                size = (int)strtoull(sizebuf, NULL, 10);
+                close(fd);
+                if ((size != (64 * 1024)) && (size != (8 * 1024)))
+                {
+                    debug("sizebuf=<%s> size=%d\n", sizebuf, size);
+                    return 1;
+                }
+            }
+        }
+        else
+        {
+            debug("%s not exist \n", diskpath);
+        }
+
         printf("/dev/%s#%s#%s\n", diskname, fs, path);
         return 0;
     }

vtoyjump/vtoyjump/vtoyjump.c

@@ -1105,6 +1105,64 @@ const char * GetFileNameInPath(const char *fullpath)
 	return fullpath;
 }
 
+int VentoyJumpWimboot(INT argc, CHAR **argv, CHAR *LunchFile)
+{
+    int rc = 1;
+    char *buf = NULL;
+    DWORD size = 0;
+    DWORD Pos;
+
+#ifdef VTOY_32
+    g_64bit_system = FALSE;
+#else
+    g_64bit_system = TRUE;
+#endif
+    
+    Log("VentoyJumpWimboot %dbit", g_64bit_system ? 64 : 32);
+
+    sprintf_s(LunchFile, MAX_PATH, "X:\\setup.exe");
+
+    ReadWholeFile2Buf("wimboot.data", &buf, &size);
+    Log("wimboot.data size:%d", size);
+
+    memcpy(&g_os_param, buf, sizeof(ventoy_os_param));
+    memcpy(&g_windows_data, buf + sizeof(ventoy_os_param), sizeof(ventoy_windows_data));
+    memcpy(g_os_param_reserved, g_os_param.vtoy_reserved, sizeof(g_os_param_reserved));
+
+    if (g_os_param_reserved[0] == 1)
+    {
+        Log("break here for debug .....");
+        goto End;
+    }
+
+    // convert / to \\   
+    for (Pos = 0; Pos < sizeof(g_os_param.vtoy_img_path) && g_os_param.vtoy_img_path[Pos]; Pos++)
+    {
+        if (g_os_param.vtoy_img_path[Pos] == '/')
+        {
+            g_os_param.vtoy_img_path[Pos] = '\\';
+        }
+    }
+
+    if (g_os_param_reserved[0] == 2)
+    {
+        Log("skip hook for debug .....");
+        rc = 0;
+        goto End;
+    }
+
+    rc = VentoyHook(&g_os_param);
+
+End:
+
+    if (buf)
+    {
+        free(buf);
+    }
+
+    return rc;
+}
+
 int VentoyJump(INT argc, CHAR **argv, CHAR *LunchFile)
 {
 	int rc = 1;
@@ -1129,6 +1187,7 @@ int VentoyJump(INT argc, CHAR **argv, CHAR *LunchFile)
 	}
 	
 	g_64bit_system = IsPe64(Buffer);
+    Log("VentoyJump %dbit", g_64bit_system ? 64 : 32);
 
 	if (!IsPathExist(TRUE, "ventoy"))
 	{
@@ -1241,7 +1300,15 @@ int main(int argc, char **argv)
     GetStartupInfoA(&Si);
 
     memset(LunchFile, 0, sizeof(LunchFile));
-    rc = VentoyJump(argc, argv, LunchFile);
+
+    if (strstr(argv[0], "vtoyjump.exe"))
+    {
+        rc = VentoyJumpWimboot(argc, argv, LunchFile);
+    }
+    else
+    {
+        rc = VentoyJump(argc, argv, LunchFile);
+    }
 
     if (g_os_param_reserved[0] == 3)
     {
@@ -1250,11 +1317,17 @@ int main(int argc, char **argv)
     }
     else
     {
-        Si.dwFlags |= STARTF_USESHOWWINDOW;
-        Si.wShowWindow = SW_HIDE;
+        if (NULL == strstr(LunchFile, "setup.exe"))
+        {
+            Log("Not setup.exe, hide windows.");
+            Si.dwFlags |= STARTF_USESHOWWINDOW;
+            Si.wShowWindow = SW_HIDE;
+        }
+        
         Log("Ventoy jump %s ...", rc == 0 ? "success" : "failed");
     }
-
+    
+    Log("Now launch <%s> ...", LunchFile);
 	CreateProcessA(NULL, LunchFile, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
 
     while (rc)

vtoyjump/vtoyjump/vtoyjump.vcxproj

@@ -92,7 +92,7 @@
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>FATFS_INC_FORMAT_SUPPORT=0;WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>VTOY_32;FATFS_INC_FORMAT_SUPPORT=0;WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
@@ -108,7 +108,7 @@
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>FATFS_INC_FORMAT_SUPPORT=0;WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>VTOY_64;FATFS_INC_FORMAT_SUPPORT=0;WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
@@ -126,7 +126,7 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>FATFS_INC_FORMAT_SUPPORT=0;WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>VTOY_32;FATFS_INC_FORMAT_SUPPORT=0;WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
@@ -146,7 +146,7 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>FATFS_INC_FORMAT_SUPPORT=0;WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>VTOY_64;FATFS_INC_FORMAT_SUPPORT=0;WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>

wimboot/build.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+VTOY_PATH=$PWD/../
+
+cd wimboot-2.7.3/src
+
+make clean
+make -j 16
+
+rm -f *.xz
+xz wimboot.x86_64
+xz wimboot.i386.efi
+
+rm -f $VTOY_PATH/INSTALL/ventoy/wimboot.x86_64.xz
+rm -f $VTOY_PATH/INSTALL/ventoy/wimboot.i386.efi.xz
+cp -a wimboot.x86_64.xz $VTOY_PATH/INSTALL/ventoy/
+cp -a wimboot.i386.efi.xz $VTOY_PATH/INSTALL/ventoy/
+
+make clean
+cd ../../

wimboot/wimboot-2.7.3/src/.gitignore

@@ -0,0 +1,10 @@
+wimboot
+*.s
+*.o
+*.a
+*.elf
+*.map
+*.unsigned
+*.efi
+*.cab
+efireloc

wimboot/wimboot-2.7.3/src/Makefile

@@ -0,0 +1,187 @@
+VERSION := v2.7.3
+
+OBJECTS := prefix.o startup.o callback.o main.o vsprintf.o string.o peloader.o
+OBJECTS += int13.o vdisk.o cpio.o stdio.o lznt1.o xca.o die.o efi.o efimain.o
+OBJECTS += efiguid.o efifile.o efipath.o efiboot.o efiblock.o cmdline.o
+OBJECTS += wimpatch.o huffman.o lzx.o wim.o wimfile.o pause.o sha1.o cookie.o
+OBJECTS += paging.o memmap.o
+
+OBJECTS_i386 := $(patsubst %.o,%.i386.o,$(OBJECTS))
+OBJECTS_x86_64 := $(patsubst %.o,%.x86_64.o,$(OBJECTS))
+OBJECTS_i386_x86_64 := $(patsubst %.o,%.i386.x86_64.o,$(OBJECTS))
+
+HEADERS := $(wildcard *.h)
+
+HOST_CC		:= $(CC)
+AS		:= $(AS)
+ECHO		:= echo
+OBJCOPY 	:= objcopy
+AR		:= ar
+RANLIB		:= ranlib
+CP		:= cp
+RM		:= rm
+GCAB		:= gcab
+PESIGN		:= pesign
+DIFF		:= diff
+CUT		:= cut
+BINUTILS_DIR	:= /usr
+BFD_DIR		:= $(BINUTILS_DIR)
+ZLIB_DIR	:= /usr
+
+HOST_CFLAGS += -Wall -W -Werror
+
+CFLAGS += -Os -ffreestanding -Wall -W -Werror -nostdinc -I. -fshort-wchar
+CFLAGS += -DVERSION="\"$(VERSION)\""
+
+CFLAGS_i386 += -m32 -march=i386 -malign-double -fno-pic
+CFLAGS_x86_64 += -m64 -mno-red-zone -fpie
+
+# Enable stack protection if available
+#
+SPG_TEST = $(CC) -fstack-protector-strong -mstack-protector-guard=global \
+		 -x c -c /dev/null -o /dev/null >/dev/null 2>&1
+SPG_FLAGS := $(shell $(SPG_TEST) && $(ECHO) '-fstack-protector-strong ' \
+					    '-mstack-protector-guard=global')
+CFLAGS += $(SPG_FLAGS)
+
+# Inhibit unwanted debugging information
+CFI_TEST = $(CC) -fno-dwarf2-cfi-asm -fno-exceptions -fno-unwind-tables \
+		 -fno-asynchronous-unwind-tables -x c -c /dev/null \
+		 -o /dev/null >/dev/null 2>&1
+CFI_FLAGS := $(shell $(CFI_TEST) && \
+	       $(ECHO) '-fno-dwarf2-cfi-asm -fno-exceptions ' \
+		    '-fno-unwind-tables -fno-asynchronous-unwind-tables')
+WORKAROUND_CFLAGS += $(CFI_FLAGS)
+
+# Add -maccumulate-outgoing-args if required by this version of gcc
+MS_ABI_TEST_CODE := extern void __attribute__ (( ms_abi )) ms_abi(); \
+		    void sysv_abi ( void ) { ms_abi(); }
+MS_ABI_TEST = $(ECHO) '$(MS_ABI_TEST_CODE)' | \
+	      $(CC) -m64 -mno-accumulate-outgoing-args -x c -c - -o /dev/null \
+		    >/dev/null 2>&1
+MS_ABI_FLAGS := $(shell $(MS_ABI_TEST) || $(ECHO) '-maccumulate-outgoing-args')
+WORKAROUND_CFLAGS += $(MS_ABI_FLAGS)
+
+# Inhibit warnings from taking address of packed struct members
+WNAPM_TEST = $(CC) -Wno-address-of-packed-member -x c -c /dev/null \
+		   -o /dev/null >/dev/null 2>&1
+WNAPM_FLAGS := $(shell $(WNAPM_TEST) && \
+		 $(ECHO) '-Wno-address-of-packed-member')
+WORKAROUND_CFLAGS += $(WNAPM_FLAGS)
+
+# Inhibit LTO
+LTO_TEST = $(CC) -fno-lto -x c -c /dev/null -o /dev/null >/dev/null 2>&1
+LTO_FLAGS := $(shell $(LTO_TEST) && $(ECHO) '-fno-lto')
+WORKAROUND_CFLAGS += $(LTO_FLAGS)
+
+CFLAGS += $(WORKAROUND_CFLAGS)
+CFLAGS += $(EXTRA_CFLAGS)
+
+ifneq ($(DEBUG),)
+CFLAGS += -DDEBUG=$(DEBUG)
+endif
+
+CFLAGS += -include compiler.h
+
+###############################################################################
+#
+# Final targets
+
+all : wimboot wimboot.i386 wimboot.x86_64 wimboot.cab
+
+wimboot : wimboot.x86_64 Makefile
+	$(CP) $< $@
+	$(CP) $@ ../$@
+
+wimboot.%.elf : prefix.%.o lib.%.a script.lds Makefile
+	$(LD) -m elf_$* -T script.lds -o $@ -q -Map wimboot.$*.map \
+		prefix.$*.o lib.$*.a
+
+wimboot.%.unsigned : wimboot.%.elf efireloc Makefile
+	$(OBJCOPY) -Obinary $< $@
+	./efireloc $< $@
+
+wimboot.%.unsigned.hash : wimboot.%.unsigned Makefile
+	$(PESIGN) -h -i $< | $(CUT) -d" " -f2- > $@
+
+wimboot.%.efi : wimboot.%.unsigned Makefile
+	$(CP) $< $@
+
+wimboot.%.efi.hash : wimboot.%.efi Makefile
+	$(PESIGN) -h -i $< | $(CUT) -d" " -f2- > $@
+
+wimboot.% : wimboot.%.efi wimboot.%.efi.hash wimboot.%.unsigned.hash Makefile
+	$(DIFF) wimboot.$*.efi.hash wimboot.$*.unsigned.hash
+	$(CP) $< $@
+
+wimboot.cab : wimboot.i386.efi wimboot.x86_64.efi Makefile
+	$(GCAB) -n -c $@ wimboot.i386.efi wimboot.x86_64.efi
+
+###############################################################################
+#
+# i386 objects
+
+%.i386.s : %.S $(HEADERS) Makefile
+	$(CC) $(CFLAGS) $(CFLAGS_i386) -DASSEMBLY -Ui386 -E $< -o $@
+
+%.i386.s : %.c $(HEADERS) Makefile
+	$(CC) $(CFLAGS) $(CFLAGS_i386) -S $< -o $@
+
+%.i386.o : %.i386.s i386.i Makefile
+	$(AS) --32 i386.i $< -o $@
+
+lib.i386.a : $(OBJECTS_i386) Makefile
+	$(RM) -f $@
+	$(AR) r $@ $(OBJECTS_i386)
+	$(RANLIB) $@
+
+###############################################################################
+#
+# i386 objects to be linked into an x86_64 binary
+
+%.i386.x86_64.raw.o : %.i386.s i386.i Makefile
+	$(AS) --64 i386.i $< -o $@
+
+%.i386.x86_64.o : %.i386.x86_64.raw.o Makefile
+	$(OBJCOPY) --prefix-symbols=__i386_ $< $@
+
+###############################################################################
+#
+# x86_64 objects
+
+%.x86_64.s : %.S $(HEADERS) Makefile
+	$(CC) $(CFLAGS) $(CFLAGS_x86_64) -DASSEMBLY -Ui386 -E $< -o $@
+
+%.x86_64.s : %.c $(HEADERS) Makefile
+	$(CC) $(CFLAGS) $(CFLAGS_x86_64) -S $< -o $@
+
+%.x86_64.o : %.x86_64.s x86_64.i Makefile
+	$(AS) --64 x86_64.i $< -o $@
+
+lib.x86_64.a : $(OBJECTS_x86_64) $(OBJECTS_i386_x86_64) Makefile
+	$(RM) -f $@
+	$(AR) r $@ $(OBJECTS_x86_64) $(OBJECTS_i386_x86_64)
+	$(RANLIB) $@
+
+###############################################################################
+#
+# EFI relocator
+
+EFIRELOC_CFLAGS := -I$(BINUTILS_DIR)/include -I$(BFD_DIR)/include \
+		   -I$(ZLIB_DIR)/include -idirafter .
+EFIRELOC_LDFLAGS := -L$(BINUTILS_DIR)/lib -L$(BFD_DIR)/lib -L$(ZLIB_DIR)/lib \
+		    -lbfd -ldl -liberty -lz -Wl,--no-warn-search-mismatch
+
+efireloc : efireloc.c Makefile
+	$(CC) $(HOST_CFLAGS) $(EFIRELOC_CFLAGS) $< $(EFIRELOC_LDFLAGS) -o $@
+
+###############################################################################
+#
+# Cleanup
+
+clean :
+	$(RM) -f *.s *.o *.a *.elf *.map
+	$(RM) -f efireloc
+	$(RM) -f wimboot wimboot.i386 wimboot.x86_64 ../wimboot
+	$(RM) -f wimboot.i386.unsigned wimboot.x86_64.unsigned
+	$(RM) -f wimboot.i386.efi wimboot.x86_64.efi wimboot.cab

wimboot/wimboot-2.7.3/src/assert.h

@@ -0,0 +1,39 @@
+#ifndef _ASSERT_H
+#define _ASSERT_H
+
+/*
+ * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * Assertions
+ *
+ */
+
+#include "wimboot.h"
+
+#define assert(x) do {						\
+	if ( DEBUG && ! (x) ) {					\
+		die ( "Assertion failed at %s line %d: %s\n",	\
+		      __FILE__, __LINE__, #x );			\
+	}							\
+	} while ( 0 )
+
+#endif /* _ASSERT_H */

wimboot/wimboot-2.7.3/src/bootapp.h

@@ -0,0 +1,318 @@
+#ifndef _BOOTAPP_H
+#define _BOOTAPP_H
+
+/*
+ * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * Boot application data structures
+ *
+ */
+
+#include <stdint.h>
+
+/** A segment:offset address */
+struct segoff {
+	/** Offset */
+	uint16_t offset;
+	/** Segment */
+	uint16_t segment;
+} __attribute__ (( packed ));
+
+/** A GUID */
+struct guid {
+	/** 8 hex digits, big-endian */
+	uint32_t a;
+	/** 2 hex digits, big-endian */
+	uint16_t b;
+	/** 2 hex digits, big-endian */
+	uint16_t c;
+	/** 2 hex digits, big-endian */
+	uint16_t d;
+	/** 12 hex digits, big-endian */
+	uint8_t e[6];
+} __attribute__ (( packed ));
+
+/** Real-mode callback parameters */
+struct bootapp_callback_params {
+	/** Vector */
+	union {
+		/** Interrupt number */
+		uint32_t interrupt;
+		/** Segment:offset address of real-mode function */
+		struct segoff function;
+	} vector;
+	/** %eax value */
+	union {
+		struct {
+			uint8_t al;
+			uint8_t ah;
+		} __attribute__ (( packed ));
+		uint16_t ax;
+		uint32_t eax;
+	};
+	/** %ebx value */
+	union {
+		struct {
+			uint8_t bl;
+			uint8_t bh;
+		} __attribute__ (( packed ));
+		uint16_t bx;
+		uint32_t ebx;
+	};
+	/** %ecx value */
+	union {
+		struct {
+			uint8_t cl;
+			uint8_t ch;
+		} __attribute__ (( packed ));
+		uint16_t cx;
+		uint32_t ecx;
+	};
+	/** %edx value */
+	union {
+		struct {
+			uint8_t dl;
+			uint8_t dh;
+		} __attribute__ (( packed ));
+		uint16_t dx;
+		uint32_t edx;
+	};
+	/** Placeholder (for %esp?) */
+	uint32_t unused_esp;
+	/** Placeholder (for %ebp?) */
+	uint32_t unused_ebp;
+	/** %esi value */
+	union {
+		uint16_t si;
+		uint32_t esi;
+	};
+	/** %edi value */
+	union {
+		uint16_t di;
+		uint32_t edi;
+	};
+	/** Placeholder (for %cs?) */
+	uint32_t unused_cs;
+	/** %ds value */
+	uint32_t ds;
+	/** Placeholder (for %ss?) */
+	uint32_t unused_ss;
+	/** %es value */
+	uint32_t es;
+	/** %fs value */
+	uint32_t fs;
+	/** %gs value */
+	uint32_t gs;
+	/** eflags value */
+	uint32_t eflags;
+} __attribute__ (( packed ));
+
+/** eflags bits */
+enum eflags {
+	CF = ( 1 << 0 ),
+	PF = ( 1 << 2 ),
+	AF = ( 1 << 4 ),
+	ZF = ( 1 << 6 ),
+	SF = ( 1 << 7 ),
+	OF = ( 1 << 11 ),
+};
+
+/** Real-mode callback function table */
+struct bootapp_callback_functions {
+	/**
+	 * Call an arbitrary real-mode interrupt
+	 *
+	 * @v params		Parameters
+	 */
+	void ( * call_interrupt ) ( struct bootapp_callback_params *params );
+	/**
+	 * Call an arbitrary real-mode function
+	 *
+	 * @v params		Parameters
+	 */
+	void ( * call_real ) ( struct bootapp_callback_params *params );
+} __attribute__ (( packed ));
+
+/** Real-mode callbacks */
+struct bootapp_callback {
+	/** Real-mode callback function table */
+	struct bootapp_callback_functions *fns;
+	/** Drive number for INT13 calls */
+	uint32_t drive;
+} __attribute__ (( packed ));
+
+/** Boot application descriptor */
+struct bootapp_descriptor {
+	/** Signature */
+	char signature[8];
+	/** Version */
+	uint32_t version;
+	/** Total length */
+	uint32_t len;
+	/** COFF machine type */
+	uint32_t arch;
+	/** Reserved */
+	uint32_t reserved_0x14;
+	/** Loaded PE image base address */
+	void *pe_base;
+	/** Reserved */
+	uint32_t reserved_0x1c;
+	/** Length of loaded PE image */
+	uint32_t pe_len;
+	/** Offset to memory descriptor */
+	uint32_t memory;
+	/** Offset to boot application entry descriptor */
+	uint32_t entry;
+	/** Offset to ??? */
+	uint32_t xxx;
+	/** Offset to callback descriptor */
+	uint32_t callback;
+	/** Offset to pointless descriptor */
+	uint32_t pointless;
+	/** Reserved */
+	uint32_t reserved_0x38;
+} __attribute__ (( packed ));
+
+/** "BOOT APP" magic signature */
+#define BOOTAPP_SIGNATURE "BOOT APP"
+
+/** Boot application descriptor version */
+#define BOOTAPP_VERSION 2
+
+/** i386 architecture */
+#define BOOTAPP_ARCH_I386 0x014c
+
+/** Memory region descriptor */
+struct bootapp_memory_region {
+	/** Reserved (for struct list_head?) */
+	uint8_t reserved[8];
+	/** Start page address */
+	uint64_t start_page;
+	/** Reserved */
+	uint8_t reserved_0x10[8];
+	/** Number of pages */
+	uint64_t num_pages;
+	/** Reserved */
+	uint8_t reserved_0x20[4];
+	/** Flags */
+	uint32_t flags;
+} __attribute__ (( packed ));
+
+/** Memory descriptor */
+struct bootapp_memory_descriptor {
+	/** Version */
+	uint32_t version;
+	/** Length of descriptor (excluding region descriptors) */
+	uint32_t len;
+	/** Number of regions */
+	uint32_t num_regions;
+	/** Length of each region descriptor */
+	uint32_t region_len;
+	/** Length of reserved area at start of each region descriptor */
+	uint32_t reserved_len;
+} __attribute__ (( packed ));
+
+/** Boot application memory descriptor version */
+#define BOOTAPP_MEMORY_VERSION 1
+
+/** Boot application entry descriptor */
+struct bootapp_entry_descriptor {
+	/** Signature */
+	char signature[8];
+	/** Flags */
+	uint32_t flags;
+	/** GUID */
+	struct guid guid;
+	/** Reserved */
+	uint8_t reserved[16];
+} __attribute__ (( packed ));
+
+/** ??? */
+struct bootapp_entry_wtf1_descriptor {
+	/** Flags */
+	uint32_t flags;
+	/** Length of descriptor */
+	uint32_t len;
+	/** Total length of following descriptors within BTAPENT */
+	uint32_t extra_len;
+	/** Reserved */
+	uint8_t reserved[12];
+} __attribute__ (( packed ));
+
+/** ??? */
+struct bootapp_entry_wtf2_descriptor {
+	/** GUID */
+	struct guid guid;
+} __attribute__ (( packed ));
+
+/** ??? */
+struct bootapp_entry_wtf3_descriptor {
+	/** Flags */
+	uint32_t flags;
+	/** Reserved */
+	uint32_t reserved_0x04;
+	/** Length of descriptor */
+	uint32_t len;
+	/** Reserved */
+	uint32_t reserved_0x0c;
+	/** Boot partition offset (in bytes) */
+	uint32_t boot_partition_offset;
+	/** Reserved */
+	uint8_t reserved_0x14[16];
+	/** MBR signature present? */
+	uint32_t xxx;
+	/** MBR signature */
+	uint32_t mbr_signature;
+	/** Reserved */
+	uint8_t reserved_0x2c[26];
+} __attribute__ (( packed ));
+
+/** "BTAPENT" magic signature */
+#define BOOTAPP_ENTRY_SIGNATURE "BTAPENT\0"
+
+/** Boot application entry flags
+ *
+ * pxeboot, etftboot, and fatboot all use a value of 0x21; I have no
+ * idea what it means.
+ */
+#define BOOTAPP_ENTRY_FLAGS 0x21
+
+/** Boot application callback descriptor */
+struct bootapp_callback_descriptor {
+	/** Real-mode callbacks */
+	struct bootapp_callback *callback;
+	/** Reserved */
+	uint32_t reserved;
+} __attribute__ (( packed ));
+
+/** Boot application pointless descriptor */
+struct bootapp_pointless_descriptor {
+	/** Version */
+	uint32_t version;
+	/** Reserved */
+	uint8_t reserved[24];
+} __attribute__ (( packed ));
+
+/** Boot application pointless descriptor version */
+#define BOOTAPP_POINTLESS_VERSION 1
+
+#endif /* _BOOTAPP_H */

wimboot/wimboot-2.7.3/src/byteswap.h

@@ -0,0 +1,183 @@
+#ifndef _BITS_BYTESWAP_H
+#define _BITS_BYTESWAP_H
+
+/** @file
+ *
+ * Byte-order swapping functions
+ *
+ */
+
+#include <stdint.h>
+
+static inline __attribute__ (( always_inline, const )) uint16_t
+__bswap_variable_16 ( uint16_t x ) {
+	__asm__ ( "xchgb %b0,%h0" : "=Q" ( x ) : "0" ( x ) );
+	return x;
+}
+
+static inline __attribute__ (( always_inline )) void
+__bswap_16s ( uint16_t *x ) {
+	__asm__ ( "rorw $8, %0" : "+m" ( *x ) );
+}
+
+static inline __attribute__ (( always_inline, const )) uint32_t
+__bswap_variable_32 ( uint32_t x ) {
+	__asm__ ( "bswapl %k0" : "=r" ( x ) : "0" ( x ) );
+	return x;
+}
+
+static inline __attribute__ (( always_inline )) void
+__bswap_32s ( uint32_t *x ) {
+	__asm__ ( "bswapl %k0" : "=r" ( *x ) : "0" ( *x ) );
+}
+
+#ifdef __x86_64__
+
+static inline __attribute__ (( always_inline, const )) uint64_t
+__bswap_variable_64 ( uint64_t x ) {
+	__asm__ ( "bswapq %q0" : "=r" ( x ) : "0" ( x ) );
+	return x;
+}
+
+#else /* __x86_64__ */
+
+static inline __attribute__ (( always_inline, const )) uint64_t
+__bswap_variable_64 ( uint64_t x ) {
+	uint32_t in_high = ( x >> 32 );
+	uint32_t in_low = ( x & 0xffffffffUL );
+	uint32_t out_high;
+	uint32_t out_low;
+
+	__asm__ ( "bswapl %0\n\t"
+		  "bswapl %1\n\t"
+		  "xchgl %0,%1\n\t"
+		  : "=r" ( out_high ), "=r" ( out_low )
+		  : "0" ( in_high ), "1" ( in_low ) );
+
+	return ( ( ( ( uint64_t ) out_high ) << 32 ) |
+		 ( ( uint64_t ) out_low ) );
+}
+
+#endif /* __x86_64__ */
+
+static inline __attribute__ (( always_inline )) void
+__bswap_64s ( uint64_t *x ) {
+	*x = __bswap_variable_64 ( *x );
+}
+
+/**
+ * Byte-swap a 16-bit constant
+ *
+ * @v value		Constant value
+ * @ret swapped		Byte-swapped value
+ */
+#define __bswap_constant_16( value )					\
+	( ( ( (value) & 0x00ff ) << 8 ) |				\
+	  ( ( (value) & 0xff00 ) >> 8 ) )
+
+/**
+ * Byte-swap a 32-bit constant
+ *
+ * @v value		Constant value
+ * @ret swapped		Byte-swapped value
+ */
+#define __bswap_constant_32( value ) \
+	( ( ( (value) & 0x000000ffUL ) << 24 ) |			\
+	  ( ( (value) & 0x0000ff00UL ) <<  8 ) |			\
+	  ( ( (value) & 0x00ff0000UL ) >>  8 ) |			\
+	  ( ( (value) & 0xff000000UL ) >> 24 ) )
+
+/**
+ * Byte-swap a 64-bit constant
+ *
+ * @v value		Constant value
+ * @ret swapped		Byte-swapped value
+ */
+#define __bswap_constant_64( value )					\
+	( ( ( (value) & 0x00000000000000ffULL ) << 56 ) |		\
+	  ( ( (value) & 0x000000000000ff00ULL ) << 40 ) |		\
+	  ( ( (value) & 0x0000000000ff0000ULL ) << 24 ) |		\
+	  ( ( (value) & 0x00000000ff000000ULL ) <<  8 ) |		\
+	  ( ( (value) & 0x000000ff00000000ULL ) >>  8 ) |		\
+	  ( ( (value) & 0x0000ff0000000000ULL ) >> 24 ) |		\
+	  ( ( (value) & 0x00ff000000000000ULL ) >> 40 ) |		\
+	  ( ( (value) & 0xff00000000000000ULL ) >> 56 ) )
+
+/**
+ * Byte-swap a 16-bit value
+ *
+ * @v value		Value
+ * @ret swapped		Byte-swapped value
+ */
+#define __bswap_16( value )						\
+	( __builtin_constant_p (value) ?				\
+	  ( ( uint16_t ) __bswap_constant_16 ( ( uint16_t ) (value) ) ) \
+	  : __bswap_variable_16 (value) )
+#define bswap_16( value ) __bswap_16 (value)
+
+/**
+ * Byte-swap a 32-bit value
+ *
+ * @v value		Value
+ * @ret swapped		Byte-swapped value
+ */
+#define __bswap_32( value )						\
+	( __builtin_constant_p (value) ?				\
+	  ( ( uint32_t ) __bswap_constant_32 ( ( uint32_t ) (value) ) ) \
+	  : __bswap_variable_32 (value) )
+#define bswap_32( value ) __bswap_32 (value)
+
+/**
+ * Byte-swap a 64-bit value
+ *
+ * @v value		Value
+ * @ret swapped		Byte-swapped value
+ */
+#define __bswap_64( value )						\
+	( __builtin_constant_p (value) ?				\
+	  ( ( uint64_t ) __bswap_constant_64 ( ( uint64_t ) (value) ) ) \
+          : __bswap_variable_64 (value) )
+#define bswap_64( value ) __bswap_64 (value)
+
+#define __cpu_to_leNN( bits, value ) (value)
+#define __cpu_to_beNN( bits, value ) __bswap_ ## bits (value)
+#define __leNN_to_cpu( bits, value ) (value)
+#define __beNN_to_cpu( bits, value ) __bswap_ ## bits (value)
+#define __cpu_to_leNNs( bits, ptr ) do { } while ( 0 )
+#define __cpu_to_beNNs( bits, ptr ) __bswap_ ## bits ## s (ptr)
+#define __leNN_to_cpus( bits, ptr ) do { } while ( 0 )
+#define __beNN_to_cpus( bits, ptr ) __bswap_ ## bits ## s (ptr)
+
+#define cpu_to_le16( value ) __cpu_to_leNN ( 16, value )
+#define cpu_to_le32( value ) __cpu_to_leNN ( 32, value )
+#define cpu_to_le64( value ) __cpu_to_leNN ( 64, value )
+#define cpu_to_be16( value ) __cpu_to_beNN ( 16, value )
+#define cpu_to_be32( value ) __cpu_to_beNN ( 32, value )
+#define cpu_to_be64( value ) __cpu_to_beNN ( 64, value )
+#define le16_to_cpu( value ) __leNN_to_cpu ( 16, value )
+#define le32_to_cpu( value ) __leNN_to_cpu ( 32, value )
+#define le64_to_cpu( value ) __leNN_to_cpu ( 64, value )
+#define be16_to_cpu( value ) __beNN_to_cpu ( 16, value )
+#define be32_to_cpu( value ) __beNN_to_cpu ( 32, value )
+#define be64_to_cpu( value ) __beNN_to_cpu ( 64, value )
+#define cpu_to_le16s( ptr ) __cpu_to_leNNs ( 16, ptr )
+#define cpu_to_le32s( ptr ) __cpu_to_leNNs ( 32, ptr )
+#define cpu_to_le64s( ptr ) __cpu_to_leNNs ( 64, ptr )
+#define cpu_to_be16s( ptr ) __cpu_to_beNNs ( 16, ptr )
+#define cpu_to_be32s( ptr ) __cpu_to_beNNs ( 32, ptr )
+#define cpu_to_be64s( ptr ) __cpu_to_beNNs ( 64, ptr )
+#define le16_to_cpus( ptr ) __leNN_to_cpus ( 16, ptr )
+#define le32_to_cpus( ptr ) __leNN_to_cpus ( 32, ptr )
+#define le64_to_cpus( ptr ) __leNN_to_cpus ( 64, ptr )
+#define be16_to_cpus( ptr ) __beNN_to_cpus ( 16, ptr )
+#define be32_to_cpus( ptr ) __beNN_to_cpus ( 32, ptr )
+#define be64_to_cpus( ptr ) __beNN_to_cpus ( 64, ptr )
+
+#define htonll( value ) cpu_to_be64 (value)
+#define ntohll( value ) be64_to_cpu (value)
+#define htonl( value ) cpu_to_be32 (value)
+#define ntohl( value ) be32_to_cpu (value)
+#define htons( value ) cpu_to_be16 (value)
+#define ntohs( value ) be16_to_cpu (value)
+
+#endif /* _BITS_BYTESWAP_H */

wimboot/wimboot-2.7.3/src/cmdline.c

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * Command line
+ *
+ */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include "wimboot.h"
+#include "cmdline.h"
+
+/** Use raw (unpatched) BCD files */
+int cmdline_rawbcd;
+
+/** Use raw (unpatched) WIM files */
+int cmdline_rawwim;
+
+/** Inhibit debugging output */
+int cmdline_quiet;
+
+/** Allow graphical output from bootmgr/bootmgfw */
+int cmdline_gui;
+
+/** Pause before booting OS */
+int cmdline_pause;
+
+/** Pause without displaying any prompt */
+int cmdline_pause_quiet;
+
+/** Use linear (unpaged) memory model */
+int cmdline_linear;
+
+/** WIM boot index */
+unsigned int cmdline_index;
+
+int cmdline_vf_num;
+char cmdline_vf_path[MAX_VF][64];
+
+file_size_pf pfventoy_file_size;
+file_read_pf pfventoy_file_read;
+
+/**
+ * Process command line
+ *
+ * @v cmdline		Command line
+ */
+void process_cmdline ( char *cmdline ) {
+	char *tmp = cmdline;
+	char *key;
+	char *value;
+	char *endp;
+
+	/* Do nothing if we have no command line */
+	if ( ( cmdline == NULL ) || ( cmdline[0] == '\0' ) )
+		return;
+
+	/* Parse command line */
+	while ( *tmp ) {
+
+		/* Skip whitespace */
+		while ( isspace ( *tmp ) )
+			tmp++;
+
+		/* Find value (if any) and end of this argument */
+		key = tmp;
+		value = NULL;
+		while ( *tmp ) {
+			if ( isspace ( *tmp ) ) {
+				*(tmp++) = '\0';
+				break;
+			} else if ( *tmp == '=' ) {
+				*(tmp++) = '\0';
+				value = tmp;
+			} else {
+				tmp++;
+			}
+		}
+
+		/* Process this argument */
+		if ( strcmp ( key, "rawbcd" ) == 0 ) {
+			cmdline_rawbcd = 1;
+		} else if ( strcmp ( key, "rawwim" ) == 0 ) {
+			cmdline_rawwim = 1;
+		} else if ( strcmp ( key, "gui" ) == 0 ) {
+			cmdline_gui = 1;
+		}
+
+        else if ((key[0] == 'v') && (key[1] == 'f') ) {
+            if (cmdline_vf_num >= MAX_VF)
+                die("Too many vf\n");
+            snprintf(cmdline_vf_path[cmdline_vf_num], 64, "%s", value);
+            cmdline_vf_num++;
+		}else if ( strcmp ( key, "pfsize" ) == 0 ) {    
+            pfventoy_file_size = (file_size_pf)strtoul(value, &endp, 0);
+		} else if ( strcmp ( key, "pfread" ) == 0 ) {
+            pfventoy_file_read = (file_read_pf)strtoul(value, &endp, 0 );
+		}
+
+        else if ( strcmp ( key, "linear" ) == 0 ) {
+			cmdline_linear = 1;
+		} else if ( strcmp ( key, "quiet" ) == 0 ) {
+			cmdline_quiet = 1;
+		} else if ( strcmp ( key, "pause" ) == 0 ) {
+			cmdline_pause = 1;
+			if ( value && ( strcmp ( value, "quiet" ) == 0 ) )
+				cmdline_pause_quiet = 1;
+		} else if ( strcmp ( key, "index" ) == 0 ) {
+			if ( ( ! value ) || ( ! value[0] ) )
+				die ( "Argument \"index\" needs a value\n" );
+			cmdline_index = strtoul ( value, &endp, 0 );
+			if ( *endp )
+				die ( "Invalid index \"%s\"\n", value );
+		} else if ( strcmp ( key, "initrdfile" ) == 0 ) {
+			/* Ignore this keyword to allow for use with syslinux */
+		} else if ( key == cmdline ) {
+			/* Ignore unknown initial arguments, which may
+			 * be the program name.
+			 */
+		} else {
+			die ( "Unrecognised argument \"%s%s%s\"\n", key,
+			      ( value ? "=" : "" ), ( value ? value : "" ) );
+		}
+	}
+
+	/* Show command line (after parsing "quiet" option) */
+	DBG ( "Command line: \"%s\" vf=%d pfsize=%p pfread=%p\n", 
+	    cmdline, cmdline_vf_num, pfventoy_file_size, pfventoy_file_read);
+}

wimboot/wimboot-2.7.3/src/cmdline.h

@@ -0,0 +1,48 @@
+#ifndef _CMDLINE_H
+#define _CMDLINE_H
+
+/*
+ * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * Command line
+ *
+ */
+
+extern int cmdline_rawbcd;
+extern int cmdline_rawwim;
+extern int cmdline_quiet;
+extern int cmdline_gui;
+extern int cmdline_pause;
+extern int cmdline_pause_quiet;
+extern int cmdline_linear;
+extern unsigned int cmdline_index;
+extern void process_cmdline ( char *cmdline );
+
+typedef int (*file_size_pf)(const char *path);
+typedef int (*file_read_pf)(const char *path, int offset, int len, void *buf);
+extern file_size_pf pfventoy_file_size;
+extern file_read_pf pfventoy_file_read;
+#define MAX_VF 16
+extern char cmdline_vf_path[MAX_VF][64];
+extern int cmdline_vf_num;
+
+#endif /* _CMDLINE_H */

wimboot/wimboot-2.7.3/src/compiler.h

@@ -0,0 +1,43 @@
+#ifndef _COMPILER_H
+#define _COMPILER_H
+
+/*
+ * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * Global compiler definitions
+ *
+ */
+
+/* Force visibility of all symbols to "hidden", i.e. inform gcc that
+ * all symbol references resolve strictly within our final binary.
+ * This avoids unnecessary PLT/GOT entries on x86_64.
+ *
+ * This is a stronger claim than specifying "-fvisibility=hidden",
+ * since it also affects symbols marked with "extern".
+ */
+#ifndef ASSEMBLY
+#if __GNUC__ >= 4
+#pragma GCC visibility push(hidden)
+#endif
+#endif /* ASSEMBLY */
+
+#endif /* _COMPILER_H */

wimboot/wimboot-2.7.3/src/cookie.c

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2021 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * Stack cookie
+ *
+ */
+
+#include "wimboot.h"
+
+/** Stack cookie */
+unsigned long __stack_chk_guard;
+
+/**
+ * Construct stack cookie value
+ *
+ */
+static __attribute__ (( noinline )) unsigned long make_cookie ( void ) {
+	union {
+		struct {
+			uint32_t eax;
+			uint32_t edx;
+		} __attribute__ (( packed ));
+		unsigned long tsc;
+	} u;
+	unsigned long cookie;
+
+	/* We have no viable source of entropy.  Use the CPU timestamp
+	 * counter, which will have at least some minimal randomness
+	 * in the low bits by the time we are invoked.
+	 */
+	__asm__ ( "rdtsc" : "=a" ( u.eax ), "=d" ( u.edx ) );
+	cookie = u.tsc;
+
+	/* Ensure that the value contains a NUL byte, to act as a
+	 * runaway string terminator.  Construct the NUL using a shift
+	 * rather than a mask, to avoid losing valuable entropy in the
+	 * lower-order bits.
+	 */
+	cookie <<= 8;
+
+	return cookie;
+}
+
+/**
+ * Initialise stack cookie
+ *
+ * This function must not itself use stack guard
+ */
+void init_cookie ( void ) {
+
+	/* Set stack cookie value
+	 *
+	 * This function must not itself use stack protection, since
+	 * the change in the stack guard value would trigger a false
+	 * positive.
+	 *
+	 * There is unfortunately no way to annotate a function to
+	 * exclude the use of stack protection.  We must therefore
+	 * rely on correctly anticipating the compiler's decision on
+	 * the use of stack protection.
+	 */
+	__stack_chk_guard = make_cookie();
+}
+
+/**
+ * Abort on stack check failure
+ *
+ */
+void __stack_chk_fail ( void ) {
+
+	/* Abort program */
+	die ( "Stack check failed\n" );
+}

wimboot/wimboot-2.7.3/src/coverity-model.c

@@ -0,0 +1,15 @@
+/*
+ * Coverity modelling file
+ *
+ */
+
+typedef unsigned short wchar_t;
+typedef void mbstate_t;
+
+/* Inhibit use of built-in models for functions where Coverity's
+ * assumptions about the modelled function are incorrect for wimboot.
+ */
+int getchar ( void ) {
+}
+size_t wcrtomb ( char *buf, wchar_t wc, mbstate_t *ps ) {
+}

wimboot/wimboot-2.7.3/src/cpio.c

@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * CPIO archives
+ *
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "wimboot.h"
+#include "cpio.h"
+
+/**
+ * Align CPIO length to nearest dword
+ *
+ * @v len		Length
+ * @ret len		Aligned length
+ */
+static size_t cpio_align ( size_t len ) {
+	return ( ( len + 0x03 ) & ~0x03 );
+}
+
+/**
+ * Parse CPIO field value
+ *
+ * @v field		ASCII field
+ * @ret value		Field value
+ */
+static unsigned long cpio_value ( const char *field ) {
+	char buf[9];
+
+	memcpy ( buf, field, ( sizeof ( buf ) - 1 ) );
+	buf[ sizeof ( buf ) - 1 ] = '\0';
+	return strtoul ( buf, NULL, 16 );
+}
+
+/**
+ * Extract files from CPIO archive
+ *
+ * @v data		CPIO archive
+ * @v len		Maximum length of CPIO archive
+ * @v file		File handler
+ * @ret rc		Return status code
+ */
+int cpio_extract ( void *data, size_t len,
+		   int ( * file ) ( const char *name, void *data,
+				    size_t len ) ) {
+	const struct cpio_header *cpio;
+	const uint32_t *pad;
+	const char *file_name;
+	void *file_data;
+	size_t file_name_len;
+	size_t file_len;
+	size_t cpio_len;
+	int rc;
+
+	while ( 1 ) {
+
+		/* Skip over any padding */
+		while ( len >= sizeof ( *pad ) ) {
+			pad = data;
+			if ( *pad )
+				break;
+			data += sizeof ( *pad );
+			len -= sizeof ( *pad );
+		}
+
+		/* Stop if we have reached the end of the archive */
+		if ( ! len )
+			return 0;
+
+		/* Sanity check */
+		if ( len < sizeof ( *cpio ) ) {
+			DBG ( "Truncated CPIO header\n" );
+			return -1;
+		}
+		cpio = data;
+
+		/* Check magic */
+		if ( memcmp ( cpio->c_magic, CPIO_MAGIC,
+			      sizeof ( cpio->c_magic ) ) != 0 ) {
+			DBG ( "Bad CPIO magic\n" );
+			return -1;
+		}
+
+		/* Extract file parameters */
+		file_name = ( ( void * ) ( cpio + 1 ) );
+		file_name_len = cpio_value ( cpio->c_namesize );
+		file_data = ( data + cpio_align ( sizeof ( *cpio ) +
+						  file_name_len ) );
+		file_len = cpio_value ( cpio->c_filesize );
+		cpio_len = ( file_data + file_len - data );
+		if ( cpio_len < len )
+			cpio_len = cpio_align ( cpio_len );
+		if ( cpio_len > len ) {
+			DBG ( "Truncated CPIO file\n" );
+			return -1;
+		}
+
+		/* If we reach the trailer, we're done */
+		if ( strcmp ( file_name, CPIO_TRAILER ) == 0 )
+			return 0;
+
+		/* Process file */
+		if ( ( rc = file ( file_name, file_data, file_len ) ) != 0 )
+			return rc;
+
+		/* Move to next file */
+		data += cpio_len;
+		len -= cpio_len;
+	}
+}

wimboot/wimboot-2.7.3/src/cpio.h

@@ -0,0 +1,78 @@
+#ifndef _CPIO_H
+#define _CPIO_H
+
+/*
+ * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * CPIO archives
+ *
+ */
+
+#include <stdint.h>
+
+/** A CPIO archive header
+ *
+ * All field are hexadecimal ASCII numbers padded with '0' on the
+ * left to the full width of the field.
+ */
+struct cpio_header {
+	/** The string "070701" or "070702" */
+	char c_magic[6];
+	/** File inode number */
+	char c_ino[8];
+	/** File mode and permissions */
+	char c_mode[8];
+	/** File uid */
+	char c_uid[8];
+	/** File gid */
+	char c_gid[8];
+	/** Number of links */
+	char c_nlink[8];
+	/** Modification time */
+	char c_mtime[8];
+	/** Size of data field */
+	char c_filesize[8];
+	/** Major part of file device number */
+	char c_maj[8];
+	/** Minor part of file device number */
+	char c_min[8];
+	/** Major part of device node reference */
+	char c_rmaj[8];
+	/** Minor part of device node reference */
+	char c_rmin[8];
+	/** Length of filename, including final NUL */
+	char c_namesize[8];
+	/** Checksum of data field if c_magic is 070702, othersize zero */
+	char c_chksum[8];
+} __attribute__ (( packed ));
+
+/** CPIO magic */
+#define CPIO_MAGIC "070701"
+
+/** CPIO trailer */
+#define CPIO_TRAILER "TRAILER!!!"
+
+extern int cpio_extract ( void *data, size_t len,
+			  int ( * file ) ( const char *name, void *data,
+					   size_t len ) );
+
+#endif /* _CPIO_H */

wimboot/wimboot-2.7.3/src/ctype.h

@@ -0,0 +1,47 @@
+#ifndef _CTYPE_H
+#define _CTYPE_H
+
+/*
+ * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * Character types
+ *
+ */
+
+static inline int islower ( int c ) {
+	return ( ( c >= 'a' ) && ( c <= 'z' ) );
+}
+
+static inline int isupper ( int c ) {
+	return ( ( c >= 'A' ) && ( c <= 'Z' ) );
+}
+
+static inline int toupper ( int c ) {
+
+	if ( islower ( c ) )
+		c -= ( 'a' - 'A' );
+	return c;
+}
+
+extern int isspace ( int c );
+
+#endif /* _CTYPE_H */

wimboot/wimboot-2.7.3/src/die.c

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * Fatal errors
+ *
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "wimboot.h"
+#include "efi.h"
+
+/**
+ * Handle fatal errors
+ *
+ * @v fmt	Error message format string
+ * @v ...	Arguments
+ */
+void die ( const char *fmt, ... ) {
+	EFI_BOOT_SERVICES *bs;
+	EFI_RUNTIME_SERVICES *rs;
+	va_list args;
+
+	/* Print message */
+	va_start ( args, fmt );
+	vprintf ( fmt, args );
+	va_end ( args );
+
+	/* Reboot or exit as applicable */
+	if ( efi_systab ) {
+
+		/* Exit */
+		bs = efi_systab->BootServices;
+		bs->Exit ( efi_image_handle, EFI_LOAD_ERROR, 0, NULL );
+		printf ( "Failed to exit\n" );
+		rs = efi_systab->RuntimeServices;
+		rs->ResetSystem ( EfiResetWarm, 0, 0, NULL );
+		printf ( "Failed to reboot\n" );
+
+	} else {
+
+		/* Wait for keypress */
+		printf ( "Press a key to reboot..." );
+		getchar();
+		printf ( "\n" );
+
+		/* Reboot system */
+		reboot();
+	}
+
+	/* Should be impossible to reach this */
+	__builtin_unreachable();
+}

wimboot/wimboot-2.7.3/src/efi.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * EFI interface
+ *
+ */
+
+#include "wimboot.h"
+#include "efi.h"
+
+/** EFI system table */
+EFI_SYSTEM_TABLE *efi_systab;
+
+/** EFI image handle */
+EFI_HANDLE efi_image_handle;

wimboot/wimboot-2.7.3/src/efi.h

@@ -0,0 +1,52 @@
+#ifndef _EFI_H
+#define _EFI_H
+
+/*
+ * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * EFI definitions
+ *
+ */
+
+/* EFIAPI definition */
+#if __x86_64__
+#define EFIAPI __attribute__ (( ms_abi ))
+#else
+#define EFIAPI
+#endif
+
+/* EFI headers rudely redefine NULL */
+#undef NULL
+
+#include "efi/Uefi.h"
+#include "efi/Protocol/LoadedImage.h"
+
+extern EFI_SYSTEM_TABLE *efi_systab;
+extern EFI_HANDLE efi_image_handle;
+
+extern EFI_GUID efi_block_io_protocol_guid;
+extern EFI_GUID efi_device_path_protocol_guid;
+extern EFI_GUID efi_graphics_output_protocol_guid;
+extern EFI_GUID efi_loaded_image_protocol_guid;
+extern EFI_GUID efi_simple_file_system_protocol_guid;
+
+#endif /* _EFI_H */

wimboot/wimboot-2.7.3/src/efi/Guid/FileInfo.h

@@ -0,0 +1,71 @@
+/** @file
+  Provides a GUID and a data structure that can be used with EFI_FILE_PROTOCOL.SetInfo()
+  and EFI_FILE_PROTOCOL.GetInfo() to set or get generic file information.
+  This GUID is defined in UEFI specification.
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __FILE_INFO_H__
+#define __FILE_INFO_H__
+
+#define EFI_FILE_INFO_ID \
+  { \
+    0x9576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct {
+  ///
+  /// The size of the EFI_FILE_INFO structure, including the Null-terminated FileName string.
+  ///
+  UINT64    Size;
+  ///
+  /// The size of the file in bytes.
+  ///
+  UINT64    FileSize;
+  ///
+  /// PhysicalSize The amount of physical space the file consumes on the file system volume.
+  ///
+  UINT64    PhysicalSize;
+  ///
+  /// The time the file was created.
+  ///
+  EFI_TIME  CreateTime;
+  ///
+  /// The time when the file was last accessed.
+  ///
+  EFI_TIME  LastAccessTime;
+  ///
+  /// The time when the file's contents were last modified.
+  ///
+  EFI_TIME  ModificationTime;
+  ///
+  /// The attribute bits for the file.
+  ///
+  UINT64    Attribute;
+  ///
+  /// The Null-terminated name of the file.
+  ///
+  CHAR16    FileName[1];
+} EFI_FILE_INFO;
+
+///
+/// The FileName field of the EFI_FILE_INFO data structure is variable length.
+/// Whenever code needs to know the size of the EFI_FILE_INFO data structure, it needs to
+/// be the size of the data structure without the FileName field.  The following macro
+/// computes this size correctly no matter how big the FileName array is declared.
+/// This is required to make the EFI_FILE_INFO data structure ANSI compilant.
+///
+#define SIZE_OF_EFI_FILE_INFO OFFSET_OF (EFI_FILE_INFO, FileName)
+
+extern EFI_GUID gEfiFileInfoGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Guid/HiiFormMapMethodGuid.h

@@ -0,0 +1,25 @@
+/** @file
+  Guid used to identify HII FormMap configuration method.
+
+  Copyright (c) 2009, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+  @par Revision Reference:
+  GUID defined in UEFI 2.2 spec.
+**/
+
+#ifndef __EFI_HII_FORMMAP_GUID_H__
+#define __EFI_HII_FORMMAP_GUID_H__
+
+#define EFI_HII_STANDARD_FORM_GUID \
+  { 0x3bd2f4ec, 0xe524, 0x46e4, { 0xa9, 0xd8, 0x51, 0x1, 0x17, 0x42, 0x55, 0x62 } }
+
+extern EFI_GUID gEfiHiiStandardFormGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Guid/PcAnsi.h

@@ -0,0 +1,58 @@
+/** @file
+  Terminal Device Path Vendor Guid.
+
+  Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.0 spec.
+
+**/
+
+#ifndef __PC_ANSI_H__
+#define __PC_ANSI_H__
+
+#define EFI_PC_ANSI_GUID \
+  { \
+    0xe0c14753, 0xf9be, 0x11d2, {0x9a, 0x0c, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+#define EFI_VT_100_GUID \
+  { \
+    0xdfa66065, 0xb419, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+#define EFI_VT_100_PLUS_GUID \
+  { \
+    0x7baec70b, 0x57e0, 0x4c76, {0x8e, 0x87, 0x2f, 0x9e, 0x28, 0x08, 0x83, 0x43 } \
+  }
+
+#define EFI_VT_UTF8_GUID \
+  { \
+    0xad15a0d6, 0x8bec, 0x4acf, {0xa0, 0x73, 0xd0, 0x1d, 0xe7, 0x7e, 0x2d, 0x88 } \
+  }
+
+#define DEVICE_PATH_MESSAGING_UART_FLOW_CONTROL \
+  { \
+    0x37499a9d, 0x542f, 0x4c89, {0xa0, 0x26, 0x35, 0xda, 0x14, 0x20, 0x94, 0xe4 } \
+  }
+
+#define EFI_SAS_DEVICE_PATH_GUID \
+  { \
+    0xd487ddb4, 0x008b, 0x11d9, {0xaf, 0xdc, 0x00, 0x10, 0x83, 0xff, 0xca, 0x4d } \
+  }
+
+extern EFI_GUID gEfiPcAnsiGuid;
+extern EFI_GUID gEfiVT100Guid;
+extern EFI_GUID gEfiVT100PlusGuid;
+extern EFI_GUID gEfiVTUTF8Guid;
+extern EFI_GUID gEfiUartDevicePathGuid;
+extern EFI_GUID gEfiSasDevicePathGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Guid/WinCertificate.h

@@ -0,0 +1,128 @@
+/** @file
+  GUID for UEFI WIN_CERTIFICATE structure.
+
+  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+  @par Revision Reference:
+  GUID defined in UEFI 2.0 spec.
+**/
+
+#ifndef __EFI_WIN_CERTIFICATE_H__
+#define __EFI_WIN_CERTIFICATE_H__
+
+//
+// _WIN_CERTIFICATE.wCertificateType
+//
+#define WIN_CERT_TYPE_PKCS_SIGNED_DATA 0x0002
+#define WIN_CERT_TYPE_EFI_PKCS115      0x0EF0
+#define WIN_CERT_TYPE_EFI_GUID         0x0EF1
+
+///
+/// The WIN_CERTIFICATE structure is part of the PE/COFF specification.
+///
+typedef struct {
+  ///
+  /// The length of the entire certificate,
+  /// including the length of the header, in bytes.
+  ///
+  UINT32  dwLength;
+  ///
+  /// The revision level of the WIN_CERTIFICATE
+  /// structure. The current revision level is 0x0200.
+  ///
+  UINT16  wRevision;
+  ///
+  /// The certificate type. See WIN_CERT_TYPE_xxx for the UEFI
+  /// certificate types. The UEFI specification reserves the range of
+  /// certificate type values from 0x0EF0 to 0x0EFF.
+  ///
+  UINT16  wCertificateType;
+  ///
+  /// The following is the actual certificate. The format of
+  /// the certificate depends on wCertificateType.
+  ///
+  /// UINT8 bCertificate[ANYSIZE_ARRAY];
+  ///
+} WIN_CERTIFICATE;
+
+///
+/// WIN_CERTIFICATE_UEFI_GUID.CertType
+///
+#define EFI_CERT_TYPE_RSA2048_SHA256_GUID \
+  {0xa7717414, 0xc616, 0x4977, {0x94, 0x20, 0x84, 0x47, 0x12, 0xa7, 0x35, 0xbf } }
+
+///
+/// WIN_CERTIFICATE_UEFI_GUID.CertData
+///
+typedef struct {
+  EFI_GUID  HashType;
+  UINT8     PublicKey[256];
+  UINT8     Signature[256];
+} EFI_CERT_BLOCK_RSA_2048_SHA256;
+
+
+///
+/// Certificate which encapsulates a GUID-specific digital signature
+///
+typedef struct {
+  ///
+  /// This is the standard WIN_CERTIFICATE header, where
+  /// wCertificateType is set to WIN_CERT_TYPE_EFI_GUID.
+  ///
+  WIN_CERTIFICATE   Hdr;
+  ///
+  /// This is the unique id which determines the
+  /// format of the CertData. .
+  ///
+  EFI_GUID          CertType;
+  ///
+  /// The following is the certificate data. The format of
+  /// the data is determined by the CertType.
+  /// If CertType is EFI_CERT_TYPE_RSA2048_SHA256_GUID,
+  /// the CertData will be EFI_CERT_BLOCK_RSA_2048_SHA256 structure.
+  ///
+  UINT8            CertData[1];
+} WIN_CERTIFICATE_UEFI_GUID;
+
+
+///
+/// Certificate which encapsulates the RSASSA_PKCS1-v1_5 digital signature.
+///
+/// The WIN_CERTIFICATE_UEFI_PKCS1_15 structure is derived from
+/// WIN_CERTIFICATE and encapsulate the information needed to
+/// implement the RSASSA-PKCS1-v1_5 digital signature algorithm as
+/// specified in RFC2437.
+///
+typedef struct {
+  ///
+  /// This is the standard WIN_CERTIFICATE header, where
+  /// wCertificateType is set to WIN_CERT_TYPE_UEFI_PKCS1_15.
+  ///
+  WIN_CERTIFICATE Hdr;
+  ///
+  /// This is the hashing algorithm which was performed on the
+  /// UEFI executable when creating the digital signature.
+  ///
+  EFI_GUID        HashAlgorithm;
+  ///
+  /// The following is the actual digital signature. The
+  /// size of the signature is the same size as the key
+  /// (1024-bit key is 128 bytes) and can be determined by
+  /// subtracting the length of the other parts of this header
+  /// from the total length of the certificate as found in
+  /// Hdr.dwLength.
+  ///
+  /// UINT8 Signature[];
+  ///
+} WIN_CERTIFICATE_EFI_PKCS1_15;
+
+extern EFI_GUID gEfiCertTypeRsa2048Sha256Guid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Ia32/ProcessorBind.h

@@ -0,0 +1,288 @@
+/** @file
+  Processor or Compiler specific defines and types for IA-32 architecture.
+
+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __PROCESSOR_BIND_H__
+#define __PROCESSOR_BIND_H__
+
+///
+/// Define the processor type so other code can make processor based choices.
+///
+#define MDE_CPU_IA32
+
+//
+// Make sure we are using the correct packing rules per EFI specification
+//
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#if defined(__INTEL_COMPILER)
+//
+// Disable ICC's remark #869: "Parameter" was never referenced warning.
+// This is legal ANSI C code so we disable the remark that is turned on with -Wall
+//
+#pragma warning ( disable : 869 )
+
+//
+// Disable ICC's remark #1418: external function definition with no prior declaration.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1418 )
+
+//
+// Disable ICC's remark #1419: external declaration in primary source file
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1419 )
+
+//
+// Disable ICC's remark #593: "Variable" was set but never used.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 593 )
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+
+//
+// Disable warning that make it impossible to compile at /W4
+// This only works for Microsoft* tools
+//
+
+//
+// Disabling bitfield type checking warnings.
+//
+#pragma warning ( disable : 4214 )
+
+//
+// Disabling the unreferenced formal parameter warnings.
+//
+#pragma warning ( disable : 4100 )
+
+//
+// Disable slightly different base types warning as CHAR8 * can not be set
+// to a constant string.
+//
+#pragma warning ( disable : 4057 )
+
+//
+// ASSERT(FALSE) or while (TRUE) are legal constructes so supress this warning
+//
+#pragma warning ( disable : 4127 )
+
+//
+// This warning is caused by functions defined but not used. For precompiled header only.
+//
+#pragma warning ( disable : 4505 )
+
+//
+// This warning is caused by empty (after preprocessing) source file. For precompiled header only.
+//
+#pragma warning ( disable : 4206 )
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+
+  //
+  // use Microsoft C complier dependent integer width types
+  //
+
+  ///
+  /// 8-byte unsigned value.
+  ///
+  typedef unsigned __int64    UINT64;
+  ///
+  /// 8-byte signed value.
+  ///
+  typedef __int64             INT64;
+  ///
+  /// 4-byte unsigned value.
+  ///
+  typedef unsigned __int32    UINT32;
+  ///
+  /// 4-byte signed value.
+  ///
+  typedef __int32             INT32;
+  ///
+  /// 2-byte unsigned value.
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value.
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value.
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character.
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value.
+  ///
+  typedef signed char         INT8;
+#else
+  ///
+  /// 8-byte unsigned value.
+  ///
+  typedef unsigned long long  UINT64;
+  ///
+  /// 8-byte signed value.
+  ///
+  typedef long long           INT64;
+  ///
+  /// 4-byte unsigned value.
+  ///
+  typedef unsigned int        UINT32;
+  ///
+  /// 4-byte signed value.
+  ///
+  typedef int                 INT32;
+  ///
+  /// 2-byte unsigned value.
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value.
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value.
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value
+  ///
+  typedef signed char         INT8;
+#endif
+
+///
+/// Unsigned value of native width.  (4 bytes on supported 32-bit processor instructions;
+/// 8 bytes on supported 64-bit processor instructions.)
+///
+typedef UINT32  UINTN;
+///
+/// Signed value of native width.  (4 bytes on supported 32-bit processor instructions;
+/// 8 bytes on supported 64-bit processor instructions.)
+///
+typedef INT32   INTN;
+
+//
+// Processor specific defines
+//
+
+///
+/// A value of native width with the highest bit set.
+///
+#define MAX_BIT     0x80000000
+///
+/// A value of native width with the two highest bits set.
+///
+#define MAX_2_BITS  0xC0000000
+
+///
+/// Maximum legal IA-32 address.
+///
+#define MAX_ADDRESS   0xFFFFFFFF
+
+///
+/// Maximum legal IA-32 INTN and UINTN values.
+///
+#define MAX_INTN   ((INTN)0x7FFFFFFF)
+#define MAX_UINTN  ((UINTN)0xFFFFFFFF)
+
+///
+/// The stack alignment required for IA-32.
+///
+#define CPU_STACK_ALIGNMENT   sizeof(UINTN)
+
+//
+// Modifier to ensure that all protocol member functions and EFI intrinsics
+// use the correct C calling convention. All protocol member functions and
+// EFI intrinsics are required to modify their member functions with EFIAPI.
+//
+#ifdef EFIAPI
+  ///
+  /// If EFIAPI is already defined, then we use that definition.
+  ///
+#elif defined(_MSC_EXTENSIONS)
+  ///
+  /// Microsoft* compiler specific method for EFIAPI calling convention.
+  ///
+  #define EFIAPI __cdecl
+#elif defined(__GNUC__)
+  ///
+  /// GCC specific method for EFIAPI calling convention.
+  ///
+  #define EFIAPI __attribute__((cdecl))
+#else
+  ///
+  /// The default for a non Microsoft* or GCC compiler is to assume the EFI ABI
+  /// is the standard.
+  ///
+  #define EFIAPI
+#endif
+
+#if defined(__GNUC__)
+  ///
+  /// For GNU assembly code, .global or .globl can declare global symbols.
+  /// Define this macro to unify the usage.
+  ///
+  #define ASM_GLOBAL .globl
+#endif
+
+/**
+  Return the pointer to the first instruction of a function given a function pointer.
+  On IA-32 CPU architectures, these two pointer values are the same,
+  so the implementation of this macro is very simple.
+
+  @param  FunctionPointer   A pointer to a function.
+
+  @return The pointer to the first instruction of a function given a function pointer.
+
+**/
+#define FUNCTION_ENTRY_POINT(FunctionPointer) (VOID *)(UINTN)(FunctionPointer)
+
+#endif
+

wimboot/wimboot-2.7.3/src/efi/IndustryStandard/PeImage.h

@@ -0,0 +1,756 @@
+/** @file
+  EFI image format for PE32, PE32+ and TE. Please note some data structures are
+  different for PE32 and PE32+. EFI_IMAGE_NT_HEADERS32 is for PE32 and
+  EFI_IMAGE_NT_HEADERS64 is for PE32+.
+
+  This file is coded to the Visual Studio, Microsoft Portable Executable and
+  Common Object File Format Specification, Revision 8.3 - February 6, 2013.
+  This file also includes some definitions in PI Specification, Revision 1.0.
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __PE_IMAGE_H__
+#define __PE_IMAGE_H__
+
+//
+// PE32+ Subsystem type for EFI images
+//
+#define EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION         10
+#define EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER 11
+#define EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER      12
+#define EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER      13 ///< defined PI Specification, 1.0
+
+
+//
+// PE32+ Machine type for EFI images
+//
+#define IMAGE_FILE_MACHINE_I386            0x014c
+#define IMAGE_FILE_MACHINE_IA64            0x0200
+#define IMAGE_FILE_MACHINE_EBC             0x0EBC
+#define IMAGE_FILE_MACHINE_X64             0x8664
+#define IMAGE_FILE_MACHINE_ARMTHUMB_MIXED  0x01c2
+#define IMAGE_FILE_MACHINE_ARM64           0xAA64
+
+//
+// EXE file formats
+//
+#define EFI_IMAGE_DOS_SIGNATURE     SIGNATURE_16('M', 'Z')
+#define EFI_IMAGE_OS2_SIGNATURE     SIGNATURE_16('N', 'E')
+#define EFI_IMAGE_OS2_SIGNATURE_LE  SIGNATURE_16('L', 'E')
+#define EFI_IMAGE_NT_SIGNATURE      SIGNATURE_32('P', 'E', '\0', '\0')
+
+///
+/// PE images can start with an optional DOS header, so if an image is run
+/// under DOS it can print an error message.
+///
+typedef struct {
+  UINT16  e_magic;    ///< Magic number.
+  UINT16  e_cblp;     ///< Bytes on last page of file.
+  UINT16  e_cp;       ///< Pages in file.
+  UINT16  e_crlc;     ///< Relocations.
+  UINT16  e_cparhdr;  ///< Size of header in paragraphs.
+  UINT16  e_minalloc; ///< Minimum extra paragraphs needed.
+  UINT16  e_maxalloc; ///< Maximum extra paragraphs needed.
+  UINT16  e_ss;       ///< Initial (relative) SS value.
+  UINT16  e_sp;       ///< Initial SP value.
+  UINT16  e_csum;     ///< Checksum.
+  UINT16  e_ip;       ///< Initial IP value.
+  UINT16  e_cs;       ///< Initial (relative) CS value.
+  UINT16  e_lfarlc;   ///< File address of relocation table.
+  UINT16  e_ovno;     ///< Overlay number.
+  UINT16  e_res[4];   ///< Reserved words.
+  UINT16  e_oemid;    ///< OEM identifier (for e_oeminfo).
+  UINT16  e_oeminfo;  ///< OEM information; e_oemid specific.
+  UINT16  e_res2[10]; ///< Reserved words.
+  UINT32  e_lfanew;   ///< File address of new exe header.
+} EFI_IMAGE_DOS_HEADER;
+
+///
+/// COFF File Header (Object and Image).
+///
+typedef struct {
+  UINT16  Machine;
+  UINT16  NumberOfSections;
+  UINT32  TimeDateStamp;
+  UINT32  PointerToSymbolTable;
+  UINT32  NumberOfSymbols;
+  UINT16  SizeOfOptionalHeader;
+  UINT16  Characteristics;
+} EFI_IMAGE_FILE_HEADER;
+
+///
+/// Size of EFI_IMAGE_FILE_HEADER.
+///
+#define EFI_IMAGE_SIZEOF_FILE_HEADER        20
+
+//
+// Characteristics
+//
+#define EFI_IMAGE_FILE_RELOCS_STRIPPED      BIT0     ///< 0x0001  Relocation info stripped from file.
+#define EFI_IMAGE_FILE_EXECUTABLE_IMAGE     BIT1     ///< 0x0002  File is executable  (i.e. no unresolved externel references).
+#define EFI_IMAGE_FILE_LINE_NUMS_STRIPPED   BIT2     ///< 0x0004  Line nunbers stripped from file.
+#define EFI_IMAGE_FILE_LOCAL_SYMS_STRIPPED  BIT3     ///< 0x0008  Local symbols stripped from file.
+#define EFI_IMAGE_FILE_BYTES_REVERSED_LO    BIT7     ///< 0x0080  Bytes of machine word are reversed.
+#define EFI_IMAGE_FILE_32BIT_MACHINE        BIT8     ///< 0x0100  32 bit word machine.
+#define EFI_IMAGE_FILE_DEBUG_STRIPPED       BIT9     ///< 0x0200  Debugging info stripped from file in .DBG file.
+#define EFI_IMAGE_FILE_SYSTEM               BIT12    ///< 0x1000  System File.
+#define EFI_IMAGE_FILE_DLL                  BIT13    ///< 0x2000  File is a DLL.
+#define EFI_IMAGE_FILE_BYTES_REVERSED_HI    BIT15    ///< 0x8000  Bytes of machine word are reversed.
+
+///
+/// Header Data Directories.
+///
+typedef struct {
+  UINT32  VirtualAddress;
+  UINT32  Size;
+} EFI_IMAGE_DATA_DIRECTORY;
+
+//
+// Directory Entries
+//
+#define EFI_IMAGE_DIRECTORY_ENTRY_EXPORT      0
+#define EFI_IMAGE_DIRECTORY_ENTRY_IMPORT      1
+#define EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE    2
+#define EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION   3
+#define EFI_IMAGE_DIRECTORY_ENTRY_SECURITY    4
+#define EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC   5
+#define EFI_IMAGE_DIRECTORY_ENTRY_DEBUG       6
+#define EFI_IMAGE_DIRECTORY_ENTRY_COPYRIGHT   7
+#define EFI_IMAGE_DIRECTORY_ENTRY_GLOBALPTR   8
+#define EFI_IMAGE_DIRECTORY_ENTRY_TLS         9
+#define EFI_IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10
+
+#define EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES 16
+
+///
+/// @attention
+/// EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC means PE32 and
+/// EFI_IMAGE_OPTIONAL_HEADER32 must be used. The data structures only vary
+/// after NT additional fields.
+///
+#define EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC 0x10b
+
+///
+/// Optional Header Standard Fields for PE32.
+///
+typedef struct {
+  ///
+  /// Standard fields.
+  ///
+  UINT16                    Magic;
+  UINT8                     MajorLinkerVersion;
+  UINT8                     MinorLinkerVersion;
+  UINT32                    SizeOfCode;
+  UINT32                    SizeOfInitializedData;
+  UINT32                    SizeOfUninitializedData;
+  UINT32                    AddressOfEntryPoint;
+  UINT32                    BaseOfCode;
+  UINT32                    BaseOfData;  ///< PE32 contains this additional field, which is absent in PE32+.
+  ///
+  /// Optional Header Windows-Specific Fields.
+  ///
+  UINT32                    ImageBase;
+  UINT32                    SectionAlignment;
+  UINT32                    FileAlignment;
+  UINT16                    MajorOperatingSystemVersion;
+  UINT16                    MinorOperatingSystemVersion;
+  UINT16                    MajorImageVersion;
+  UINT16                    MinorImageVersion;
+  UINT16                    MajorSubsystemVersion;
+  UINT16                    MinorSubsystemVersion;
+  UINT32                    Win32VersionValue;
+  UINT32                    SizeOfImage;
+  UINT32                    SizeOfHeaders;
+  UINT32                    CheckSum;
+  UINT16                    Subsystem;
+  UINT16                    DllCharacteristics;
+  UINT32                    SizeOfStackReserve;
+  UINT32                    SizeOfStackCommit;
+  UINT32                    SizeOfHeapReserve;
+  UINT32                    SizeOfHeapCommit;
+  UINT32                    LoaderFlags;
+  UINT32                    NumberOfRvaAndSizes;
+  EFI_IMAGE_DATA_DIRECTORY  DataDirectory[EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES];
+} EFI_IMAGE_OPTIONAL_HEADER32;
+
+///
+/// @attention
+/// EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC means PE32+ and
+/// EFI_IMAGE_OPTIONAL_HEADER64 must be used. The data structures only vary
+/// after NT additional fields.
+///
+#define EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
+
+///
+/// Optional Header Standard Fields for PE32+.
+///
+typedef struct {
+  ///
+  /// Standard fields.
+  ///
+  UINT16                    Magic;
+  UINT8                     MajorLinkerVersion;
+  UINT8                     MinorLinkerVersion;
+  UINT32                    SizeOfCode;
+  UINT32                    SizeOfInitializedData;
+  UINT32                    SizeOfUninitializedData;
+  UINT32                    AddressOfEntryPoint;
+  UINT32                    BaseOfCode;
+  ///
+  /// Optional Header Windows-Specific Fields.
+  ///
+  UINT64                    ImageBase;
+  UINT32                    SectionAlignment;
+  UINT32                    FileAlignment;
+  UINT16                    MajorOperatingSystemVersion;
+  UINT16                    MinorOperatingSystemVersion;
+  UINT16                    MajorImageVersion;
+  UINT16                    MinorImageVersion;
+  UINT16                    MajorSubsystemVersion;
+  UINT16                    MinorSubsystemVersion;
+  UINT32                    Win32VersionValue;
+  UINT32                    SizeOfImage;
+  UINT32                    SizeOfHeaders;
+  UINT32                    CheckSum;
+  UINT16                    Subsystem;
+  UINT16                    DllCharacteristics;
+  UINT64                    SizeOfStackReserve;
+  UINT64                    SizeOfStackCommit;
+  UINT64                    SizeOfHeapReserve;
+  UINT64                    SizeOfHeapCommit;
+  UINT32                    LoaderFlags;
+  UINT32                    NumberOfRvaAndSizes;
+  EFI_IMAGE_DATA_DIRECTORY  DataDirectory[EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES];
+} EFI_IMAGE_OPTIONAL_HEADER64;
+
+
+///
+/// @attention
+/// EFI_IMAGE_NT_HEADERS32 is for use ONLY by tools.
+///
+typedef struct {
+  UINT32                      Signature;
+  EFI_IMAGE_FILE_HEADER       FileHeader;
+  EFI_IMAGE_OPTIONAL_HEADER32 OptionalHeader;
+} EFI_IMAGE_NT_HEADERS32;
+
+#define EFI_IMAGE_SIZEOF_NT_OPTIONAL32_HEADER sizeof (EFI_IMAGE_NT_HEADERS32)
+
+///
+/// @attention
+/// EFI_IMAGE_HEADERS64 is for use ONLY by tools.
+///
+typedef struct {
+  UINT32                      Signature;
+  EFI_IMAGE_FILE_HEADER       FileHeader;
+  EFI_IMAGE_OPTIONAL_HEADER64 OptionalHeader;
+} EFI_IMAGE_NT_HEADERS64;
+
+#define EFI_IMAGE_SIZEOF_NT_OPTIONAL64_HEADER sizeof (EFI_IMAGE_NT_HEADERS64)
+
+//
+// Other Windows Subsystem Values
+//
+#define EFI_IMAGE_SUBSYSTEM_UNKNOWN     0
+#define EFI_IMAGE_SUBSYSTEM_NATIVE      1
+#define EFI_IMAGE_SUBSYSTEM_WINDOWS_GUI 2
+#define EFI_IMAGE_SUBSYSTEM_WINDOWS_CUI 3
+#define EFI_IMAGE_SUBSYSTEM_OS2_CUI     5
+#define EFI_IMAGE_SUBSYSTEM_POSIX_CUI   7
+
+///
+/// Length of ShortName.
+///
+#define EFI_IMAGE_SIZEOF_SHORT_NAME 8
+
+///
+/// Section Table. This table immediately follows the optional header.
+///
+typedef struct {
+  UINT8 Name[EFI_IMAGE_SIZEOF_SHORT_NAME];
+  union {
+    UINT32  PhysicalAddress;
+    UINT32  VirtualSize;
+  } Misc;
+  UINT32  VirtualAddress;
+  UINT32  SizeOfRawData;
+  UINT32  PointerToRawData;
+  UINT32  PointerToRelocations;
+  UINT32  PointerToLinenumbers;
+  UINT16  NumberOfRelocations;
+  UINT16  NumberOfLinenumbers;
+  UINT32  Characteristics;
+} EFI_IMAGE_SECTION_HEADER;
+
+///
+/// Size of EFI_IMAGE_SECTION_HEADER.
+///
+#define EFI_IMAGE_SIZEOF_SECTION_HEADER       40
+
+//
+// Section Flags Values
+//
+#define EFI_IMAGE_SCN_TYPE_NO_PAD                  BIT3   ///< 0x00000008  ///< Reserved.
+#define EFI_IMAGE_SCN_CNT_CODE                     BIT5   ///< 0x00000020
+#define EFI_IMAGE_SCN_CNT_INITIALIZED_DATA         BIT6   ///< 0x00000040
+#define EFI_IMAGE_SCN_CNT_UNINITIALIZED_DATA       BIT7   ///< 0x00000080
+
+#define EFI_IMAGE_SCN_LNK_OTHER                    BIT8   ///< 0x00000100  ///< Reserved.
+#define EFI_IMAGE_SCN_LNK_INFO                     BIT9   ///< 0x00000200  ///< Section contains comments or some other type of information.
+#define EFI_IMAGE_SCN_LNK_REMOVE                   BIT11  ///< 0x00000800  ///< Section contents will not become part of image.
+#define EFI_IMAGE_SCN_LNK_COMDAT                   BIT12  ///< 0x00001000
+
+#define EFI_IMAGE_SCN_ALIGN_1BYTES                 BIT20  ///< 0x00100000
+#define EFI_IMAGE_SCN_ALIGN_2BYTES                 BIT21  ///< 0x00200000
+#define EFI_IMAGE_SCN_ALIGN_4BYTES          (BIT20|BIT21) ///< 0x00300000
+#define EFI_IMAGE_SCN_ALIGN_8BYTES                 BIT22  ///< 0x00400000
+#define EFI_IMAGE_SCN_ALIGN_16BYTES         (BIT20|BIT22) ///< 0x00500000
+#define EFI_IMAGE_SCN_ALIGN_32BYTES         (BIT21|BIT22) ///< 0x00600000
+#define EFI_IMAGE_SCN_ALIGN_64BYTES   (BIT20|BIT21|BIT22) ///< 0x00700000
+
+#define EFI_IMAGE_SCN_MEM_DISCARDABLE              BIT25  ///< 0x02000000
+#define EFI_IMAGE_SCN_MEM_NOT_CACHED               BIT26  ///< 0x04000000
+#define EFI_IMAGE_SCN_MEM_NOT_PAGED                BIT27  ///< 0x08000000
+#define EFI_IMAGE_SCN_MEM_SHARED                   BIT28  ///< 0x10000000
+#define EFI_IMAGE_SCN_MEM_EXECUTE                  BIT29  ///< 0x20000000
+#define EFI_IMAGE_SCN_MEM_READ                     BIT30  ///< 0x40000000
+#define EFI_IMAGE_SCN_MEM_WRITE                    BIT31  ///< 0x80000000
+
+///
+/// Size of a Symbol Table Record.
+///
+#define EFI_IMAGE_SIZEOF_SYMBOL 18
+
+//
+// Symbols have a section number of the section in which they are
+// defined. Otherwise, section numbers have the following meanings:
+//
+#define EFI_IMAGE_SYM_UNDEFINED (UINT16) 0  ///< Symbol is undefined or is common.
+#define EFI_IMAGE_SYM_ABSOLUTE  (UINT16) -1 ///< Symbol is an absolute value.
+#define EFI_IMAGE_SYM_DEBUG     (UINT16) -2 ///< Symbol is a special debug item.
+
+//
+// Symbol Type (fundamental) values.
+//
+#define EFI_IMAGE_SYM_TYPE_NULL   0   ///< no type.
+#define EFI_IMAGE_SYM_TYPE_VOID   1   ///< no valid type.
+#define EFI_IMAGE_SYM_TYPE_CHAR   2   ///< type character.
+#define EFI_IMAGE_SYM_TYPE_SHORT  3   ///< type short integer.
+#define EFI_IMAGE_SYM_TYPE_INT    4
+#define EFI_IMAGE_SYM_TYPE_LONG   5
+#define EFI_IMAGE_SYM_TYPE_FLOAT  6
+#define EFI_IMAGE_SYM_TYPE_DOUBLE 7
+#define EFI_IMAGE_SYM_TYPE_STRUCT 8
+#define EFI_IMAGE_SYM_TYPE_UNION  9
+#define EFI_IMAGE_SYM_TYPE_ENUM   10  ///< enumeration.
+#define EFI_IMAGE_SYM_TYPE_MOE    11  ///< member of enumeration.
+#define EFI_IMAGE_SYM_TYPE_BYTE   12
+#define EFI_IMAGE_SYM_TYPE_WORD   13
+#define EFI_IMAGE_SYM_TYPE_UINT   14
+#define EFI_IMAGE_SYM_TYPE_DWORD  15
+
+//
+// Symbol Type (derived) values.
+//
+#define EFI_IMAGE_SYM_DTYPE_NULL      0 ///< no derived type.
+#define EFI_IMAGE_SYM_DTYPE_POINTER   1
+#define EFI_IMAGE_SYM_DTYPE_FUNCTION  2
+#define EFI_IMAGE_SYM_DTYPE_ARRAY     3
+
+//
+// Storage classes.
+//
+#define EFI_IMAGE_SYM_CLASS_END_OF_FUNCTION   ((UINT8) -1)
+#define EFI_IMAGE_SYM_CLASS_NULL              0
+#define EFI_IMAGE_SYM_CLASS_AUTOMATIC         1
+#define EFI_IMAGE_SYM_CLASS_EXTERNAL          2
+#define EFI_IMAGE_SYM_CLASS_STATIC            3
+#define EFI_IMAGE_SYM_CLASS_REGISTER          4
+#define EFI_IMAGE_SYM_CLASS_EXTERNAL_DEF      5
+#define EFI_IMAGE_SYM_CLASS_LABEL             6
+#define EFI_IMAGE_SYM_CLASS_UNDEFINED_LABEL   7
+#define EFI_IMAGE_SYM_CLASS_MEMBER_OF_STRUCT  8
+#define EFI_IMAGE_SYM_CLASS_ARGUMENT          9
+#define EFI_IMAGE_SYM_CLASS_STRUCT_TAG        10
+#define EFI_IMAGE_SYM_CLASS_MEMBER_OF_UNION   11
+#define EFI_IMAGE_SYM_CLASS_UNION_TAG         12
+#define EFI_IMAGE_SYM_CLASS_TYPE_DEFINITION   13
+#define EFI_IMAGE_SYM_CLASS_UNDEFINED_STATIC  14
+#define EFI_IMAGE_SYM_CLASS_ENUM_TAG          15
+#define EFI_IMAGE_SYM_CLASS_MEMBER_OF_ENUM    16
+#define EFI_IMAGE_SYM_CLASS_REGISTER_PARAM    17
+#define EFI_IMAGE_SYM_CLASS_BIT_FIELD         18
+#define EFI_IMAGE_SYM_CLASS_BLOCK             100
+#define EFI_IMAGE_SYM_CLASS_FUNCTION          101
+#define EFI_IMAGE_SYM_CLASS_END_OF_STRUCT     102
+#define EFI_IMAGE_SYM_CLASS_FILE              103
+#define EFI_IMAGE_SYM_CLASS_SECTION           104
+#define EFI_IMAGE_SYM_CLASS_WEAK_EXTERNAL     105
+
+//
+// type packing constants
+//
+#define EFI_IMAGE_N_BTMASK  017
+#define EFI_IMAGE_N_TMASK   060
+#define EFI_IMAGE_N_TMASK1  0300
+#define EFI_IMAGE_N_TMASK2  0360
+#define EFI_IMAGE_N_BTSHFT  4
+#define EFI_IMAGE_N_TSHIFT  2
+
+//
+// Communal selection types.
+//
+#define EFI_IMAGE_COMDAT_SELECT_NODUPLICATES    1
+#define EFI_IMAGE_COMDAT_SELECT_ANY             2
+#define EFI_IMAGE_COMDAT_SELECT_SAME_SIZE       3
+#define EFI_IMAGE_COMDAT_SELECT_EXACT_MATCH     4
+#define EFI_IMAGE_COMDAT_SELECT_ASSOCIATIVE     5
+
+//
+// the following values only be referred in PeCoff, not defined in PECOFF.
+//
+#define EFI_IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY  1
+#define EFI_IMAGE_WEAK_EXTERN_SEARCH_LIBRARY    2
+#define EFI_IMAGE_WEAK_EXTERN_SEARCH_ALIAS      3
+
+///
+/// Relocation format.
+///
+typedef struct {
+  UINT32  VirtualAddress;
+  UINT32  SymbolTableIndex;
+  UINT16  Type;
+} EFI_IMAGE_RELOCATION;
+
+///
+/// Size of EFI_IMAGE_RELOCATION
+///
+#define EFI_IMAGE_SIZEOF_RELOCATION 10
+
+//
+// I386 relocation types.
+//
+#define EFI_IMAGE_REL_I386_ABSOLUTE 0x0000  ///< Reference is absolute, no relocation is necessary.
+#define EFI_IMAGE_REL_I386_DIR16    0x0001  ///< Direct 16-bit reference to the symbols virtual address.
+#define EFI_IMAGE_REL_I386_REL16    0x0002  ///< PC-relative 16-bit reference to the symbols virtual address.
+#define EFI_IMAGE_REL_I386_DIR32    0x0006  ///< Direct 32-bit reference to the symbols virtual address.
+#define EFI_IMAGE_REL_I386_DIR32NB  0x0007  ///< Direct 32-bit reference to the symbols virtual address, base not included.
+#define EFI_IMAGE_REL_I386_SEG12    0x0009  ///< Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address.
+#define EFI_IMAGE_REL_I386_SECTION  0x000A
+#define EFI_IMAGE_REL_I386_SECREL   0x000B
+#define EFI_IMAGE_REL_I386_REL32    0x0014  ///< PC-relative 32-bit reference to the symbols virtual address.
+
+//
+// x64 processor relocation types.
+//
+#define IMAGE_REL_AMD64_ABSOLUTE  0x0000
+#define IMAGE_REL_AMD64_ADDR64    0x0001
+#define IMAGE_REL_AMD64_ADDR32    0x0002
+#define IMAGE_REL_AMD64_ADDR32NB  0x0003
+#define IMAGE_REL_AMD64_REL32     0x0004
+#define IMAGE_REL_AMD64_REL32_1   0x0005
+#define IMAGE_REL_AMD64_REL32_2   0x0006
+#define IMAGE_REL_AMD64_REL32_3   0x0007
+#define IMAGE_REL_AMD64_REL32_4   0x0008
+#define IMAGE_REL_AMD64_REL32_5   0x0009
+#define IMAGE_REL_AMD64_SECTION   0x000A
+#define IMAGE_REL_AMD64_SECREL    0x000B
+#define IMAGE_REL_AMD64_SECREL7   0x000C
+#define IMAGE_REL_AMD64_TOKEN     0x000D
+#define IMAGE_REL_AMD64_SREL32    0x000E
+#define IMAGE_REL_AMD64_PAIR      0x000F
+#define IMAGE_REL_AMD64_SSPAN32   0x0010
+
+///
+/// Based relocation format.
+///
+typedef struct {
+  UINT32  VirtualAddress;
+  UINT32  SizeOfBlock;
+} EFI_IMAGE_BASE_RELOCATION;
+
+///
+/// Size of EFI_IMAGE_BASE_RELOCATION.
+///
+#define EFI_IMAGE_SIZEOF_BASE_RELOCATION  8
+
+//
+// Based relocation types.
+//
+#define EFI_IMAGE_REL_BASED_ABSOLUTE        0
+#define EFI_IMAGE_REL_BASED_HIGH            1
+#define EFI_IMAGE_REL_BASED_LOW             2
+#define EFI_IMAGE_REL_BASED_HIGHLOW         3
+#define EFI_IMAGE_REL_BASED_HIGHADJ         4
+#define EFI_IMAGE_REL_BASED_MIPS_JMPADDR    5
+#define EFI_IMAGE_REL_BASED_ARM_MOV32A      5
+#define EFI_IMAGE_REL_BASED_ARM_MOV32T      7
+#define EFI_IMAGE_REL_BASED_IA64_IMM64      9
+#define EFI_IMAGE_REL_BASED_MIPS_JMPADDR16  9
+#define EFI_IMAGE_REL_BASED_DIR64           10
+
+///
+/// Line number format.
+///
+typedef struct {
+  union {
+    UINT32  SymbolTableIndex; ///< Symbol table index of function name if Linenumber is 0.
+    UINT32  VirtualAddress;   ///< Virtual address of line number.
+  } Type;
+  UINT16  Linenumber;         ///< Line number.
+} EFI_IMAGE_LINENUMBER;
+
+///
+/// Size of EFI_IMAGE_LINENUMBER.
+///
+#define EFI_IMAGE_SIZEOF_LINENUMBER 6
+
+//
+// Archive format.
+//
+#define EFI_IMAGE_ARCHIVE_START_SIZE        8
+#define EFI_IMAGE_ARCHIVE_START             "!<arch>\n"
+#define EFI_IMAGE_ARCHIVE_END               "`\n"
+#define EFI_IMAGE_ARCHIVE_PAD               "\n"
+#define EFI_IMAGE_ARCHIVE_LINKER_MEMBER     "/               "
+#define EFI_IMAGE_ARCHIVE_LONGNAMES_MEMBER  "//              "
+
+///
+/// Archive Member Headers
+///
+typedef struct {
+  UINT8 Name[16];     ///< File member name - `/' terminated.
+  UINT8 Date[12];     ///< File member date - decimal.
+  UINT8 UserID[6];    ///< File member user id - decimal.
+  UINT8 GroupID[6];   ///< File member group id - decimal.
+  UINT8 Mode[8];      ///< File member mode - octal.
+  UINT8 Size[10];     ///< File member size - decimal.
+  UINT8 EndHeader[2]; ///< String to end header. (0x60 0x0A).
+} EFI_IMAGE_ARCHIVE_MEMBER_HEADER;
+
+///
+/// Size of EFI_IMAGE_ARCHIVE_MEMBER_HEADER.
+///
+#define EFI_IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR 60
+
+
+//
+// DLL Support
+//
+
+///
+/// Export Directory Table.
+///
+typedef struct {
+  UINT32  Characteristics;
+  UINT32  TimeDateStamp;
+  UINT16  MajorVersion;
+  UINT16  MinorVersion;
+  UINT32  Name;
+  UINT32  Base;
+  UINT32  NumberOfFunctions;
+  UINT32  NumberOfNames;
+  UINT32  AddressOfFunctions;
+  UINT32  AddressOfNames;
+  UINT32  AddressOfNameOrdinals;
+} EFI_IMAGE_EXPORT_DIRECTORY;
+
+///
+/// Hint/Name Table.
+///
+typedef struct {
+  UINT16  Hint;
+  UINT8   Name[1];
+} EFI_IMAGE_IMPORT_BY_NAME;
+
+///
+/// Import Address Table RVA (Thunk Table).
+///
+typedef struct {
+  union {
+    UINT32                    Function;
+    UINT32                    Ordinal;
+    EFI_IMAGE_IMPORT_BY_NAME  *AddressOfData;
+  } u1;
+} EFI_IMAGE_THUNK_DATA;
+
+#define EFI_IMAGE_ORDINAL_FLAG              BIT31    ///< Flag for PE32.
+#define EFI_IMAGE_SNAP_BY_ORDINAL(Ordinal)  ((Ordinal & EFI_IMAGE_ORDINAL_FLAG) != 0)
+#define EFI_IMAGE_ORDINAL(Ordinal)          (Ordinal & 0xffff)
+
+///
+/// Import Directory Table
+///
+typedef struct {
+  UINT32                Characteristics;
+  UINT32                TimeDateStamp;
+  UINT32                ForwarderChain;
+  UINT32                Name;
+  EFI_IMAGE_THUNK_DATA  *FirstThunk;
+} EFI_IMAGE_IMPORT_DESCRIPTOR;
+
+
+///
+/// Debug Directory Format.
+///
+typedef struct {
+  UINT32  Characteristics;
+  UINT32  TimeDateStamp;
+  UINT16  MajorVersion;
+  UINT16  MinorVersion;
+  UINT32  Type;
+  UINT32  SizeOfData;
+  UINT32  RVA;           ///< The address of the debug data when loaded, relative to the image base.
+  UINT32  FileOffset;    ///< The file pointer to the debug data.
+} EFI_IMAGE_DEBUG_DIRECTORY_ENTRY;
+
+#define EFI_IMAGE_DEBUG_TYPE_CODEVIEW 2     ///< The Visual C++ debug information.
+
+///
+/// Debug Data Structure defined in Microsoft C++.
+///
+#define CODEVIEW_SIGNATURE_NB10  SIGNATURE_32('N', 'B', '1', '0')
+typedef struct {
+  UINT32  Signature;                        ///< "NB10"
+  UINT32  Unknown;
+  UINT32  Unknown2;
+  UINT32  Unknown3;
+  //
+  // Filename of .PDB goes here
+  //
+} EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY;
+
+///
+/// Debug Data Structure defined in Microsoft C++.
+///
+#define CODEVIEW_SIGNATURE_RSDS  SIGNATURE_32('R', 'S', 'D', 'S')
+typedef struct {
+  UINT32  Signature;                        ///< "RSDS".
+  UINT32  Unknown;
+  UINT32  Unknown2;
+  UINT32  Unknown3;
+  UINT32  Unknown4;
+  UINT32  Unknown5;
+  //
+  // Filename of .PDB goes here
+  //
+} EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY;
+
+
+///
+/// Debug Data Structure defined by Apple Mach-O to Coff utility.
+///
+#define CODEVIEW_SIGNATURE_MTOC  SIGNATURE_32('M', 'T', 'O', 'C')
+typedef struct {
+  UINT32    Signature;                       ///< "MTOC".
+  GUID      MachOUuid;
+  //
+  //  Filename of .DLL (Mach-O with debug info) goes here
+  //
+} EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY;
+
+///
+/// Resource format.
+///
+typedef struct {
+  UINT32  Characteristics;
+  UINT32  TimeDateStamp;
+  UINT16  MajorVersion;
+  UINT16  MinorVersion;
+  UINT16  NumberOfNamedEntries;
+  UINT16  NumberOfIdEntries;
+  //
+  // Array of EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY entries goes here.
+  //
+} EFI_IMAGE_RESOURCE_DIRECTORY;
+
+///
+/// Resource directory entry format.
+///
+typedef struct {
+  union {
+    struct {
+      UINT32  NameOffset:31;
+      UINT32  NameIsString:1;
+    } s;
+    UINT32  Id;
+  } u1;
+  union {
+    UINT32  OffsetToData;
+    struct {
+      UINT32  OffsetToDirectory:31;
+      UINT32  DataIsDirectory:1;
+    } s;
+  } u2;
+} EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY;
+
+///
+/// Resource directory entry for string.
+///
+typedef struct {
+  UINT16  Length;
+  CHAR16  String[1];
+} EFI_IMAGE_RESOURCE_DIRECTORY_STRING;
+
+///
+/// Resource directory entry for data array.
+///
+typedef struct {
+  UINT32  OffsetToData;
+  UINT32  Size;
+  UINT32  CodePage;
+  UINT32  Reserved;
+} EFI_IMAGE_RESOURCE_DATA_ENTRY;
+
+///
+/// Header format for TE images, defined in the PI Specification, 1.0.
+///
+typedef struct {
+  UINT16                    Signature;            ///< The signature for TE format = "VZ".
+  UINT16                    Machine;              ///< From the original file header.
+  UINT8                     NumberOfSections;     ///< From the original file header.
+  UINT8                     Subsystem;            ///< From original optional header.
+  UINT16                    StrippedSize;         ///< Number of bytes we removed from the header.
+  UINT32                    AddressOfEntryPoint;  ///< Offset to entry point -- from original optional header.
+  UINT32                    BaseOfCode;           ///< From original image -- required for ITP debug.
+  UINT64                    ImageBase;            ///< From original file header.
+  EFI_IMAGE_DATA_DIRECTORY  DataDirectory[2];     ///< Only base relocation and debug directory.
+} EFI_TE_IMAGE_HEADER;
+
+
+#define EFI_TE_IMAGE_HEADER_SIGNATURE  SIGNATURE_16('V', 'Z')
+
+//
+// Data directory indexes in our TE image header
+//
+#define EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC  0
+#define EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG      1
+
+
+///
+/// Union of PE32, PE32+, and TE headers.
+///
+typedef union {
+  EFI_IMAGE_NT_HEADERS32   Pe32;
+  EFI_IMAGE_NT_HEADERS64   Pe32Plus;
+  EFI_TE_IMAGE_HEADER      Te;
+} EFI_IMAGE_OPTIONAL_HEADER_UNION;
+
+typedef union {
+  EFI_IMAGE_NT_HEADERS32            *Pe32;
+  EFI_IMAGE_NT_HEADERS64            *Pe32Plus;
+  EFI_TE_IMAGE_HEADER               *Te;
+  EFI_IMAGE_OPTIONAL_HEADER_UNION   *Union;
+} EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/ProcessorBind.h

@@ -0,0 +1,19 @@
+#ifndef _WIMBOOT_EFI_PROCESSOR_BIND_H
+#define _WIMBOOT_EFI_PROCESSOR_BIND_H
+
+/*
+ * EFI header files rely on having the CPU architecture directory
+ * present in the search path in order to pick up ProcessorBind.h.  We
+ * use this header file as a quick indirection layer.
+ *
+ */
+
+#if __i386__
+#include <efi/Ia32/ProcessorBind.h>
+#endif
+
+#if __x86_64__
+#include <efi/X64/ProcessorBind.h>
+#endif
+
+#endif /* _WIMBOOT_EFI_PROCESSOR_BIND_H */

wimboot/wimboot-2.7.3/src/efi/Protocol/BlockIo.h

@@ -0,0 +1,241 @@
+/** @file
+  Block IO protocol as defined in the UEFI 2.0 specification.
+
+  The Block IO protocol is used to abstract block devices like hard drives,
+  DVD-ROMs and floppy drives.
+
+  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __BLOCK_IO_H__
+#define __BLOCK_IO_H__
+
+#define EFI_BLOCK_IO_PROTOCOL_GUID \
+  { \
+    0x964e5b21, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct _EFI_BLOCK_IO_PROTOCOL  EFI_BLOCK_IO_PROTOCOL;
+
+///
+/// Protocol GUID name defined in EFI1.1.
+///
+#define BLOCK_IO_PROTOCOL       EFI_BLOCK_IO_PROTOCOL_GUID
+
+///
+/// Protocol defined in EFI1.1.
+///
+typedef EFI_BLOCK_IO_PROTOCOL   EFI_BLOCK_IO;
+
+/**
+  Reset the Block Device.
+
+  @param  This                 Indicates a pointer to the calling context.
+  @param  ExtendedVerification Driver may perform diagnostics on reset.
+
+  @retval EFI_SUCCESS          The device was reset.
+  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could
+                               not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_RESET)(
+  IN EFI_BLOCK_IO_PROTOCOL          *This,
+  IN BOOLEAN                        ExtendedVerification
+  );
+
+/**
+  Read BufferSize bytes from Lba into Buffer.
+
+  @param  This       Indicates a pointer to the calling context.
+  @param  MediaId    Id of the media, changes every time the media is replaced.
+  @param  Lba        The starting Logical Block Address to read from
+  @param  BufferSize Size of Buffer, must be a multiple of device block size.
+  @param  Buffer     A pointer to the destination buffer for the data. The caller is
+                     responsible for either having implicit or explicit ownership of the buffer.
+
+  @retval EFI_SUCCESS           The data was read correctly from the device.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHANGED     The MediaId does not matched the current device.
+  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
+  @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
+                                or the buffer is not on proper alignment.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_READ)(
+  IN EFI_BLOCK_IO_PROTOCOL          *This,
+  IN UINT32                         MediaId,
+  IN EFI_LBA                        Lba,
+  IN UINTN                          BufferSize,
+  OUT VOID                          *Buffer
+  );
+
+/**
+  Write BufferSize bytes from Lba into Buffer.
+
+  @param  This       Indicates a pointer to the calling context.
+  @param  MediaId    The media ID that the write request is for.
+  @param  Lba        The starting logical block address to be written. The caller is
+                     responsible for writing to only legitimate locations.
+  @param  BufferSize Size of Buffer, must be a multiple of device block size.
+  @param  Buffer     A pointer to the source buffer for the data.
+
+  @retval EFI_SUCCESS           The data was written correctly to the device.
+  @retval EFI_WRITE_PROTECTED   The device can not be written to.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
+  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
+  @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
+                                or the buffer is not on proper alignment.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_WRITE)(
+  IN EFI_BLOCK_IO_PROTOCOL          *This,
+  IN UINT32                         MediaId,
+  IN EFI_LBA                        Lba,
+  IN UINTN                          BufferSize,
+  IN VOID                           *Buffer
+  );
+
+/**
+  Flush the Block Device.
+
+  @param  This              Indicates a pointer to the calling context.
+
+  @retval EFI_SUCCESS       All outstanding data was written to the device
+  @retval EFI_DEVICE_ERROR  The device reported an error while writting back the data
+  @retval EFI_NO_MEDIA      There is no media in the device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_FLUSH)(
+  IN EFI_BLOCK_IO_PROTOCOL  *This
+  );
+
+/**
+  Block IO read only mode data and updated only via members of BlockIO
+**/
+typedef struct {
+  ///
+  /// The curent media Id. If the media changes, this value is changed.
+  ///
+  UINT32  MediaId;
+
+  ///
+  /// TRUE if the media is removable; otherwise, FALSE.
+  ///
+  BOOLEAN RemovableMedia;
+
+  ///
+  /// TRUE if there is a media currently present in the device;
+  /// othersise, FALSE. THis field shows the media present status
+  /// as of the most recent ReadBlocks() or WriteBlocks() call.
+  ///
+  BOOLEAN MediaPresent;
+
+  ///
+  /// TRUE if LBA 0 is the first block of a partition; otherwise
+  /// FALSE. For media with only one partition this would be TRUE.
+  ///
+  BOOLEAN LogicalPartition;
+
+  ///
+  /// TRUE if the media is marked read-only otherwise, FALSE.
+  /// This field shows the read-only status as of the most recent WriteBlocks () call.
+  ///
+  BOOLEAN ReadOnly;
+
+  ///
+  /// TRUE if the WriteBlock () function caches write data.
+  ///
+  BOOLEAN WriteCaching;
+
+  ///
+  /// The intrinsic block size of the device. If the media changes, then
+  /// this field is updated.
+  ///
+  UINT32  BlockSize;
+
+  ///
+  /// Supplies the alignment requirement for any buffer to read or write block(s).
+  ///
+  UINT32  IoAlign;
+
+  ///
+  /// The last logical block address on the device.
+  /// If the media changes, then this field is updated.
+  ///
+  EFI_LBA LastBlock;
+
+  ///
+  /// Only present if EFI_BLOCK_IO_PROTOCOL.Revision is greater than or equal to
+  /// EFI_BLOCK_IO_PROTOCOL_REVISION2. Returns the first LBA is aligned to
+  /// a physical block boundary.
+  ///
+  EFI_LBA LowestAlignedLba;
+
+  ///
+  /// Only present if EFI_BLOCK_IO_PROTOCOL.Revision is greater than or equal to
+  /// EFI_BLOCK_IO_PROTOCOL_REVISION2. Returns the number of logical blocks
+  /// per physical block.
+  ///
+  UINT32 LogicalBlocksPerPhysicalBlock;
+
+  ///
+  /// Only present if EFI_BLOCK_IO_PROTOCOL.Revision is greater than or equal to
+  /// EFI_BLOCK_IO_PROTOCOL_REVISION3. Returns the optimal transfer length
+  /// granularity as a number of logical blocks.
+  ///
+  UINT32 OptimalTransferLengthGranularity;
+} EFI_BLOCK_IO_MEDIA;
+
+#define EFI_BLOCK_IO_PROTOCOL_REVISION  0x00010000
+#define EFI_BLOCK_IO_PROTOCOL_REVISION2 0x00020001
+#define EFI_BLOCK_IO_PROTOCOL_REVISION3 0x00020031
+
+///
+/// Revision defined in EFI1.1.
+///
+#define EFI_BLOCK_IO_INTERFACE_REVISION   EFI_BLOCK_IO_PROTOCOL_REVISION
+
+///
+///  This protocol provides control over block devices.
+///
+struct _EFI_BLOCK_IO_PROTOCOL {
+  ///
+  /// The revision to which the block IO interface adheres. All future
+  /// revisions must be backwards compatible. If a future version is not
+  /// back wards compatible, it is not the same GUID.
+  ///
+  UINT64              Revision;
+  ///
+  /// Pointer to the EFI_BLOCK_IO_MEDIA data for this device.
+  ///
+  EFI_BLOCK_IO_MEDIA  *Media;
+
+  EFI_BLOCK_RESET     Reset;
+  EFI_BLOCK_READ      ReadBlocks;
+  EFI_BLOCK_WRITE     WriteBlocks;
+  EFI_BLOCK_FLUSH     FlushBlocks;
+
+};
+
+extern EFI_GUID gEfiBlockIoProtocolGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Protocol/GraphicsOutput.h

@@ -0,0 +1,276 @@
+/** @file
+  Graphics Output Protocol from the UEFI 2.0 specification.
+
+  Abstraction of a very simple graphics device.
+
+  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __GRAPHICS_OUTPUT_H__
+#define __GRAPHICS_OUTPUT_H__
+
+#define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID \
+  { \
+    0x9042a9de, 0x23dc, 0x4a38, {0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a } \
+  }
+
+typedef struct _EFI_GRAPHICS_OUTPUT_PROTOCOL EFI_GRAPHICS_OUTPUT_PROTOCOL;
+
+typedef struct {
+  UINT32            RedMask;
+  UINT32            GreenMask;
+  UINT32            BlueMask;
+  UINT32            ReservedMask;
+} EFI_PIXEL_BITMASK;
+
+typedef enum {
+  ///
+  /// A pixel is 32-bits and byte zero represents red, byte one represents green,
+  /// byte two represents blue, and byte three is reserved. This is the definition
+  /// for the physical frame buffer. The byte values for the red, green, and blue
+  /// components represent the color intensity. This color intensity value range
+  /// from a minimum intensity of 0 to maximum intensity of 255.
+  ///
+  PixelRedGreenBlueReserved8BitPerColor,
+  ///
+  /// A pixel is 32-bits and byte zero represents blue, byte one represents green,
+  /// byte two represents red, and byte three is reserved. This is the definition
+  /// for the physical frame buffer. The byte values for the red, green, and blue
+  /// components represent the color intensity. This color intensity value range
+  /// from a minimum intensity of 0 to maximum intensity of 255.
+  ///
+  PixelBlueGreenRedReserved8BitPerColor,
+  ///
+  /// The Pixel definition of the physical frame buffer.
+  ///
+  PixelBitMask,
+  ///
+  /// This mode does not support a physical frame buffer.
+  ///
+  PixelBltOnly,
+  ///
+  /// Valid EFI_GRAPHICS_PIXEL_FORMAT enum values are less than this value.
+  ///
+  PixelFormatMax
+} EFI_GRAPHICS_PIXEL_FORMAT;
+
+typedef struct {
+  ///
+  /// The version of this data structure. A value of zero represents the
+  /// EFI_GRAPHICS_OUTPUT_MODE_INFORMATION structure as defined in this specification.
+  ///
+  UINT32                     Version;
+  ///
+  /// The size of video screen in pixels in the X dimension.
+  ///
+  UINT32                     HorizontalResolution;
+  ///
+  /// The size of video screen in pixels in the Y dimension.
+  ///
+  UINT32                     VerticalResolution;
+  ///
+  /// Enumeration that defines the physical format of the pixel. A value of PixelBltOnly
+  /// implies that a linear frame buffer is not available for this mode.
+  ///
+  EFI_GRAPHICS_PIXEL_FORMAT  PixelFormat;
+  ///
+  /// This bit-mask is only valid if PixelFormat is set to PixelPixelBitMask.
+  /// A bit being set defines what bits are used for what purpose such as Red, Green, Blue, or Reserved.
+  ///
+  EFI_PIXEL_BITMASK          PixelInformation;
+  ///
+  /// Defines the number of pixel elements per video memory line.
+  ///
+  UINT32                     PixelsPerScanLine;
+} EFI_GRAPHICS_OUTPUT_MODE_INFORMATION;
+
+/**
+  Returns information for an available graphics mode that the graphics device
+  and the set of active video output devices supports.
+
+  @param  This                  The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
+  @param  ModeNumber            The mode number to return information on.
+  @param  SizeOfInfo            A pointer to the size, in bytes, of the Info buffer.
+  @param  Info                  A pointer to callee allocated buffer that returns information about ModeNumber.
+
+  @retval EFI_SUCCESS           Valid mode information was returned.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to retrieve the video mode.
+  @retval EFI_INVALID_PARAMETER ModeNumber is not valid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE)(
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,
+  IN  UINT32                                ModeNumber,
+  OUT UINTN                                 *SizeOfInfo,
+  OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
+  );
+
+/**
+  Set the video device into the specified mode and clears the visible portions of
+  the output display to black.
+
+  @param  This              The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
+  @param  ModeNumber        Abstraction that defines the current video mode.
+
+  @retval EFI_SUCCESS       The graphics mode specified by ModeNumber was selected.
+  @retval EFI_DEVICE_ERROR  The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED   ModeNumber is not supported by this device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE)(
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
+  IN  UINT32                       ModeNumber
+  );
+
+typedef struct {
+  UINT8 Blue;
+  UINT8 Green;
+  UINT8 Red;
+  UINT8 Reserved;
+} EFI_GRAPHICS_OUTPUT_BLT_PIXEL;
+
+typedef union {
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL Pixel;
+  UINT32                        Raw;
+} EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION;
+
+///
+/// actions for BltOperations
+///
+typedef enum {
+  ///
+  /// Write data from the BltBuffer pixel (0, 0)
+  /// directly to every pixel of the video display rectangle
+  /// (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height).
+  /// Only one pixel will be used from the BltBuffer. Delta is NOT used.
+  ///
+  EfiBltVideoFill,
+
+  ///
+  /// Read data from the video display rectangle
+  /// (SourceX, SourceY) (SourceX + Width, SourceY + Height) and place it in
+  /// the BltBuffer rectangle (DestinationX, DestinationY )
+  /// (DestinationX + Width, DestinationY + Height). If DestinationX or
+  /// DestinationY is not zero then Delta must be set to the length in bytes
+  /// of a row in the BltBuffer.
+  ///
+  EfiBltVideoToBltBuffer,
+
+  ///
+  /// Write data from the BltBuffer rectangle
+  /// (SourceX, SourceY) (SourceX + Width, SourceY + Height) directly to the
+  /// video display rectangle (DestinationX, DestinationY)
+  /// (DestinationX + Width, DestinationY + Height). If SourceX or SourceY is
+  /// not zero then Delta must be set to the length in bytes of a row in the
+  /// BltBuffer.
+  ///
+  EfiBltBufferToVideo,
+
+  ///
+  /// Copy from the video display rectangle (SourceX, SourceY)
+  /// (SourceX + Width, SourceY + Height) to the video display rectangle
+  /// (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height).
+  /// The BltBuffer and Delta are not used in this mode.
+  ///
+  EfiBltVideoToVideo,
+
+  EfiGraphicsOutputBltOperationMax
+} EFI_GRAPHICS_OUTPUT_BLT_OPERATION;
+
+/**
+  Blt a rectangle of pixels on the graphics screen. Blt stands for BLock Transfer.
+
+  @param  This         Protocol instance pointer.
+  @param  BltBuffer    The data to transfer to the graphics screen.
+                       Size is at least Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL).
+  @param  BltOperation The operation to perform when copying BltBuffer on to the graphics screen.
+  @param  SourceX      The X coordinate of source for the BltOperation.
+  @param  SourceY      The Y coordinate of source for the BltOperation.
+  @param  DestinationX The X coordinate of destination for the BltOperation.
+  @param  DestinationY The Y coordinate of destination for the BltOperation.
+  @param  Width        The width of a rectangle in the blt rectangle in pixels.
+  @param  Height       The height of a rectangle in the blt rectangle in pixels.
+  @param  Delta        Not used for EfiBltVideoFill or the EfiBltVideoToVideo operation.
+                       If a Delta of zero is used, the entire BltBuffer is being operated on.
+                       If a subrectangle of the BltBuffer is being used then Delta
+                       represents the number of bytes in a row of the BltBuffer.
+
+  @retval EFI_SUCCESS           BltBuffer was drawn to the graphics screen.
+  @retval EFI_INVALID_PARAMETER BltOperation is not valid.
+  @retval EFI_DEVICE_ERROR      The device had an error and could not complete the request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT)(
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,
+  IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL           *BltBuffer,   OPTIONAL
+  IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION       BltOperation,
+  IN  UINTN                                   SourceX,
+  IN  UINTN                                   SourceY,
+  IN  UINTN                                   DestinationX,
+  IN  UINTN                                   DestinationY,
+  IN  UINTN                                   Width,
+  IN  UINTN                                   Height,
+  IN  UINTN                                   Delta         OPTIONAL
+  );
+
+typedef struct {
+  ///
+  /// The number of modes supported by QueryMode() and SetMode().
+  ///
+  UINT32                                 MaxMode;
+  ///
+  /// Current Mode of the graphics device. Valid mode numbers are 0 to MaxMode -1.
+  ///
+  UINT32                                 Mode;
+  ///
+  /// Pointer to read-only EFI_GRAPHICS_OUTPUT_MODE_INFORMATION data.
+  ///
+  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   *Info;
+  ///
+  /// Size of Info structure in bytes.
+  ///
+  UINTN                                  SizeOfInfo;
+  ///
+  /// Base address of graphics linear frame buffer.
+  /// Offset zero in FrameBufferBase represents the upper left pixel of the display.
+  ///
+  EFI_PHYSICAL_ADDRESS                   FrameBufferBase;
+  ///
+  /// Amount of frame buffer needed to support the active mode as defined by
+  /// PixelsPerScanLine xVerticalResolution x PixelElementSize.
+  ///
+  UINTN                                  FrameBufferSize;
+} EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE;
+
+///
+/// Provides a basic abstraction to set video modes and copy pixels to and from
+/// the graphics controller's frame buffer. The linear address of the hardware
+/// frame buffer is also exposed so software can write directly to the video hardware.
+///
+struct _EFI_GRAPHICS_OUTPUT_PROTOCOL {
+  EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE  QueryMode;
+  EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE    SetMode;
+  EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT         Blt;
+  ///
+  /// Pointer to EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE data.
+  ///
+  EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE        *Mode;
+};
+
+extern EFI_GUID gEfiGraphicsOutputProtocolGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Protocol/LoadedImage.h

@@ -0,0 +1,88 @@
+/** @file
+  UEFI 2.0 Loaded image protocol definition.
+
+  Every EFI driver and application is passed an image handle when it is loaded.
+  This image handle will contain a Loaded Image Protocol.
+
+  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __LOADED_IMAGE_PROTOCOL_H__
+#define __LOADED_IMAGE_PROTOCOL_H__
+
+#define EFI_LOADED_IMAGE_PROTOCOL_GUID \
+  { \
+    0x5B1B31A1, 0x9562, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B } \
+  }
+
+#define EFI_LOADED_IMAGE_DEVICE_PATH_PROTOCOL_GUID \
+  { \
+    0xbc62157e, 0x3e33, 0x4fec, {0x99, 0x20, 0x2d, 0x3b, 0x36, 0xd7, 0x50, 0xdf } \
+  }
+
+///
+/// Protocol GUID defined in EFI1.1.
+///
+#define LOADED_IMAGE_PROTOCOL   EFI_LOADED_IMAGE_PROTOCOL_GUID
+
+///
+/// EFI_SYSTEM_TABLE & EFI_IMAGE_UNLOAD are defined in EfiApi.h
+///
+#define EFI_LOADED_IMAGE_PROTOCOL_REVISION  0x1000
+
+///
+/// Revision defined in EFI1.1.
+///
+#define EFI_LOADED_IMAGE_INFORMATION_REVISION    EFI_LOADED_IMAGE_PROTOCOL_REVISION
+
+///
+/// Can be used on any image handle to obtain information about the loaded image.
+///
+typedef struct {
+  UINT32            Revision;       ///< Defines the revision of the EFI_LOADED_IMAGE_PROTOCOL structure.
+                                    ///< All future revisions will be backward compatible to the current revision.
+  EFI_HANDLE        ParentHandle;   ///< Parent image's image handle. NULL if the image is loaded directly from
+                                    ///< the firmware's boot manager.
+  EFI_SYSTEM_TABLE  *SystemTable;   ///< the image's EFI system table pointer.
+
+  //
+  // Source location of image
+  //
+  EFI_HANDLE        DeviceHandle;   ///< The device handle that the EFI Image was loaded from.
+  EFI_DEVICE_PATH_PROTOCOL  *FilePath;  ///< A pointer to the file path portion specific to DeviceHandle
+                                        ///< that the EFI Image was loaded from.
+  VOID              *Reserved;      ///< Reserved. DO NOT USE.
+
+  //
+  // Images load options
+  //
+  UINT32            LoadOptionsSize;///< The size in bytes of LoadOptions.
+  VOID              *LoadOptions;   ///< A pointer to the image's binary load options.
+
+  //
+  // Location of where image was loaded
+  //
+  VOID              *ImageBase;     ///< The base address at which the image was loaded.
+  UINT64            ImageSize;      ///< The size in bytes of the loaded image.
+  EFI_MEMORY_TYPE   ImageCodeType;  ///< The memory type that the code sections were loaded as.
+  EFI_MEMORY_TYPE   ImageDataType;  ///< The memory type that the data sections were loaded as.
+  EFI_IMAGE_UNLOAD  Unload;
+} EFI_LOADED_IMAGE_PROTOCOL;
+
+//
+// For backward-compatible with EFI1.1.
+//
+typedef EFI_LOADED_IMAGE_PROTOCOL EFI_LOADED_IMAGE;
+
+extern EFI_GUID gEfiLoadedImageProtocolGuid;
+extern EFI_GUID gEfiLoadedImageDevicePathProtocolGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Protocol/SimpleFileSystem.h

@@ -0,0 +1,562 @@
+/** @file
+  SimpleFileSystem protocol as defined in the UEFI 2.0 specification.
+
+  The SimpleFileSystem protocol is the programmatic access to the FAT (12,16,32)
+  file system specified in UEFI 2.0. It can also be used to abstract a file
+  system other than FAT.
+
+  UEFI 2.0 can boot from any valid EFI image contained in a SimpleFileSystem.
+
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __SIMPLE_FILE_SYSTEM_H__
+#define __SIMPLE_FILE_SYSTEM_H__
+
+#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID \
+  { \
+    0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL;
+
+typedef struct _EFI_FILE_PROTOCOL         EFI_FILE_PROTOCOL;
+typedef struct _EFI_FILE_PROTOCOL         *EFI_FILE_HANDLE;
+
+///
+/// Protocol GUID name defined in EFI1.1.
+///
+#define SIMPLE_FILE_SYSTEM_PROTOCOL       EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID
+
+///
+/// Protocol name defined in EFI1.1.
+///
+typedef EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   EFI_FILE_IO_INTERFACE;
+typedef EFI_FILE_PROTOCOL                 EFI_FILE;
+
+/**
+  Open the root directory on a volume.
+
+  @param  This A pointer to the volume to open the root directory.
+  @param  Root A pointer to the location to return the opened file handle for the
+               root directory.
+
+  @retval EFI_SUCCESS          The device was opened.
+  @retval EFI_UNSUPPORTED      This volume does not support the requested file system type.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of resources.
+  @retval EFI_MEDIA_CHANGED    The device has a different medium in it or the medium is no
+                               longer supported. Any existing file handles for this volume are
+                               no longer valid. To access the files on the new medium, the
+                               volume must be reopened with OpenVolume().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME)(
+  IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL    *This,
+  OUT EFI_FILE_PROTOCOL                 **Root
+  );
+
+#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION  0x00010000
+
+///
+/// Revision defined in EFI1.1
+///
+#define EFI_FILE_IO_INTERFACE_REVISION  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION
+
+struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL {
+  ///
+  /// The version of the EFI_SIMPLE_FILE_SYSTEM_PROTOCOL. The version
+  /// specified by this specification is 0x00010000. All future revisions
+  /// must be backwards compatible.
+  ///
+  UINT64                                      Revision;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME OpenVolume;
+};
+
+/**
+  Opens a new file relative to the source file's location.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                     handle to the source location. This would typically be an open
+                     handle to a directory.
+  @param  NewHandle  A pointer to the location to return the opened handle for the new
+                     file.
+  @param  FileName   The Null-terminated string of the name of the file to be opened.
+                     The file name may contain the following path modifiers: "\", ".",
+                     and "..".
+  @param  OpenMode   The mode to open the file. The only valid combinations that the
+                     file may be opened with are: Read, Read/Write, or Create/Read/Write.
+  @param  Attributes Only valid for EFI_FILE_MODE_CREATE, in which case these are the
+                     attribute bits for the newly created file.
+
+  @retval EFI_SUCCESS          The file was opened.
+  @retval EFI_NOT_FOUND        The specified file could not be found on the device.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_MEDIA_CHANGED    The device has a different medium in it or the medium is no
+                               longer supported.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  An attempt was made to create a file, or open a file for write
+                               when the media is write-protected.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_OPEN)(
+  IN EFI_FILE_PROTOCOL        *This,
+  OUT EFI_FILE_PROTOCOL       **NewHandle,
+  IN CHAR16                   *FileName,
+  IN UINT64                   OpenMode,
+  IN UINT64                   Attributes
+  );
+
+//
+// Open modes
+//
+#define EFI_FILE_MODE_READ    0x0000000000000001ULL
+#define EFI_FILE_MODE_WRITE   0x0000000000000002ULL
+#define EFI_FILE_MODE_CREATE  0x8000000000000000ULL
+
+//
+// File attributes
+//
+#define EFI_FILE_READ_ONLY  0x0000000000000001ULL
+#define EFI_FILE_HIDDEN     0x0000000000000002ULL
+#define EFI_FILE_SYSTEM     0x0000000000000004ULL
+#define EFI_FILE_RESERVED   0x0000000000000008ULL
+#define EFI_FILE_DIRECTORY  0x0000000000000010ULL
+#define EFI_FILE_ARCHIVE    0x0000000000000020ULL
+#define EFI_FILE_VALID_ATTR 0x0000000000000037ULL
+
+/**
+  Closes a specified file handle.
+
+  @param  This          A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                        handle to close.
+
+  @retval EFI_SUCCESS   The file was closed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_CLOSE)(
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+/**
+  Close and delete the file handle.
+
+  @param  This                     A pointer to the EFI_FILE_PROTOCOL instance that is the
+                                   handle to the file to delete.
+
+  @retval EFI_SUCCESS              The file was closed and deleted, and the handle was closed.
+  @retval EFI_WARN_DELETE_FAILURE  The handle was closed, but the file was not deleted.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_DELETE)(
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+/**
+  Reads data from a file.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                     handle to read data from.
+  @param  BufferSize On input, the size of the Buffer. On output, the amount of data
+                     returned in Buffer. In both cases, the size is measured in bytes.
+  @param  Buffer     The buffer into which the data is read.
+
+  @retval EFI_SUCCESS          Data was read.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to read from a deleted file.
+  @retval EFI_DEVICE_ERROR     On entry, the current file position is beyond the end of the file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small to read the current directory
+                               entry. BufferSize has been updated with the size
+                               needed to complete the request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_READ)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT UINTN                *BufferSize,
+  OUT VOID                    *Buffer
+  );
+
+/**
+  Writes data to a file.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                     handle to write data to.
+  @param  BufferSize On input, the size of the Buffer. On output, the amount of data
+                     actually written. In both cases, the size is measured in bytes.
+  @param  Buffer     The buffer of data to write.
+
+  @retval EFI_SUCCESS          Data was written.
+  @retval EFI_UNSUPPORTED      Writes to open directory files are not supported.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to write to a deleted file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED    The file was opened read only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_WRITE)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT UINTN                *BufferSize,
+  IN VOID                     *Buffer
+  );
+
+/**
+  Sets a file's current position.
+
+  @param  This            A pointer to the EFI_FILE_PROTOCOL instance that is the
+                          file handle to set the requested position on.
+  @param  Position        The byte position from the start of the file to set.
+
+  @retval EFI_SUCCESS      The position was set.
+  @retval EFI_UNSUPPORTED  The seek request for nonzero is not valid on open
+                           directories.
+  @retval EFI_DEVICE_ERROR An attempt was made to set the position of a deleted file.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_SET_POSITION)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN UINT64                   Position
+  );
+
+/**
+  Returns a file's current position.
+
+  @param  This            A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                          handle to get the current position on.
+  @param  Position        The address to return the file's current position value.
+
+  @retval EFI_SUCCESS      The position was returned.
+  @retval EFI_UNSUPPORTED  The request is not valid on open directories.
+  @retval EFI_DEVICE_ERROR An attempt was made to get the position from a deleted file.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_GET_POSITION)(
+  IN EFI_FILE_PROTOCOL        *This,
+  OUT UINT64                  *Position
+  );
+
+/**
+  Returns information about a file.
+
+  @param  This            A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                          handle the requested information is for.
+  @param  InformationType The type identifier for the information being requested.
+  @param  BufferSize      On input, the size of Buffer. On output, the amount of data
+                          returned in Buffer. In both cases, the size is measured in bytes.
+  @param  Buffer          A pointer to the data buffer to return. The buffer's type is
+                          indicated by InformationType.
+
+  @retval EFI_SUCCESS          The information was returned.
+  @retval EFI_UNSUPPORTED      The InformationType is not known.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small to read the current directory entry.
+                               BufferSize has been updated with the size needed to complete
+                               the request.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_GET_INFO)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN EFI_GUID                 *InformationType,
+  IN OUT UINTN                *BufferSize,
+  OUT VOID                    *Buffer
+  );
+
+/**
+  Sets information about a file.
+
+  @param  File            A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                          handle the information is for.
+  @param  InformationType The type identifier for the information being set.
+  @param  BufferSize      The size, in bytes, of Buffer.
+  @param  Buffer          A pointer to the data buffer to write. The buffer's type is
+                          indicated by InformationType.
+
+  @retval EFI_SUCCESS          The information was set.
+  @retval EFI_UNSUPPORTED      The InformationType is not known.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  InformationType is EFI_FILE_INFO_ID and the media is
+                               read-only.
+  @retval EFI_WRITE_PROTECTED  InformationType is EFI_FILE_PROTOCOL_SYSTEM_INFO_ID
+                               and the media is read only.
+  @retval EFI_WRITE_PROTECTED  InformationType is EFI_FILE_SYSTEM_VOLUME_LABEL_ID
+                               and the media is read-only.
+  @retval EFI_ACCESS_DENIED    An attempt is made to change the name of a file to a
+                               file that is already present.
+  @retval EFI_ACCESS_DENIED    An attempt is being made to change the EFI_FILE_DIRECTORY
+                               Attribute.
+  @retval EFI_ACCESS_DENIED    An attempt is being made to change the size of a directory.
+  @retval EFI_ACCESS_DENIED    InformationType is EFI_FILE_INFO_ID and the file was opened
+                               read-only and an attempt is being made to modify a field
+                               other than Attribute.
+  @retval EFI_VOLUME_FULL      The volume is full.
+  @retval EFI_BAD_BUFFER_SIZE  BufferSize is smaller than the size of the type indicated
+                               by InformationType.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_SET_INFO)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN EFI_GUID                 *InformationType,
+  IN UINTN                    BufferSize,
+  IN VOID                     *Buffer
+  );
+
+/**
+  Flushes all modified data associated with a file to a device.
+
+  @param  This A pointer to the EFI_FILE_PROTOCOL instance that is the file
+               handle to flush.
+
+  @retval EFI_SUCCESS          The data was flushed.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED    The file was opened read-only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_FLUSH)(
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+typedef struct {
+  //
+  // If Event is NULL, then blocking I/O is performed.
+  // If Event is not NULL and non-blocking I/O is supported, then non-blocking I/O is performed,
+  // and Event will be signaled when the read request is completed.
+  // The caller must be prepared to handle the case where the callback associated with Event
+  // occurs before the original asynchronous I/O request call returns.
+  //
+  EFI_EVENT                   Event;
+
+  //
+  // Defines whether or not the signaled event encountered an error.
+  //
+  EFI_STATUS                  Status;
+
+  //
+  // For OpenEx():  Not Used, ignored.
+  // For ReadEx():  On input, the size of the Buffer. On output, the amount of data returned in Buffer.
+  //                In both cases, the size is measured in bytes.
+  // For WriteEx(): On input, the size of the Buffer. On output, the amount of data actually written.
+  //                In both cases, the size is measured in bytes.
+  // For FlushEx(): Not used, ignored.
+  //
+  UINTN                       BufferSize;
+
+  //
+  // For OpenEx():  Not Used, ignored.
+  // For ReadEx():  The buffer into which the data is read.
+  // For WriteEx(): The buffer of data to write.
+  // For FlushEx(): Not Used, ignored.
+  //
+  VOID                        *Buffer;
+} EFI_FILE_IO_TOKEN;
+
+/**
+  Opens a new file relative to the source directory's location.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                     handle to the source location.
+  @param  NewHandle  A pointer to the location to return the opened handle for the new
+                     file.
+  @param  FileName   The Null-terminated string of the name of the file to be opened.
+                     The file name may contain the following path modifiers: "\", ".",
+                     and "..".
+  @param  OpenMode   The mode to open the file. The only valid combinations that the
+                     file may be opened with are: Read, Read/Write, or Create/Read/Write.
+  @param  Attributes Only valid for EFI_FILE_MODE_CREATE, in which case these are the
+                     attribute bits for the newly created file.
+  @param  Token      A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS          If Event is NULL (blocking I/O): The data was read successfully.
+                               If Event is not NULL (asynchronous I/O): The request was successfully
+                                                                        queued for processing.
+  @retval EFI_NOT_FOUND        The specified file could not be found on the device.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_MEDIA_CHANGED    The device has a different medium in it or the medium is no
+                               longer supported.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  An attempt was made to create a file, or open a file for write
+                               when the media is write-protected.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_OPEN_EX)(
+  IN EFI_FILE_PROTOCOL        *This,
+  OUT EFI_FILE_PROTOCOL       **NewHandle,
+  IN CHAR16                   *FileName,
+  IN UINT64                   OpenMode,
+  IN UINT64                   Attributes,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+  );
+
+
+/**
+  Reads data from a file.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file handle to read data from.
+  @param  Token      A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS          If Event is NULL (blocking I/O): The data was read successfully.
+                               If Event is not NULL (asynchronous I/O): The request was successfully
+                                                                        queued for processing.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to read from a deleted file.
+  @retval EFI_DEVICE_ERROR     On entry, the current file position is beyond the end of the file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES Unable to queue the request due to lack of resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_READ_EX) (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+);
+
+
+/**
+  Writes data to a file.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file handle to write data to.
+  @param  Token      A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS          If Event is NULL (blocking I/O): The data was read successfully.
+                               If Event is not NULL (asynchronous I/O): The request was successfully
+                                                                        queued for processing.
+  @retval EFI_UNSUPPORTED      Writes to open directory files are not supported.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to write to a deleted file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED    The file was opened read only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+  @retval EFI_OUT_OF_RESOURCES Unable to queue the request due to lack of resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_WRITE_EX) (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+);
+
+/**
+  Flushes all modified data associated with a file to a device.
+
+  @param  This  A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                handle to flush.
+  @param  Token A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS          If Event is NULL (blocking I/O): The data was read successfully.
+                               If Event is not NULL (asynchronous I/O): The request was successfully
+                                                                        queued for processing.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED    The file was opened read-only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+  @retval EFI_OUT_OF_RESOURCES Unable to queue the request due to lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_FLUSH_EX) (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+  );
+
+#define EFI_FILE_PROTOCOL_REVISION        0x00010000
+#define EFI_FILE_PROTOCOL_REVISION2       0x00020000
+#define EFI_FILE_PROTOCOL_LATEST_REVISION EFI_FILE_PROTOCOL_REVISION2
+
+//
+// Revision defined in EFI1.1.
+//
+#define EFI_FILE_REVISION   EFI_FILE_PROTOCOL_REVISION
+
+///
+/// The EFI_FILE_PROTOCOL provides file IO access to supported file systems.
+/// An EFI_FILE_PROTOCOL provides access to a file's or directory's contents,
+/// and is also a reference to a location in the directory tree of the file system
+/// in which the file resides. With any given file handle, other files may be opened
+/// relative to this file's location, yielding new file handles.
+///
+struct _EFI_FILE_PROTOCOL {
+  ///
+  /// The version of the EFI_FILE_PROTOCOL interface. The version specified
+  /// by this specification is EFI_FILE_PROTOCOL_LATEST_REVISION.
+  /// Future versions are required to be backward compatible to version 1.0.
+  ///
+  UINT64                Revision;
+  EFI_FILE_OPEN         Open;
+  EFI_FILE_CLOSE        Close;
+  EFI_FILE_DELETE       Delete;
+  EFI_FILE_READ         Read;
+  EFI_FILE_WRITE        Write;
+  EFI_FILE_GET_POSITION GetPosition;
+  EFI_FILE_SET_POSITION SetPosition;
+  EFI_FILE_GET_INFO     GetInfo;
+  EFI_FILE_SET_INFO     SetInfo;
+  EFI_FILE_FLUSH        Flush;
+  EFI_FILE_OPEN_EX      OpenEx;
+  EFI_FILE_READ_EX      ReadEx;
+  EFI_FILE_WRITE_EX     WriteEx;
+  EFI_FILE_FLUSH_EX     FlushEx;
+};
+
+
+extern EFI_GUID gEfiSimpleFileSystemProtocolGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Protocol/SimpleTextIn.h

@@ -0,0 +1,134 @@
+/** @file
+  Simple Text Input protocol from the UEFI 2.0 specification.
+
+  Abstraction of a very simple input device like a keyboard or serial
+  terminal.
+
+  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __SIMPLE_TEXT_IN_PROTOCOL_H__
+#define __SIMPLE_TEXT_IN_PROTOCOL_H__
+
+#define EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID \
+  { \
+    0x387477c1, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL  EFI_SIMPLE_TEXT_INPUT_PROTOCOL;
+
+///
+/// Protocol GUID name defined in EFI1.1.
+///
+#define SIMPLE_INPUT_PROTOCOL   EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID
+
+///
+/// Protocol name in EFI1.1 for backward-compatible.
+///
+typedef struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL  SIMPLE_INPUT_INTERFACE;
+
+///
+/// The keystroke information for the key that was pressed.
+///
+typedef struct {
+  UINT16  ScanCode;
+  CHAR16  UnicodeChar;
+} EFI_INPUT_KEY;
+
+//
+// Required unicode control chars
+//
+#define CHAR_NULL             0x0000
+#define CHAR_BACKSPACE        0x0008
+#define CHAR_TAB              0x0009
+#define CHAR_LINEFEED         0x000A
+#define CHAR_CARRIAGE_RETURN  0x000D
+
+//
+// EFI Scan codes
+//
+#define SCAN_NULL       0x0000
+#define SCAN_UP         0x0001
+#define SCAN_DOWN       0x0002
+#define SCAN_RIGHT      0x0003
+#define SCAN_LEFT       0x0004
+#define SCAN_HOME       0x0005
+#define SCAN_END        0x0006
+#define SCAN_INSERT     0x0007
+#define SCAN_DELETE     0x0008
+#define SCAN_PAGE_UP    0x0009
+#define SCAN_PAGE_DOWN  0x000A
+#define SCAN_F1         0x000B
+#define SCAN_F2         0x000C
+#define SCAN_F3         0x000D
+#define SCAN_F4         0x000E
+#define SCAN_F5         0x000F
+#define SCAN_F6         0x0010
+#define SCAN_F7         0x0011
+#define SCAN_F8         0x0012
+#define SCAN_F9         0x0013
+#define SCAN_F10        0x0014
+#define SCAN_ESC        0x0017
+
+/**
+  Reset the input device and optionally run diagnostics
+
+  @param  This                 Protocol instance pointer.
+  @param  ExtendedVerification Driver may perform diagnostics on reset.
+
+  @retval EFI_SUCCESS          The device was reset.
+  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_RESET)(
+  IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL       *This,
+  IN BOOLEAN                              ExtendedVerification
+  );
+
+/**
+  Reads the next keystroke from the input device. The WaitForKey Event can
+  be used to test for existence of a keystroke via WaitForEvent () call.
+
+  @param  This  Protocol instance pointer.
+  @param  Key   A pointer to a buffer that is filled in with the keystroke
+                information for the key that was pressed.
+
+  @retval EFI_SUCCESS      The keystroke information was returned.
+  @retval EFI_NOT_READY    There was no keystroke data available.
+  @retval EFI_DEVICE_ERROR The keystroke information was not returned due to
+                           hardware errors.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_READ_KEY)(
+  IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL       *This,
+  OUT EFI_INPUT_KEY                       *Key
+  );
+
+///
+/// The EFI_SIMPLE_TEXT_INPUT_PROTOCOL is used on the ConsoleIn device.
+/// It is the minimum required protocol for ConsoleIn.
+///
+struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL {
+  EFI_INPUT_RESET     Reset;
+  EFI_INPUT_READ_KEY  ReadKeyStroke;
+  ///
+  /// Event to use with WaitForEvent() to wait for a key to be available
+  ///
+  EFI_EVENT           WaitForKey;
+};
+
+extern EFI_GUID gEfiSimpleTextInProtocolGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Protocol/SimpleTextInEx.h

@@ -0,0 +1,325 @@
+/** @file
+  Simple Text Input Ex protocol from the UEFI 2.0 specification.
+
+  This protocol defines an extension to the EFI_SIMPLE_TEXT_INPUT_PROTOCOL
+  which exposes much more state and modifier information from the input device,
+  also allows one to register a notification for a particular keystroke.
+
+  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __SIMPLE_TEXT_IN_EX_H__
+#define __SIMPLE_TEXT_IN_EX_H__
+
+#include "efi/Protocol/SimpleTextIn.h"
+
+#define EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID \
+  {0xdd9e7534, 0x7762, 0x4698, { 0x8c, 0x14, 0xf5, 0x85, 0x17, 0xa6, 0x25, 0xaa } }
+
+
+typedef struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL;
+
+/**
+  The Reset() function resets the input device hardware. As part
+  of initialization process, the firmware/device will make a quick
+  but reasonable attempt to verify that the device is functioning.
+  If the ExtendedVerification flag is TRUE the firmware may take
+  an extended amount of time to verify the device is operating on
+  reset. Otherwise the reset operation is to occur as quickly as
+  possible. The hardware verification process is not defined by
+  this specification and is left up to the platform firmware or
+  driver to implement.
+
+  @param This                 A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param ExtendedVerification Indicates that the driver may
+                              perform a more exhaustive
+                              verification operation of the
+                              device during reset.
+
+
+  @retval EFI_SUCCESS       The device was reset.
+
+  @retval EFI_DEVICE_ERROR  The device is not functioning
+                            correctly and could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_RESET_EX)(
+  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  IN BOOLEAN                           ExtendedVerification
+);
+
+
+///
+/// EFI_KEY_TOGGLE_STATE. The toggle states are defined.
+/// They are: EFI_TOGGLE_STATE_VALID, EFI_SCROLL_LOCK_ACTIVE
+/// EFI_NUM_LOCK_ACTIVE, EFI_CAPS_LOCK_ACTIVE
+///
+typedef UINT8 EFI_KEY_TOGGLE_STATE;
+
+typedef struct _EFI_KEY_STATE {
+  ///
+  /// Reflects the currently pressed shift
+  /// modifiers for the input device. The
+  /// returned value is valid only if the high
+  /// order bit has been set.
+  ///
+  UINT32                KeyShiftState;
+  ///
+  /// Reflects the current internal state of
+  /// various toggled attributes. The returned
+  /// value is valid only if the high order
+  /// bit has been set.
+  ///
+  EFI_KEY_TOGGLE_STATE  KeyToggleState;
+} EFI_KEY_STATE;
+
+typedef struct {
+  ///
+  /// The EFI scan code and Unicode value returned from the input device.
+  ///
+  EFI_INPUT_KEY   Key;
+  ///
+  /// The current state of various toggled attributes as well as input modifier values.
+  ///
+  EFI_KEY_STATE   KeyState;
+} EFI_KEY_DATA;
+
+//
+// Any Shift or Toggle State that is valid should have
+// high order bit set.
+//
+// Shift state
+//
+#define EFI_SHIFT_STATE_VALID     0x80000000
+#define EFI_RIGHT_SHIFT_PRESSED   0x00000001
+#define EFI_LEFT_SHIFT_PRESSED    0x00000002
+#define EFI_RIGHT_CONTROL_PRESSED 0x00000004
+#define EFI_LEFT_CONTROL_PRESSED  0x00000008
+#define EFI_RIGHT_ALT_PRESSED     0x00000010
+#define EFI_LEFT_ALT_PRESSED      0x00000020
+#define EFI_RIGHT_LOGO_PRESSED    0x00000040
+#define EFI_LEFT_LOGO_PRESSED     0x00000080
+#define EFI_MENU_KEY_PRESSED      0x00000100
+#define EFI_SYS_REQ_PRESSED       0x00000200
+
+//
+// Toggle state
+//
+#define EFI_TOGGLE_STATE_VALID    0x80
+#define EFI_KEY_STATE_EXPOSED     0x40
+#define EFI_SCROLL_LOCK_ACTIVE    0x01
+#define EFI_NUM_LOCK_ACTIVE       0x02
+#define EFI_CAPS_LOCK_ACTIVE      0x04
+
+//
+// EFI Scan codes
+//
+#define SCAN_F11                  0x0015
+#define SCAN_F12                  0x0016
+#define SCAN_PAUSE                0x0048
+#define SCAN_F13                  0x0068
+#define SCAN_F14                  0x0069
+#define SCAN_F15                  0x006A
+#define SCAN_F16                  0x006B
+#define SCAN_F17                  0x006C
+#define SCAN_F18                  0x006D
+#define SCAN_F19                  0x006E
+#define SCAN_F20                  0x006F
+#define SCAN_F21                  0x0070
+#define SCAN_F22                  0x0071
+#define SCAN_F23                  0x0072
+#define SCAN_F24                  0x0073
+#define SCAN_MUTE                 0x007F
+#define SCAN_VOLUME_UP            0x0080
+#define SCAN_VOLUME_DOWN          0x0081
+#define SCAN_BRIGHTNESS_UP        0x0100
+#define SCAN_BRIGHTNESS_DOWN      0x0101
+#define SCAN_SUSPEND              0x0102
+#define SCAN_HIBERNATE            0x0103
+#define SCAN_TOGGLE_DISPLAY       0x0104
+#define SCAN_RECOVERY             0x0105
+#define SCAN_EJECT                0x0106
+
+/**
+  The function reads the next keystroke from the input device. If
+  there is no pending keystroke the function returns
+  EFI_NOT_READY. If there is a pending keystroke, then
+  KeyData.Key.ScanCode is the EFI scan code defined in Error!
+  Reference source not found. The KeyData.Key.UnicodeChar is the
+  actual printable character or is zero if the key does not
+  represent a printable character (control key, function key,
+  etc.). The KeyData.KeyState is shift state for the character
+  reflected in KeyData.Key.UnicodeChar or KeyData.Key.ScanCode .
+  When interpreting the data from this function, it should be
+  noted that if a class of printable characters that are
+  normally adjusted by shift modifiers (e.g. Shift Key + "f"
+  key) would be presented solely as a KeyData.Key.UnicodeChar
+  without the associated shift state. So in the previous example
+  of a Shift Key + "f" key being pressed, the only pertinent
+  data returned would be KeyData.Key.UnicodeChar with the value
+  of "F". This of course would not typically be the case for
+  non-printable characters such as the pressing of the Right
+  Shift Key + F10 key since the corresponding returned data
+  would be reflected both in the KeyData.KeyState.KeyShiftState
+  and KeyData.Key.ScanCode values. UEFI drivers which implement
+  the EFI_SIMPLE_TEXT_INPUT_EX protocol are required to return
+  KeyData.Key and KeyData.KeyState values. These drivers must
+  always return the most current state of
+  KeyData.KeyState.KeyShiftState and
+  KeyData.KeyState.KeyToggleState. It should also be noted that
+  certain input devices may not be able to produce shift or toggle
+  state information, and in those cases the high order bit in the
+  respective Toggle and Shift state fields should not be active.
+
+
+  @param This     A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param KeyData  A pointer to a buffer that is filled in with
+                  the keystroke state data for the key that was
+                  pressed.
+
+
+  @retval EFI_SUCCESS     The keystroke information was
+                          returned.
+
+  @retval EFI_NOT_READY   There was no keystroke data available.
+                          EFI_DEVICE_ERROR The keystroke
+                          information was not returned due to
+                          hardware errors.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_READ_KEY_EX)(
+  IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  OUT EFI_KEY_DATA                      *KeyData
+);
+
+/**
+  The SetState() function allows the input device hardware to
+  have state settings adjusted.
+
+  @param This           A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param KeyToggleState Pointer to the EFI_KEY_TOGGLE_STATE to
+                        set the state for the input device.
+
+
+  @retval EFI_SUCCESS       The device state was set appropriately.
+
+  @retval EFI_DEVICE_ERROR  The device is not functioning
+                            correctly and could not have the
+                            setting adjusted.
+
+  @retval EFI_UNSUPPORTED   The device does not support the
+                            ability to have its state set.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_STATE)(
+  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  IN EFI_KEY_TOGGLE_STATE              *KeyToggleState
+);
+
+///
+/// The function will be called when the key sequence is typed specified by KeyData.
+///
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KEY_NOTIFY_FUNCTION)(
+  IN EFI_KEY_DATA *KeyData
+);
+
+/**
+  The RegisterKeystrokeNotify() function registers a function
+  which will be called when a specified keystroke will occur.
+
+  @param This                     A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param KeyData                  A pointer to a buffer that is filled in with
+                                  the keystroke information for the key that was
+                                  pressed.
+
+  @param KeyNotificationFunction  Points to the function to be
+                                  called when the key sequence
+                                  is typed specified by KeyData.
+
+
+  @param NotifyHandle             Points to the unique handle assigned to
+                                  the registered notification.
+
+  @retval EFI_SUCCESS           The device state was set
+                                appropriately.
+
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate necessary
+                                data structures.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_KEYSTROKE_NOTIFY)(
+  IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  IN  EFI_KEY_DATA                      *KeyData,
+  IN  EFI_KEY_NOTIFY_FUNCTION           KeyNotificationFunction,
+  OUT VOID                              **NotifyHandle
+);
+
+/**
+  The UnregisterKeystrokeNotify() function removes the
+  notification which was previously registered.
+
+  @param This               A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param NotificationHandle The handle of the notification
+                            function being unregistered.
+
+  @retval EFI_SUCCESS The device state was set appropriately.
+
+  @retval EFI_INVALID_PARAMETER The NotificationHandle is
+                                invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UNREGISTER_KEYSTROKE_NOTIFY)(
+  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
+  IN VOID                               *NotificationHandle
+);
+
+
+///
+/// The EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL is used on the ConsoleIn
+/// device. It is an extension to the Simple Text Input protocol
+/// which allows a variety of extended shift state information to be
+/// returned.
+///
+struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL{
+  EFI_INPUT_RESET_EX              Reset;
+  EFI_INPUT_READ_KEY_EX           ReadKeyStrokeEx;
+  ///
+  /// Event to use with WaitForEvent() to wait for a key to be available.
+  ///
+  EFI_EVENT                       WaitForKeyEx;
+  EFI_SET_STATE                   SetState;
+  EFI_REGISTER_KEYSTROKE_NOTIFY   RegisterKeyNotify;
+  EFI_UNREGISTER_KEYSTROKE_NOTIFY UnregisterKeyNotify;
+};
+
+
+extern EFI_GUID gEfiSimpleTextInputExProtocolGuid;
+
+#endif
+

wimboot/wimboot-2.7.3/src/efi/Protocol/SimpleTextOut.h

@@ -0,0 +1,404 @@
+/** @file
+  Simple Text Out protocol from the UEFI 2.0 specification.
+
+  Abstraction of a very simple text based output device like VGA text mode or
+  a serial terminal. The Simple Text Out protocol instance can represent
+  a single hardware device or a virtual device that is an aggregation
+  of multiple physical devices.
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __SIMPLE_TEXT_OUT_H__
+#define __SIMPLE_TEXT_OUT_H__
+
+#define EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID \
+  { \
+    0x387477c2, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+///
+/// Protocol GUID defined in EFI1.1.
+///
+#define SIMPLE_TEXT_OUTPUT_PROTOCOL   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID
+
+typedef struct _EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL;
+
+///
+/// Backward-compatible with EFI1.1.
+///
+typedef EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL   SIMPLE_TEXT_OUTPUT_INTERFACE;
+
+//
+// Define's for required EFI Unicode Box Draw characters
+//
+#define BOXDRAW_HORIZONTAL                  0x2500
+#define BOXDRAW_VERTICAL                    0x2502
+#define BOXDRAW_DOWN_RIGHT                  0x250c
+#define BOXDRAW_DOWN_LEFT                   0x2510
+#define BOXDRAW_UP_RIGHT                    0x2514
+#define BOXDRAW_UP_LEFT                     0x2518
+#define BOXDRAW_VERTICAL_RIGHT              0x251c
+#define BOXDRAW_VERTICAL_LEFT               0x2524
+#define BOXDRAW_DOWN_HORIZONTAL             0x252c
+#define BOXDRAW_UP_HORIZONTAL               0x2534
+#define BOXDRAW_VERTICAL_HORIZONTAL         0x253c
+#define BOXDRAW_DOUBLE_HORIZONTAL           0x2550
+#define BOXDRAW_DOUBLE_VERTICAL             0x2551
+#define BOXDRAW_DOWN_RIGHT_DOUBLE           0x2552
+#define BOXDRAW_DOWN_DOUBLE_RIGHT           0x2553
+#define BOXDRAW_DOUBLE_DOWN_RIGHT           0x2554
+#define BOXDRAW_DOWN_LEFT_DOUBLE            0x2555
+#define BOXDRAW_DOWN_DOUBLE_LEFT            0x2556
+#define BOXDRAW_DOUBLE_DOWN_LEFT            0x2557
+#define BOXDRAW_UP_RIGHT_DOUBLE             0x2558
+#define BOXDRAW_UP_DOUBLE_RIGHT             0x2559
+#define BOXDRAW_DOUBLE_UP_RIGHT             0x255a
+#define BOXDRAW_UP_LEFT_DOUBLE              0x255b
+#define BOXDRAW_UP_DOUBLE_LEFT              0x255c
+#define BOXDRAW_DOUBLE_UP_LEFT              0x255d
+#define BOXDRAW_VERTICAL_RIGHT_DOUBLE       0x255e
+#define BOXDRAW_VERTICAL_DOUBLE_RIGHT       0x255f
+#define BOXDRAW_DOUBLE_VERTICAL_RIGHT       0x2560
+#define BOXDRAW_VERTICAL_LEFT_DOUBLE        0x2561
+#define BOXDRAW_VERTICAL_DOUBLE_LEFT        0x2562
+#define BOXDRAW_DOUBLE_VERTICAL_LEFT        0x2563
+#define BOXDRAW_DOWN_HORIZONTAL_DOUBLE      0x2564
+#define BOXDRAW_DOWN_DOUBLE_HORIZONTAL      0x2565
+#define BOXDRAW_DOUBLE_DOWN_HORIZONTAL      0x2566
+#define BOXDRAW_UP_HORIZONTAL_DOUBLE        0x2567
+#define BOXDRAW_UP_DOUBLE_HORIZONTAL        0x2568
+#define BOXDRAW_DOUBLE_UP_HORIZONTAL        0x2569
+#define BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE  0x256a
+#define BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL  0x256b
+#define BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL  0x256c
+
+//
+// EFI Required Block Elements Code Chart
+//
+#define BLOCKELEMENT_FULL_BLOCK   0x2588
+#define BLOCKELEMENT_LIGHT_SHADE  0x2591
+
+//
+// EFI Required Geometric Shapes Code Chart
+//
+#define GEOMETRICSHAPE_UP_TRIANGLE    0x25b2
+#define GEOMETRICSHAPE_RIGHT_TRIANGLE 0x25ba
+#define GEOMETRICSHAPE_DOWN_TRIANGLE  0x25bc
+#define GEOMETRICSHAPE_LEFT_TRIANGLE  0x25c4
+
+//
+// EFI Required Arrow shapes
+//
+#define ARROW_LEFT  0x2190
+#define ARROW_UP    0x2191
+#define ARROW_RIGHT 0x2192
+#define ARROW_DOWN  0x2193
+
+//
+// EFI Console Colours
+//
+#define EFI_BLACK                 0x00
+#define EFI_BLUE                  0x01
+#define EFI_GREEN                 0x02
+#define EFI_CYAN                  (EFI_BLUE | EFI_GREEN)
+#define EFI_RED                   0x04
+#define EFI_MAGENTA               (EFI_BLUE | EFI_RED)
+#define EFI_BROWN                 (EFI_GREEN | EFI_RED)
+#define EFI_LIGHTGRAY             (EFI_BLUE | EFI_GREEN | EFI_RED)
+#define EFI_BRIGHT                0x08
+#define EFI_DARKGRAY              (EFI_BRIGHT)
+#define EFI_LIGHTBLUE             (EFI_BLUE | EFI_BRIGHT)
+#define EFI_LIGHTGREEN            (EFI_GREEN | EFI_BRIGHT)
+#define EFI_LIGHTCYAN             (EFI_CYAN | EFI_BRIGHT)
+#define EFI_LIGHTRED              (EFI_RED | EFI_BRIGHT)
+#define EFI_LIGHTMAGENTA          (EFI_MAGENTA | EFI_BRIGHT)
+#define EFI_YELLOW                (EFI_BROWN | EFI_BRIGHT)
+#define EFI_WHITE                 (EFI_BLUE | EFI_GREEN | EFI_RED | EFI_BRIGHT)
+
+#define EFI_TEXT_ATTR(f, b)       ((f) | ((b) << 4))
+
+#define EFI_BACKGROUND_BLACK      0x00
+#define EFI_BACKGROUND_BLUE       0x10
+#define EFI_BACKGROUND_GREEN      0x20
+#define EFI_BACKGROUND_CYAN       (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN)
+#define EFI_BACKGROUND_RED        0x40
+#define EFI_BACKGROUND_MAGENTA    (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_RED)
+#define EFI_BACKGROUND_BROWN      (EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED)
+#define EFI_BACKGROUND_LIGHTGRAY  (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED)
+
+//
+// We currently define attributes from 0 - 7F for color manipulations
+// To internally handle the local display characteristics for a particular character,
+// Bit 7 signifies the local glyph representation for a character.  If turned on, glyphs will be
+// pulled from the wide glyph database and will display locally as a wide character (16 X 19 versus 8 X 19)
+// If bit 7 is off, the narrow glyph database will be used.  This does NOT affect information that is sent to
+// non-local displays, such as serial or LAN consoles.
+//
+#define EFI_WIDE_ATTRIBUTE  0x80
+
+/**
+  Reset the text output device hardware and optionaly run diagnostics
+
+  @param  This                 The protocol instance pointer.
+  @param  ExtendedVerification Driver may perform more exhaustive verfication
+                               operation of the device during reset.
+
+  @retval EFI_SUCCESS          The text output device was reset.
+  @retval EFI_DEVICE_ERROR     The text output device is not functioning correctly and
+                               could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_RESET)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN BOOLEAN                                ExtendedVerification
+  );
+
+/**
+  Write a string to the output device.
+
+  @param  This   The protocol instance pointer.
+  @param  String The NULL-terminated string to be displayed on the output
+                 device(s). All output devices must also support the Unicode
+                 drawing character codes defined in this file.
+
+  @retval EFI_SUCCESS             The string was output to the device.
+  @retval EFI_DEVICE_ERROR        The device reported an error while attempting to output
+                                  the text.
+  @retval EFI_UNSUPPORTED         The output device's mode is not currently in a
+                                  defined text mode.
+  @retval EFI_WARN_UNKNOWN_GLYPH  This warning code indicates that some of the
+                                  characters in the string could not be
+                                  rendered and were skipped.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_STRING)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN CHAR16                                 *String
+  );
+
+/**
+  Verifies that all characters in a string can be output to the
+  target device.
+
+  @param  This   The protocol instance pointer.
+  @param  String The NULL-terminated string to be examined for the output
+                 device(s).
+
+  @retval EFI_SUCCESS      The device(s) are capable of rendering the output string.
+  @retval EFI_UNSUPPORTED  Some of the characters in the string cannot be
+                           rendered by one or more of the output devices mapped
+                           by the EFI handle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_TEST_STRING)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN CHAR16                                 *String
+  );
+
+/**
+  Returns information for an available text mode that the output device(s)
+  supports.
+
+  @param  This       The protocol instance pointer.
+  @param  ModeNumber The mode number to return information on.
+  @param  Columns    Returns the geometry of the text output device for the
+                     requested ModeNumber.
+  @param  Rows       Returns the geometry of the text output device for the
+                     requested ModeNumber.
+
+  @retval EFI_SUCCESS      The requested mode information was returned.
+  @retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED  The mode number was not valid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_QUERY_MODE)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN UINTN                                  ModeNumber,
+  OUT UINTN                                 *Columns,
+  OUT UINTN                                 *Rows
+  );
+
+/**
+  Sets the output device(s) to a specified mode.
+
+  @param  This       The protocol instance pointer.
+  @param  ModeNumber The mode number to set.
+
+  @retval EFI_SUCCESS      The requested text mode was set.
+  @retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED  The mode number was not valid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_MODE)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN UINTN                                  ModeNumber
+  );
+
+/**
+  Sets the background and foreground colors for the OutputString () and
+  ClearScreen () functions.
+
+  @param  This      The protocol instance pointer.
+  @param  Attribute The attribute to set. Bits 0..3 are the foreground color, and
+                    bits 4..6 are the background color. All other bits are undefined
+                    and must be zero. The valid Attributes are defined in this file.
+
+  @retval EFI_SUCCESS       The attribute was set.
+  @retval EFI_DEVICE_ERROR  The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED   The attribute requested is not defined.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_ATTRIBUTE)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN UINTN                                  Attribute
+  );
+
+/**
+  Clears the output device(s) display to the currently selected background
+  color.
+
+  @param  This              The protocol instance pointer.
+
+  @retval  EFI_SUCCESS      The operation completed successfully.
+  @retval  EFI_DEVICE_ERROR The device had an error and could not complete the request.
+  @retval  EFI_UNSUPPORTED  The output device is not in a valid text mode.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_CLEAR_SCREEN)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL   *This
+  );
+
+/**
+  Sets the current coordinates of the cursor position
+
+  @param  This        The protocol instance pointer.
+  @param  Column      The position to set the cursor to. Must be greater than or
+                      equal to zero and less than the number of columns and rows
+                      by QueryMode ().
+  @param  Row         The position to set the cursor to. Must be greater than or
+                      equal to zero and less than the number of columns and rows
+                      by QueryMode ().
+
+  @retval EFI_SUCCESS      The operation completed successfully.
+  @retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED  The output device is not in a valid text mode, or the
+                           cursor position is invalid for the current mode.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_CURSOR_POSITION)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN UINTN                                  Column,
+  IN UINTN                                  Row
+  );
+
+/**
+  Makes the cursor visible or invisible
+
+  @param  This    The protocol instance pointer.
+  @param  Visible If TRUE, the cursor is set to be visible. If FALSE, the cursor is
+                  set to be invisible.
+
+  @retval EFI_SUCCESS      The operation completed successfully.
+  @retval EFI_DEVICE_ERROR The device had an error and could not complete the
+                           request, or the device does not support changing
+                           the cursor mode.
+  @retval EFI_UNSUPPORTED  The output device is not in a valid text mode.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_ENABLE_CURSOR)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN BOOLEAN                                Visible
+  );
+
+/**
+  @par Data Structure Description:
+  Mode Structure pointed to by Simple Text Out protocol.
+**/
+typedef struct {
+  ///
+  /// The number of modes supported by QueryMode () and SetMode ().
+  ///
+  INT32   MaxMode;
+
+  //
+  // current settings
+  //
+
+  ///
+  /// The text mode of the output device(s).
+  ///
+  INT32   Mode;
+  ///
+  /// The current character output attribute.
+  ///
+  INT32   Attribute;
+  ///
+  /// The cursor's column.
+  ///
+  INT32   CursorColumn;
+  ///
+  /// The cursor's row.
+  ///
+  INT32   CursorRow;
+  ///
+  /// The cursor is currently visbile or not.
+  ///
+  BOOLEAN CursorVisible;
+} EFI_SIMPLE_TEXT_OUTPUT_MODE;
+
+///
+/// The SIMPLE_TEXT_OUTPUT protocol is used to control text-based output devices.
+/// It is the minimum required protocol for any handle supplied as the ConsoleOut
+/// or StandardError device. In addition, the minimum supported text mode of such
+/// devices is at least 80 x 25 characters.
+///
+struct _EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL {
+  EFI_TEXT_RESET                Reset;
+
+  EFI_TEXT_STRING               OutputString;
+  EFI_TEXT_TEST_STRING          TestString;
+
+  EFI_TEXT_QUERY_MODE           QueryMode;
+  EFI_TEXT_SET_MODE             SetMode;
+  EFI_TEXT_SET_ATTRIBUTE        SetAttribute;
+
+  EFI_TEXT_CLEAR_SCREEN         ClearScreen;
+  EFI_TEXT_SET_CURSOR_POSITION  SetCursorPosition;
+  EFI_TEXT_ENABLE_CURSOR        EnableCursor;
+
+  ///
+  /// Pointer to SIMPLE_TEXT_OUTPUT_MODE data.
+  ///
+  EFI_SIMPLE_TEXT_OUTPUT_MODE   *Mode;
+};
+
+extern EFI_GUID gEfiSimpleTextOutProtocolGuid;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Uefi.h

@@ -0,0 +1,27 @@
+/** @file
+
+  Root include file for Mde Package UEFI, UEFI_APPLICATION type modules.
+
+  This is the include file for any module of type UEFI and UEFI_APPLICATION. Uefi modules only use
+  types defined via this include file and can be ported easily to any
+  environment.
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __PI_UEFI_H__
+#define __PI_UEFI_H__
+
+#include "efi/Uefi/UefiBaseType.h"
+#include "efi/Uefi/UefiSpec.h"
+
+#endif
+

wimboot/wimboot-2.7.3/src/efi/Uefi/UefiBaseType.h

@@ -0,0 +1,301 @@
+/** @file
+  Defines data types and constants introduced in UEFI.
+
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR>
+
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __UEFI_BASETYPE_H__
+#define __UEFI_BASETYPE_H__
+
+#include "efi/Base.h"
+
+//
+// Basic data type definitions introduced in UEFI.
+//
+
+///
+/// 128-bit buffer containing a unique identifier value.
+///
+typedef GUID                      EFI_GUID;
+///
+/// Function return status for EFI API.
+///
+typedef RETURN_STATUS             EFI_STATUS;
+///
+/// A collection of related interfaces.
+///
+typedef VOID                      *EFI_HANDLE;
+///
+/// Handle to an event structure.
+///
+typedef VOID                      *EFI_EVENT;
+///
+/// Task priority level.
+///
+typedef UINTN                     EFI_TPL;
+///
+/// Logical block address.
+///
+typedef UINT64                    EFI_LBA;
+
+///
+/// 64-bit physical memory address.
+///
+typedef UINT64                    EFI_PHYSICAL_ADDRESS;
+
+///
+/// 64-bit virtual memory address.
+///
+typedef UINT64                    EFI_VIRTUAL_ADDRESS;
+
+///
+/// EFI Time Abstraction:
+///  Year:       1900 - 9999
+///  Month:      1 - 12
+///  Day:        1 - 31
+///  Hour:       0 - 23
+///  Minute:     0 - 59
+///  Second:     0 - 59
+///  Nanosecond: 0 - 999,999,999
+///  TimeZone:   -1440 to 1440 or 2047
+///
+typedef struct {
+  UINT16  Year;
+  UINT8   Month;
+  UINT8   Day;
+  UINT8   Hour;
+  UINT8   Minute;
+  UINT8   Second;
+  UINT8   Pad1;
+  UINT32  Nanosecond;
+  INT16   TimeZone;
+  UINT8   Daylight;
+  UINT8   Pad2;
+} EFI_TIME;
+
+
+///
+/// 4-byte buffer. An IPv4 internet protocol address.
+///
+typedef struct {
+  UINT8 Addr[4];
+} EFI_IPv4_ADDRESS;
+
+///
+/// 16-byte buffer. An IPv6 internet protocol address.
+///
+typedef struct {
+  UINT8 Addr[16];
+} EFI_IPv6_ADDRESS;
+
+///
+/// 32-byte buffer containing a network Media Access Control address.
+///
+typedef struct {
+  UINT8 Addr[32];
+} EFI_MAC_ADDRESS;
+
+///
+/// 16-byte buffer aligned on a 4-byte boundary.
+/// An IPv4 or IPv6 internet protocol address.
+///
+typedef union {
+  UINT32            Addr[4];
+  EFI_IPv4_ADDRESS  v4;
+  EFI_IPv6_ADDRESS  v6;
+} EFI_IP_ADDRESS;
+
+
+///
+/// Enumeration of EFI_STATUS.
+///@{
+#define EFI_SUCCESS               RETURN_SUCCESS
+#define EFI_LOAD_ERROR            RETURN_LOAD_ERROR
+#define EFI_INVALID_PARAMETER     RETURN_INVALID_PARAMETER
+#define EFI_UNSUPPORTED           RETURN_UNSUPPORTED
+#define EFI_BAD_BUFFER_SIZE       RETURN_BAD_BUFFER_SIZE
+#define EFI_BUFFER_TOO_SMALL      RETURN_BUFFER_TOO_SMALL
+#define EFI_NOT_READY             RETURN_NOT_READY
+#define EFI_DEVICE_ERROR          RETURN_DEVICE_ERROR
+#define EFI_WRITE_PROTECTED       RETURN_WRITE_PROTECTED
+#define EFI_OUT_OF_RESOURCES      RETURN_OUT_OF_RESOURCES
+#define EFI_VOLUME_CORRUPTED      RETURN_VOLUME_CORRUPTED
+#define EFI_VOLUME_FULL           RETURN_VOLUME_FULL
+#define EFI_NO_MEDIA              RETURN_NO_MEDIA
+#define EFI_MEDIA_CHANGED         RETURN_MEDIA_CHANGED
+#define EFI_NOT_FOUND             RETURN_NOT_FOUND
+#define EFI_ACCESS_DENIED         RETURN_ACCESS_DENIED
+#define EFI_NO_RESPONSE           RETURN_NO_RESPONSE
+#define EFI_NO_MAPPING            RETURN_NO_MAPPING
+#define EFI_TIMEOUT               RETURN_TIMEOUT
+#define EFI_NOT_STARTED           RETURN_NOT_STARTED
+#define EFI_ALREADY_STARTED       RETURN_ALREADY_STARTED
+#define EFI_ABORTED               RETURN_ABORTED
+#define EFI_ICMP_ERROR            RETURN_ICMP_ERROR
+#define EFI_TFTP_ERROR            RETURN_TFTP_ERROR
+#define EFI_PROTOCOL_ERROR        RETURN_PROTOCOL_ERROR
+#define EFI_INCOMPATIBLE_VERSION  RETURN_INCOMPATIBLE_VERSION
+#define EFI_SECURITY_VIOLATION    RETURN_SECURITY_VIOLATION
+#define EFI_CRC_ERROR             RETURN_CRC_ERROR
+#define EFI_END_OF_MEDIA          RETURN_END_OF_MEDIA
+#define EFI_END_OF_FILE           RETURN_END_OF_FILE
+#define EFI_INVALID_LANGUAGE      RETURN_INVALID_LANGUAGE
+#define EFI_COMPROMISED_DATA      RETURN_COMPROMISED_DATA
+
+#define EFI_WARN_UNKNOWN_GLYPH    RETURN_WARN_UNKNOWN_GLYPH
+#define EFI_WARN_DELETE_FAILURE   RETURN_WARN_DELETE_FAILURE
+#define EFI_WARN_WRITE_FAILURE    RETURN_WARN_WRITE_FAILURE
+#define EFI_WARN_BUFFER_TOO_SMALL RETURN_WARN_BUFFER_TOO_SMALL
+#define EFI_WARN_STALE_DATA       RETURN_WARN_STALE_DATA
+///@}
+
+///
+/// Define macro to encode the status code.
+///
+#define EFIERR(_a)                ENCODE_ERROR(_a)
+
+#define EFI_ERROR(A)              RETURN_ERROR(A)
+
+///
+/// ICMP error definitions
+///@{
+#define EFI_NETWORK_UNREACHABLE   EFIERR(100)
+#define EFI_HOST_UNREACHABLE      EFIERR(101)
+#define EFI_PROTOCOL_UNREACHABLE  EFIERR(102)
+#define EFI_PORT_UNREACHABLE      EFIERR(103)
+///@}
+
+///
+/// Tcp connection status definitions
+///@{
+#define EFI_CONNECTION_FIN        EFIERR(104)
+#define EFI_CONNECTION_RESET      EFIERR(105)
+#define EFI_CONNECTION_REFUSED    EFIERR(106)
+///@}
+
+//
+// The EFI memory allocation functions work in units of EFI_PAGEs that are
+// 4KB. This should in no way be confused with the page size of the processor.
+// An EFI_PAGE is just the quanta of memory in EFI.
+//
+#define EFI_PAGE_SIZE             SIZE_4KB
+#define EFI_PAGE_MASK             0xFFF
+#define EFI_PAGE_SHIFT            12
+
+/**
+  Macro that converts a size, in bytes, to a number of EFI_PAGESs.
+
+  @param  Size      A size in bytes.  This parameter is assumed to be type UINTN.
+                    Passing in a parameter that is larger than UINTN may produce
+                    unexpected results.
+
+  @return  The number of EFI_PAGESs associated with the number of bytes specified
+           by Size.
+
+**/
+#define EFI_SIZE_TO_PAGES(Size)  (((Size) >> EFI_PAGE_SHIFT) + (((Size) & EFI_PAGE_MASK) ? 1 : 0))
+
+/**
+  Macro that converts a number of EFI_PAGEs to a size in bytes.
+
+  @param  Pages     The number of EFI_PAGES.  This parameter is assumed to be
+                    type UINTN.  Passing in a parameter that is larger than
+                    UINTN may produce unexpected results.
+
+  @return  The number of bytes associated with the number of EFI_PAGEs specified
+           by Pages.
+
+**/
+#define EFI_PAGES_TO_SIZE(Pages)  ((Pages) << EFI_PAGE_SHIFT)
+
+///
+/// PE32+ Machine type for IA32 UEFI images.
+///
+#define EFI_IMAGE_MACHINE_IA32            0x014C
+
+///
+/// PE32+ Machine type for IA64 UEFI images.
+///
+#define EFI_IMAGE_MACHINE_IA64            0x0200
+
+///
+/// PE32+ Machine type for EBC UEFI images.
+///
+#define EFI_IMAGE_MACHINE_EBC             0x0EBC
+
+///
+/// PE32+ Machine type for X64 UEFI images.
+///
+#define EFI_IMAGE_MACHINE_X64             0x8664
+
+///
+/// PE32+ Machine type for ARM mixed ARM and Thumb/Thumb2 images.
+///
+#define EFI_IMAGE_MACHINE_ARMTHUMB_MIXED  0x01C2
+
+///
+/// PE32+ Machine type for AARCH64 A64 images.
+///
+#define EFI_IMAGE_MACHINE_AARCH64  0xAA64
+
+
+#if   defined (MDE_CPU_IA32)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_IA32) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) ((Machine) == EFI_IMAGE_MACHINE_X64)
+
+#elif defined (MDE_CPU_IPF)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_IA64) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) (FALSE)
+
+#elif defined (MDE_CPU_X64)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_X64) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) ((Machine) == EFI_IMAGE_MACHINE_IA32)
+
+#elif defined (MDE_CPU_ARM)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_ARMTHUMB_MIXED) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) ((Machine) == EFI_IMAGE_MACHINE_ARMTHUMB_MIXED)
+
+#elif defined (MDE_CPU_AARCH64)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_AARCH64) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) (FALSE)
+
+#elif defined (MDE_CPU_EBC)
+
+///
+/// This is just to make sure you can cross compile with the EBC compiler.
+/// It does not make sense to have a PE loader coded in EBC.
+///
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) ((Machine) == EFI_IMAGE_MACHINE_EBC)
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) (FALSE)
+
+#else
+#error Unknown Processor Type
+#endif
+
+#endif

wimboot/wimboot-2.7.3/src/efi/Uefi/UefiGpt.h

@@ -0,0 +1,141 @@
+/** @file
+  EFI Guid Partition Table Format Definition.
+
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __UEFI_GPT_H__
+#define __UEFI_GPT_H__
+
+///
+/// The primary GUID Partition Table Header must be
+/// located in LBA 1 (i.e., the second logical block).
+///
+#define PRIMARY_PART_HEADER_LBA 1
+///
+/// EFI Partition Table Signature: "EFI PART".
+///
+#define EFI_PTAB_HEADER_ID      SIGNATURE_64 ('E','F','I',' ','P','A','R','T')
+
+#pragma pack(1)
+
+///
+/// GPT Partition Table Header.
+///
+typedef struct {
+  ///
+  /// The table header for the GPT partition Table.
+  /// This header contains EFI_PTAB_HEADER_ID.
+  ///
+  EFI_TABLE_HEADER  Header;
+  ///
+  /// The LBA that contains this data structure.
+  ///
+  EFI_LBA           MyLBA;
+  ///
+  /// LBA address of the alternate GUID Partition Table Header.
+  ///
+  EFI_LBA           AlternateLBA;
+  ///
+  /// The first usable logical block that may be used
+  /// by a partition described by a GUID Partition Entry.
+  ///
+  EFI_LBA           FirstUsableLBA;
+  ///
+  /// The last usable logical block that may be used
+  /// by a partition described by a GUID Partition Entry.
+  ///
+  EFI_LBA           LastUsableLBA;
+  ///
+  /// GUID that can be used to uniquely identify the disk.
+  ///
+  EFI_GUID          DiskGUID;
+  ///
+  /// The starting LBA of the GUID Partition Entry array.
+  ///
+  EFI_LBA           PartitionEntryLBA;
+  ///
+  /// The number of Partition Entries in the GUID Partition Entry array.
+  ///
+  UINT32            NumberOfPartitionEntries;
+  ///
+  /// The size, in bytes, of each the GUID Partition
+  /// Entry structures in the GUID Partition Entry
+  /// array. This field shall be set to a value of 128 x 2^n where n is
+  /// an integer greater than or equal to zero (e.g., 128, 256, 512, etc.).
+  ///
+  UINT32            SizeOfPartitionEntry;
+  ///
+  /// The CRC32 of the GUID Partition Entry array.
+  /// Starts at PartitionEntryLBA and is
+  /// computed over a byte length of
+  /// NumberOfPartitionEntries * SizeOfPartitionEntry.
+  ///
+  UINT32            PartitionEntryArrayCRC32;
+} EFI_PARTITION_TABLE_HEADER;
+
+///
+/// GPT Partition Entry.
+///
+typedef struct {
+  ///
+  /// Unique ID that defines the purpose and type of this Partition. A value of
+  /// zero defines that this partition entry is not being used.
+  ///
+  EFI_GUID  PartitionTypeGUID;
+  ///
+  /// GUID that is unique for every partition entry. Every partition ever
+  /// created will have a unique GUID.
+  /// This GUID must be assigned when the GUID Partition Entry is created.
+  ///
+  EFI_GUID  UniquePartitionGUID;
+  ///
+  /// Starting LBA of the partition defined by this entry
+  ///
+  EFI_LBA   StartingLBA;
+  ///
+  /// Ending LBA of the partition defined by this entry.
+  ///
+  EFI_LBA   EndingLBA;
+  ///
+  /// Attribute bits, all bits reserved by UEFI
+  /// Bit 0:      If this bit is set, the partition is required for the platform to function. The owner/creator of the
+  ///             partition indicates that deletion or modification of the contents can result in loss of platform
+  ///             features or failure for the platform to boot or operate. The system cannot function normally if
+  ///             this partition is removed, and it should be considered part of the hardware of the system.
+  ///             Actions such as running diagnostics, system recovery, or even OS install or boot, could
+  ///             potentially stop working if this partition is removed. Unless OS software or firmware
+  ///             recognizes this partition, it should never be removed or modified as the UEFI firmware or
+  ///             platform hardware may become non-functional.
+  /// Bit 1:      If this bit is set, then firmware must not produce an EFI_BLOCK_IO_PROTOCOL device for
+  ///             this partition. By not producing an EFI_BLOCK_IO_PROTOCOL partition, file system
+  ///             mappings will not be created for this partition in UEFI.
+  /// Bit 2:      This bit is set aside to let systems with traditional PC-AT BIOS firmware implementations
+  ///             inform certain limited, special-purpose software running on these systems that a GPT
+  ///             partition may be bootable. The UEFI boot manager must ignore this bit when selecting
+  ///             a UEFI-compliant application, e.g., an OS loader.
+  /// Bits 3-47:  Undefined and must be zero. Reserved for expansion by future versions of the UEFI
+  ///             specification.
+  /// Bits 48-63: Reserved for GUID specific use. The use of these bits will vary depending on the
+  ///             PartitionTypeGUID. Only the owner of the PartitionTypeGUID is allowed
+  ///             to modify these bits. They must be preserved if Bits 0-47 are modified..
+  ///
+  UINT64    Attributes;
+  ///
+  /// Null-terminated name of the partition.
+  ///
+  CHAR16    PartitionName[36];
+} EFI_PARTITION_ENTRY;
+
+#pragma pack()
+#endif
+
+

wimboot/wimboot-2.7.3/src/efi/Uefi/UefiMultiPhase.h

@@ -0,0 +1,193 @@
+/** @file
+  This includes some definitions introduced in UEFI that will be used in both PEI and DXE phases.
+
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __UEFI_MULTIPHASE_H__
+#define __UEFI_MULTIPHASE_H__
+
+#include "efi/Guid/WinCertificate.h"
+///
+/// Enumeration of memory types introduced in UEFI.
+///
+typedef enum {
+  ///
+  /// Not used.
+  ///
+  EfiReservedMemoryType,
+  ///
+  /// The code portions of a loaded application.
+  /// (Note that UEFI OS loaders are UEFI applications.)
+  ///
+  EfiLoaderCode,
+  ///
+  /// The data portions of a loaded application and the default data allocation
+  /// type used by an application to allocate pool memory.
+  ///
+  EfiLoaderData,
+  ///
+  /// The code portions of a loaded Boot Services Driver.
+  ///
+  EfiBootServicesCode,
+  ///
+  /// The data portions of a loaded Boot Serves Driver, and the default data
+  /// allocation type used by a Boot Services Driver to allocate pool memory.
+  ///
+  EfiBootServicesData,
+  ///
+  /// The code portions of a loaded Runtime Services Driver.
+  ///
+  EfiRuntimeServicesCode,
+  ///
+  /// The data portions of a loaded Runtime Services Driver and the default
+  /// data allocation type used by a Runtime Services Driver to allocate pool memory.
+  ///
+  EfiRuntimeServicesData,
+  ///
+  /// Free (unallocated) memory.
+  ///
+  EfiConventionalMemory,
+  ///
+  /// Memory in which errors have been detected.
+  ///
+  EfiUnusableMemory,
+  ///
+  /// Memory that holds the ACPI tables.
+  ///
+  EfiACPIReclaimMemory,
+  ///
+  /// Address space reserved for use by the firmware.
+  ///
+  EfiACPIMemoryNVS,
+  ///
+  /// Used by system firmware to request that a memory-mapped IO region
+  /// be mapped by the OS to a virtual address so it can be accessed by EFI runtime services.
+  ///
+  EfiMemoryMappedIO,
+  ///
+  /// System memory-mapped IO region that is used to translate memory
+  /// cycles to IO cycles by the processor.
+  ///
+  EfiMemoryMappedIOPortSpace,
+  ///
+  /// Address space reserved by the firmware for code that is part of the processor.
+  ///
+  EfiPalCode,
+  EfiMaxMemoryType
+} EFI_MEMORY_TYPE;
+
+///
+/// Data structure that precedes all of the standard EFI table types.
+///
+typedef struct {
+  ///
+  /// A 64-bit signature that identifies the type of table that follows.
+  /// Unique signatures have been generated for the EFI System Table,
+  /// the EFI Boot Services Table, and the EFI Runtime Services Table.
+  ///
+  UINT64  Signature;
+  ///
+  /// The revision of the EFI Specification to which this table
+  /// conforms. The upper 16 bits of this field contain the major
+  /// revision value, and the lower 16 bits contain the minor revision
+  /// value. The minor revision values are limited to the range of 00..99.
+  ///
+  UINT32  Revision;
+  ///
+  /// The size, in bytes, of the entire table including the EFI_TABLE_HEADER.
+  ///
+  UINT32  HeaderSize;
+  ///
+  /// The 32-bit CRC for the entire table. This value is computed by
+  /// setting this field to 0, and computing the 32-bit CRC for HeaderSize bytes.
+  ///
+  UINT32  CRC32;
+  ///
+  /// Reserved field that must be set to 0.
+  ///
+  UINT32  Reserved;
+} EFI_TABLE_HEADER;
+
+///
+/// Attributes of variable.
+///
+#define EFI_VARIABLE_NON_VOLATILE                            0x00000001
+#define EFI_VARIABLE_BOOTSERVICE_ACCESS                      0x00000002
+#define EFI_VARIABLE_RUNTIME_ACCESS                          0x00000004
+///
+/// This attribute is identified by the mnemonic 'HR'
+/// elsewhere in this specification.
+///
+#define EFI_VARIABLE_HARDWARE_ERROR_RECORD                   0x00000008
+///
+/// Attributes of Authenticated Variable
+///
+#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS              0x00000010
+#define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS   0x00000020
+#define EFI_VARIABLE_APPEND_WRITE                            0x00000040
+
+
+///
+/// AuthInfo is a WIN_CERTIFICATE using the wCertificateType
+/// WIN_CERTIFICATE_UEFI_GUID and the CertType
+/// EFI_CERT_TYPE_RSA2048_SHA256_GUID. If the attribute specifies
+/// authenticated access, then the Data buffer should begin with an
+/// authentication descriptor prior to the data payload and DataSize
+/// should reflect the the data.and descriptor size. The caller
+/// shall digest the Monotonic Count value and the associated data
+/// for the variable update using the SHA-256 1-way hash algorithm.
+/// The ensuing the 32-byte digest will be signed using the private
+/// key associated w/ the public/private 2048-bit RSA key-pair. The
+/// WIN_CERTIFICATE shall be used to describe the signature of the
+/// Variable data *Data. In addition, the signature will also
+/// include the MonotonicCount value to guard against replay attacks.
+///
+typedef struct {
+  ///
+  /// Included in the signature of
+  /// AuthInfo.Used to ensure freshness/no
+  /// replay. Incremented during each
+  /// "Write" access.
+  ///
+  UINT64                      MonotonicCount;
+  ///
+  /// Provides the authorization for the variable
+  /// access. It is a signature across the
+  /// variable data and the  Monotonic Count
+  /// value. Caller uses Private key that is
+  /// associated with a public key that has been
+  /// provisioned via the key exchange.
+  ///
+  WIN_CERTIFICATE_UEFI_GUID   AuthInfo;
+} EFI_VARIABLE_AUTHENTICATION;
+
+///
+/// When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is
+/// set, then the Data buffer shall begin with an instance of a complete (and serialized)
+/// EFI_VARIABLE_AUTHENTICATION_2 descriptor. The descriptor shall be followed by the new
+/// variable value and DataSize shall reflect the combined size of the descriptor and the new
+/// variable value. The authentication descriptor is not part of the variable data and is not
+/// returned by subsequent calls to GetVariable().
+///
+typedef struct {
+  ///
+  /// For the TimeStamp value, components Pad1, Nanosecond, TimeZone, Daylight and
+  /// Pad2 shall be set to 0. This means that the time shall always be expressed in GMT.
+  ///
+  EFI_TIME                    TimeStamp;
+  ///
+  /// Only a CertType of  EFI_CERT_TYPE_PKCS7_GUID is accepted.
+  ///
+  WIN_CERTIFICATE_UEFI_GUID   AuthInfo;
+ } EFI_VARIABLE_AUTHENTICATION_2;
+
+#endif

wimboot/wimboot-2.7.3/src/efi/X64/ProcessorBind.h

@@ -0,0 +1,294 @@
+/** @file
+  Processor or Compiler specific defines and types x64 (Intel 64, AMD64).
+
+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __PROCESSOR_BIND_H__
+#define __PROCESSOR_BIND_H__
+
+///
+/// Define the processor type so other code can make processor based choices
+///
+#define MDE_CPU_X64
+
+//
+// Make sure we are using the correct packing rules per EFI specification
+//
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+
+#if defined(__INTEL_COMPILER)
+//
+// Disable ICC's remark #869: "Parameter" was never referenced warning.
+// This is legal ANSI C code so we disable the remark that is turned on with -Wall
+//
+#pragma warning ( disable : 869 )
+
+//
+// Disable ICC's remark #1418: external function definition with no prior declaration.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1418 )
+
+//
+// Disable ICC's remark #1419: external declaration in primary source file
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1419 )
+
+//
+// Disable ICC's remark #593: "Variable" was set but never used.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 593 )
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+
+//
+// Disable warning that make it impossible to compile at /W4
+// This only works for Microsoft* tools
+//
+
+//
+// Disabling bitfield type checking warnings.
+//
+#pragma warning ( disable : 4214 )
+
+//
+// Disabling the unreferenced formal parameter warnings.
+//
+#pragma warning ( disable : 4100 )
+
+//
+// Disable slightly different base types warning as CHAR8 * can not be set
+// to a constant string.
+//
+#pragma warning ( disable : 4057 )
+
+//
+// ASSERT(FALSE) or while (TRUE) are legal constructes so supress this warning
+//
+#pragma warning ( disable : 4127 )
+
+//
+// This warning is caused by functions defined but not used. For precompiled header only.
+//
+#pragma warning ( disable : 4505 )
+
+//
+// This warning is caused by empty (after preprocessing) source file. For precompiled header only.
+//
+#pragma warning ( disable : 4206 )
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+  //
+  // use Microsoft C complier dependent integer width types
+  //
+
+  ///
+  /// 8-byte unsigned value
+  ///
+  typedef unsigned __int64    UINT64;
+  ///
+  /// 8-byte signed value
+  ///
+  typedef __int64             INT64;
+  ///
+  /// 4-byte unsigned value
+  ///
+  typedef unsigned __int32    UINT32;
+  ///
+  /// 4-byte signed value
+  ///
+  typedef __int32             INT32;
+  ///
+  /// 2-byte unsigned value
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value
+  ///
+  typedef signed char         INT8;
+#else
+  ///
+  /// 8-byte unsigned value
+  ///
+  typedef unsigned long long  UINT64;
+  ///
+  /// 8-byte signed value
+  ///
+  typedef long long           INT64;
+  ///
+  /// 4-byte unsigned value
+  ///
+  typedef unsigned int        UINT32;
+  ///
+  /// 4-byte signed value
+  ///
+  typedef int                 INT32;
+  ///
+  /// 2-byte unsigned value
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value
+  ///
+  typedef signed char         INT8;
+#endif
+
+///
+/// Unsigned value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+///
+typedef UINT64  UINTN;
+///
+/// Signed value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+///
+typedef INT64   INTN;
+
+
+//
+// Processor specific defines
+//
+
+///
+/// A value of native width with the highest bit set.
+///
+#define MAX_BIT     0x8000000000000000ULL
+///
+/// A value of native width with the two highest bits set.
+///
+#define MAX_2_BITS  0xC000000000000000ULL
+
+///
+/// Maximum legal x64 address
+///
+#define MAX_ADDRESS   0xFFFFFFFFFFFFFFFFULL
+
+///
+/// Maximum legal x64 INTN and UINTN values.
+///
+#define MAX_INTN   ((INTN)0x7FFFFFFFFFFFFFFFULL)
+#define MAX_UINTN  ((UINTN)0xFFFFFFFFFFFFFFFFULL)
+
+///
+/// The stack alignment required for x64
+///
+#define CPU_STACK_ALIGNMENT   16
+
+//
+// Modifier to ensure that all protocol member functions and EFI intrinsics
+// use the correct C calling convention. All protocol member functions and
+// EFI intrinsics are required to modify their member functions with EFIAPI.
+//
+#ifdef EFIAPI
+  ///
+  /// If EFIAPI is already defined, then we use that definition.
+  ///
+#elif defined(_MSC_EXTENSIONS)
+  ///
+  /// Microsoft* compiler specific method for EFIAPI calling convension
+  ///
+  #define EFIAPI __cdecl
+#elif defined(__GNUC__)
+  ///
+  /// Define the standard calling convention reguardless of optimization level.
+  /// The GCC support assumes a GCC compiler that supports the EFI ABI. The EFI
+  /// ABI is much closer to the x64 Microsoft* ABI than standard x64 (x86-64)
+  /// GCC ABI. Thus a standard x64 (x86-64) GCC compiler can not be used for
+  /// x64. Warning the assembly code in the MDE x64 does not follow the correct
+  /// ABI for the standard x64 (x86-64) GCC.
+  ///
+  #define EFIAPI
+#else
+  ///
+  /// The default for a non Microsoft* or GCC compiler is to assume the EFI ABI
+  /// is the standard.
+  ///
+  #define EFIAPI
+#endif
+
+#if defined(__GNUC__)
+  ///
+  /// For GNU assembly code, .global or .globl can declare global symbols.
+  /// Define this macro to unify the usage.
+  ///
+  #define ASM_GLOBAL .globl
+#endif
+
+/**
+  Return the pointer to the first instruction of a function given a function pointer.
+  On x64 CPU architectures, these two pointer values are the same,
+  so the implementation of this macro is very simple.
+
+  @param  FunctionPointer   A pointer to a function.
+
+  @return The pointer to the first instruction of a function given a function pointer.
+
+**/
+#define FUNCTION_ENTRY_POINT(FunctionPointer) (VOID *)(UINTN)(FunctionPointer)
+
+#endif
+

wimboot/wimboot-2.7.3/src/efi/import.pl

@@ -0,0 +1,120 @@
+#!/usr/bin/perl -w
+
+=head1 NAME
+
+import.pl
+
+=head1 SYNOPSIS
+
+import.pl [options] /path/to/edk2/edk2
+
+Options:
+
+    -h,--help		Display brief help message
+    -v,--verbose	Increase verbosity
+    -q,--quiet		Decrease verbosity
+
+=cut
+
+use File::Spec::Functions qw ( :ALL );
+use File::Find;
+use File::Path;
+use Getopt::Long;
+use Pod::Usage;
+use FindBin;
+use strict;
+use warnings;
+
+my $verbosity = 0;
+
+sub try_import_file {
+  my $wimbootdir = shift;
+  my $edktop = shift;
+  my $edkdirs = shift;
+  my $filename = shift;
+
+  # Skip everything except headers
+  return unless $filename =~ /\.h$/;
+
+  # Skip files that are wimboot native headers
+  my $outfile = catfile ( $wimbootdir, $filename );
+  if ( -s $outfile ) {
+    open my $outfh, "<$outfile" or die "Could not open $outfile: $!\n";
+    my $line = <$outfh>;
+    close $outfh;
+    chomp $line;
+    return if $line =~ /^\#ifndef\s+_WIMBOOT_\S+_H$/;
+  }
+
+  # Search for importable header
+  foreach my $edkdir ( @$edkdirs ) {
+    my $infile = catfile ( $edktop, $edkdir, $filename );
+    if ( -e $infile ) {
+      # We have found a matching source file - import it
+      print "$filename <- ".catfile ( $edkdir, $filename )."\n"
+	  if $verbosity >= 1;
+      open my $infh, "<$infile" or die "Could not open $infile: $!\n";
+      ( undef, my $outdir, undef ) = splitpath ( $outfile );
+      mkpath ( $outdir );
+      open my $outfh, ">$outfile" or die "Could not open $outfile: $!\n";
+      my @dependencies = ();
+      while ( <$infh> ) {
+	# Strip CR and trailing whitespace
+	s/\r//g;
+	s/\s*$//g;
+	chomp;
+	# Update include lines, and record included files
+	if ( s/^\#include\s+[<\"](\S+)[>\"]/\#include "efi\/$1"/ ) {
+	  push @dependencies, $1;
+	}
+	# Write out line
+	print $outfh "$_\n";
+      }
+      close $outfh;
+      close $infh;
+      # Recurse to handle any included files that we don't already have
+      foreach my $dependency ( @dependencies ) {
+	if ( ! -e catfile ( $wimbootdir, $dependency ) ) {
+	  print "...following dependency on $dependency\n" if $verbosity >= 1;
+	  try_import_file ( $wimbootdir, $edktop, $edkdirs, $dependency );
+	}
+      }
+      return;
+    }
+  }
+  die "$filename has no equivalent in $edktop\n";
+}
+
+# Parse command-line options
+Getopt::Long::Configure ( 'bundling', 'auto_abbrev' );
+GetOptions (
+  'verbose|v+' => sub { $verbosity++; },
+  'quiet|q+' => sub { $verbosity--; },
+  'help|h' => sub { pod2usage ( 1 ); },
+) or die "Could not parse command-line options\n";
+pod2usage ( 1 ) unless @ARGV == 1;
+my $edktop = shift;
+
+# Identify edk import directories
+my $edkdirs = [ "MdePkg/Include", "IntelFrameworkPkg/Include",
+		"MdeModulePkg/Include", "EdkCompatibilityPkg/Foundation" ];
+foreach my $edkdir ( @$edkdirs ) {
+  die "Directory \"$edktop\" does not appear to contain the EFI EDK2 "
+      ."(missing \"$edkdir\")\n" unless -d catdir ( $edktop, $edkdir );
+}
+
+# Identify wimboot EFI includes directory
+my $wimbootdir = $FindBin::Bin;
+die "Directory \"$wimbootdir\" does not contain the wimboot EFI includes\n"
+    unless -e catfile ( $wimbootdir, "../wimboot.h" );
+
+if ( $verbosity >= 1 ) {
+  print "Importing EFI headers into $wimbootdir\nfrom ";
+  print join ( "\n and ", map { catdir ( $edktop, $_ ) } @$edkdirs )."\n";
+}
+
+# Import headers
+find ( { wanted => sub {
+  try_import_file ( $wimbootdir, $edktop, $edkdirs,
+		    abs2rel ( $_, $wimbootdir ) );
+}, no_chdir => 1 }, $wimbootdir );

wimboot/wimboot-2.7.3/src/efiblock.c

@@ -0,0 +1,307 @@
+/*
+ * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * @file
+ *
+ * EFI block device
+ *
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include "wimboot.h"
+#include "vdisk.h"
+#include "efi.h"
+#include "efipath.h"
+#include "efiblock.h"
+
+/** A block I/O device */
+struct efi_block {
+	/** EFI block I/O protocol */
+	EFI_BLOCK_IO_PROTOCOL block;
+	/** Device path */
+	EFI_DEVICE_PATH_PROTOCOL *path;
+	/** Starting LBA */
+	uint64_t lba;
+	/** Name */
+	const char *name;
+};
+
+/**
+ * Reset block I/O protocol
+ *
+ * @v this		Block I/O protocol
+ * @v extended		Perform extended verification
+ * @ret efirc		EFI status code
+ */
+static EFI_STATUS EFIAPI
+efi_reset_blocks ( EFI_BLOCK_IO_PROTOCOL *this, BOOLEAN extended ) {
+	struct efi_block *block =
+		container_of ( this, struct efi_block, block );
+	void *retaddr = __builtin_return_address ( 0 );
+
+	DBG2 ( "EFI %s %sreset -> %p\n",
+	       block->name, ( extended ? "extended " : "" ), retaddr );
+	return 0;
+}
+
+/**
+ * Read blocks
+ *
+ * @v this		Block I/O protocol
+ * @v media		Media ID
+ * @v lba		Starting LBA
+ * @v len		Length of data
+ * @v data		Data buffer
+ * @ret efirc		EFI status code
+ */
+static EFI_STATUS EFIAPI
+efi_read_blocks ( EFI_BLOCK_IO_PROTOCOL *this, UINT32 media, EFI_LBA lba,
+		  UINTN len, VOID *data ) {
+	struct efi_block *block =
+		container_of ( this, struct efi_block, block );
+	void *retaddr = __builtin_return_address ( 0 );
+
+	DBG2 ( "EFI %s read media %08x LBA %#llx to %p+%zx -> %p\n",
+	       block->name, media, lba, data, ( ( size_t ) len ), retaddr );
+	vdisk_read ( ( lba + block->lba ), ( len / VDISK_SECTOR_SIZE ), data );
+	return 0;
+}
+
+/**
+ * Write blocks
+ *
+ * @v this		Block I/O protocol
+ * @v media		Media ID
+ * @v lba		Starting LBA
+ * @v len		Length of data
+ * @v data		Data buffer
+ * @ret efirc		EFI status code
+ */
+static EFI_STATUS EFIAPI
+efi_write_blocks ( EFI_BLOCK_IO_PROTOCOL *this __unused,
+		   UINT32 media __unused, EFI_LBA lba __unused,
+		   UINTN len __unused, VOID *data __unused ) {
+	struct efi_block *block =
+		container_of ( this, struct efi_block, block );
+	void *retaddr = __builtin_return_address ( 0 );
+
+	DBG2 ( "EFI %s write media %08x LBA %#llx from %p+%zx -> %p\n",
+	       block->name, media, lba, data, ( ( size_t ) len ), retaddr );
+	return EFI_WRITE_PROTECTED;
+}
+
+/**
+ * Flush block operations
+ *
+ * @v this		Block I/O protocol
+ * @ret efirc		EFI status code
+ */
+static EFI_STATUS EFIAPI
+efi_flush_blocks ( EFI_BLOCK_IO_PROTOCOL *this ) {
+	struct efi_block *block =
+		container_of ( this, struct efi_block, block );
+	void *retaddr = __builtin_return_address ( 0 );
+
+	DBG2 ( "EFI %s flush -> %p\n", block->name, retaddr );
+	return 0;
+}
+
+/** GUID used in vendor device path */
+#define EFIBLOCK_GUID {							\
+	0x1322d197, 0x15dc, 0x4a45,					\
+	{ 0xa6, 0xa4, 0xfa, 0x57, 0x05, 0x4e, 0xa6, 0x14 }		\
+	}
+
+/**
+ * Initialise vendor device path
+ *
+ * @v name		Variable name
+ */
+#define EFIBLOCK_DEVPATH_VENDOR_INIT( name ) {				\
+	.Header = EFI_DEVPATH_INIT ( name, HARDWARE_DEVICE_PATH,	\
+				     HW_VENDOR_DP ),			\
+	.Guid = EFIBLOCK_GUID,						\
+	}
+
+/**
+ * Initialise ATA device path
+ *
+ * @v name		Variable name
+ */
+#define EFIBLOCK_DEVPATH_ATA_INIT( name ) {				\
+	.Header = EFI_DEVPATH_INIT ( name, MESSAGING_DEVICE_PATH,	\
+				     MSG_ATAPI_DP ),			\
+	.PrimarySecondary = 0,						\
+	.SlaveMaster = 0,						\
+	.Lun = 0,							\
+	}
+
+/**
+ * Initialise hard disk device path
+ *
+ * @v name		Variable name
+ */
+#define EFIBLOCK_DEVPATH_HD_INIT( name ) {				\
+	.Header = EFI_DEVPATH_INIT ( name, MEDIA_DEVICE_PATH,		\
+				     MEDIA_HARDDRIVE_DP ),		\
+	.PartitionNumber = 1,						\
+	.PartitionStart = VDISK_PARTITION_LBA,				\
+	.PartitionSize = VDISK_PARTITION_COUNT,				\
+	.Signature[0] = ( ( VDISK_MBR_SIGNATURE >> 0 ) & 0xff ),	\
+	.Signature[1] = ( ( VDISK_MBR_SIGNATURE >> 8 ) & 0xff ),	\
+	.Signature[2] = ( ( VDISK_MBR_SIGNATURE >> 16 ) & 0xff ),	\
+	.Signature[3] = ( ( VDISK_MBR_SIGNATURE >> 24 ) & 0xff ),	\
+	.MBRType = MBR_TYPE_PCAT,					\
+	.SignatureType = SIGNATURE_TYPE_MBR,				\
+	}
+
+/** Virtual disk media */
+static EFI_BLOCK_IO_MEDIA efi_vdisk_media = {
+	.MediaId = VDISK_MBR_SIGNATURE,
+	.MediaPresent = TRUE,
+	.LogicalPartition = FALSE,
+	.ReadOnly = TRUE,
+	.BlockSize = VDISK_SECTOR_SIZE,
+	.LastBlock = ( VDISK_COUNT - 1 ),
+};
+
+/** Virtual disk device path */
+static struct {
+	VENDOR_DEVICE_PATH vendor;
+	ATAPI_DEVICE_PATH ata;
+	EFI_DEVICE_PATH_PROTOCOL end;
+} __attribute__ (( packed )) efi_vdisk_path = {
+	.vendor = EFIBLOCK_DEVPATH_VENDOR_INIT ( efi_vdisk_path.vendor ),
+	.ata = EFIBLOCK_DEVPATH_ATA_INIT ( efi_vdisk_path.ata ),
+	.end = EFI_DEVPATH_END_INIT ( efi_vdisk_path.end ),
+};
+
+/** Virtual disk device */
+static struct efi_block efi_vdisk = {
+	.block = {
+		.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION,
+		.Media = &efi_vdisk_media,
+		.Reset = efi_reset_blocks,
+		.ReadBlocks = efi_read_blocks,
+		.WriteBlocks = efi_write_blocks,
+		.FlushBlocks = efi_flush_blocks,
+	},
+	.path = &efi_vdisk_path.vendor.Header,
+	.lba = 0,
+	.name = "vdisk",
+};
+
+/** Virtual partition media */
+static EFI_BLOCK_IO_MEDIA efi_vpartition_media = {
+	.MediaId = VDISK_MBR_SIGNATURE,
+	.MediaPresent = TRUE,
+	.LogicalPartition = TRUE,
+	.ReadOnly = TRUE,
+	.BlockSize = VDISK_SECTOR_SIZE,
+	.LastBlock = ( VDISK_PARTITION_COUNT - 1 ),
+};
+
+/** Virtual partition device path */
+static struct {
+	VENDOR_DEVICE_PATH vendor;
+	ATAPI_DEVICE_PATH ata;
+	HARDDRIVE_DEVICE_PATH hd;
+	EFI_DEVICE_PATH_PROTOCOL end;
+} __attribute__ (( packed )) efi_vpartition_path = {
+	.vendor = EFIBLOCK_DEVPATH_VENDOR_INIT ( efi_vpartition_path.vendor ),
+	.ata = EFIBLOCK_DEVPATH_ATA_INIT ( efi_vpartition_path.ata ),
+	.hd = EFIBLOCK_DEVPATH_HD_INIT ( efi_vpartition_path.hd ),
+	.end = EFI_DEVPATH_END_INIT ( efi_vpartition_path.end ),
+};
+
+/** Virtual partition device */
+static struct efi_block efi_vpartition = {
+	.block = {
+		.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION,
+		.Media = &efi_vpartition_media,
+		.Reset = efi_reset_blocks,
+		.ReadBlocks = efi_read_blocks,
+		.WriteBlocks = efi_write_blocks,
+		.FlushBlocks = efi_flush_blocks,
+	},
+	.path = &efi_vpartition_path.vendor.Header,
+	.lba = VDISK_PARTITION_LBA,
+	.name = "vpartition",
+};
+
+/**
+ * Install block I/O protocols
+ *
+ * @ret vdisk		New virtual disk handle
+ * @ret vpartition	New virtual partition handle
+ */
+void efi_install ( EFI_HANDLE *vdisk, EFI_HANDLE *vpartition ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	EFI_STATUS efirc;
+
+	/* Install virtual disk */
+	if ( ( efirc = bs->InstallMultipleProtocolInterfaces (
+		vdisk,
+		&efi_block_io_protocol_guid, &efi_vdisk.block,
+		&efi_device_path_protocol_guid, efi_vdisk.path,
+		NULL ) ) != 0 ) {
+		die ( "Could not install disk block I/O protocols: %#lx\n",
+		      ( ( unsigned long ) efirc ) );
+	}
+
+	/* Install virtual partition */
+	if ( ( efirc = bs->InstallMultipleProtocolInterfaces (
+		vpartition,
+		&efi_block_io_protocol_guid, &efi_vpartition.block,
+		&efi_device_path_protocol_guid, efi_vpartition.path,
+		NULL ) ) != 0 ) {
+		die ( "Could not install partition block I/O protocols: %#lx\n",
+		      ( ( unsigned long ) efirc ) );
+	}
+}
+
+/** Boot image path */
+static struct {
+	VENDOR_DEVICE_PATH vendor;
+	ATAPI_DEVICE_PATH ata;
+	HARDDRIVE_DEVICE_PATH hd;
+	struct {
+		EFI_DEVICE_PATH header;
+		CHAR16 name[ sizeof ( EFI_REMOVABLE_MEDIA_FILE_NAME ) /
+			     sizeof ( CHAR16 ) ];
+	} __attribute__ (( packed )) file;
+	EFI_DEVICE_PATH_PROTOCOL end;
+} __attribute__ (( packed )) efi_bootmgfw_path = {
+	.vendor = EFIBLOCK_DEVPATH_VENDOR_INIT ( efi_bootmgfw_path.vendor ),
+	.ata = EFIBLOCK_DEVPATH_ATA_INIT ( efi_bootmgfw_path.ata ),
+	.hd = EFIBLOCK_DEVPATH_HD_INIT ( efi_bootmgfw_path.hd ),
+	.file = {
+		.header = EFI_DEVPATH_INIT ( efi_bootmgfw_path.file,
+					     MEDIA_DEVICE_PATH,
+					     MEDIA_FILEPATH_DP ),
+		.name = EFI_REMOVABLE_MEDIA_FILE_NAME,
+	},
+	.end = EFI_DEVPATH_END_INIT ( efi_bootmgfw_path.end ),
+};
+
+/** Boot image path */
+EFI_DEVICE_PATH_PROTOCOL *bootmgfw_path = &efi_bootmgfw_path.vendor.Header;