static grub_err_t grub_freedos_boot (void) { struct grub_relocator16_state state = { .cs = GRUB_FREEDOS_SEGMENT, .ip = 0, .ds = GRUB_FREEDOS_STACK_SEGMENT, .es = 0, .fs = 0, .gs = 0, .ss = GRUB_FREEDOS_STACK_SEGMENT, .sp = GRUB_FREEDOS_STACK_POINTER, .ebp = GRUB_FREEDOS_STACK_BPB_POINTER, .ebx = ebx, .edx = ebx, .a20 = 1 }; grub_video_set_mode ("text", 0, 0); return grub_relocator16_boot (rel, state); } static grub_err_t grub_freedos_unload (void) { grub_relocator_unload (rel); rel = NULL; grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_ntldr_boot (void) { struct grub_relocator16_state state = { .cs = GRUB_NTLDR_SEGMENT, .ip = 0, .ds = 0, .es = 0, .fs = 0, .gs = 0, .ss = 0, .sp = 0x7c00, .edx = edx }; grub_video_set_mode ("text", 0, 0); return grub_relocator16_boot (rel, state); } static grub_err_t grub_ntldr_unload (void) { grub_relocator_unload (rel); rel = NULL; grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_ext2_uuid (grub_device_t device, char **uuid) { struct grub_ext2_data *data; grub_disk_t disk = device->disk; grub_dl_ref (my_mod); data = grub_ext2_mount (disk); if (data) { *uuid = grub_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x", grub_be_to_cpu16 (data->sblock.uuid[0]), grub_be_to_cpu16 (data->sblock.uuid[1]), grub_be_to_cpu16 (data->sblock.uuid[2]), grub_be_to_cpu16 (data->sblock.uuid[3]), grub_be_to_cpu16 (data->sblock.uuid[4]), grub_be_to_cpu16 (data->sblock.uuid[5]), grub_be_to_cpu16 (data->sblock.uuid[6]), grub_be_to_cpu16 (data->sblock.uuid[7])); } else *uuid = NULL; grub_dl_unref (my_mod); grub_free (data); return grub_errno; }
static grub_err_t grub_mb2_unload (void) { struct multiboot_tag_header *tag; struct multiboot_tag_header *tags = (struct multiboot_tag_header *) grub_mb2_tags; /* Free all module memory in the tag list. */ for_each_tag (tag, tags) { if (tag->key == MULTIBOOT2_TAG_MODULE) { struct multiboot_tag_module *module = (struct multiboot_tag_module *) tag; grub_free ((void *) module->addr); } } /* Allow architecture to un-reserve memory. */ grub_mb2_arch_unload (tags); /* Free the tags themselves. */ grub_mb2_tags_free (); grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_ext2_dir (grub_device_t device, const char *path, int (*hook) (const char *filename, const struct grub_dirhook_info *info)) { struct grub_ext2_data *data = 0; struct grub_fshelp_node *fdiro = 0; auto int NESTED_FUNC_ATTR iterate (const char *filename, enum grub_fshelp_filetype filetype, grub_fshelp_node_t node); int NESTED_FUNC_ATTR iterate (const char *filename, enum grub_fshelp_filetype filetype, grub_fshelp_node_t node) { struct grub_dirhook_info info; grub_memset (&info, 0, sizeof (info)); if (! node->inode_read) { grub_ext2_read_inode (data, node->ino, &node->inode); if (!grub_errno) node->inode_read = 1; grub_errno = GRUB_ERR_NONE; } if (node->inode_read) { info.mtimeset = 1; info.mtime = grub_le_to_cpu32 (node->inode.mtime); } info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR); grub_free (node); return hook (filename, &info); } grub_dl_ref (my_mod); data = grub_ext2_mount (device->disk); if (! data) goto fail; grub_fshelp_find_file (path, &data->diropen, &fdiro, grub_ext2_iterate_dir, grub_ext2_read_symlink, GRUB_FSHELP_DIR); if (grub_errno) goto fail; grub_ext2_iterate_dir (fdiro, iterate); fail: if (fdiro != &data->diropen) grub_free (fdiro); grub_free (data); grub_dl_unref (my_mod); return grub_errno; }
static grub_err_t grub_cpio_close (grub_file_t file) { grub_free (file->data); grub_dl_unref (my_mod); return grub_errno; }
static grub_err_t grub_ext2_close (grub_file_t file) { grub_free (file->data); grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_multiboot_unload (void) { grub_multiboot_free_mbi (); grub_relocator_unload (grub_multiboot_relocator); grub_multiboot_relocator = NULL; grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_linux_unload (void) { grub_free (kernel_cmdline); grub_free (kernel_addr); kernel_cmdline = 0; kernel_addr = 0; initrd_size = 0; grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_appleloader_unload (void) { grub_efi_boot_services_t *b; b = grub_efi_system_table->boot_services; efi_call_1 (b->unload_image, image_handle); grub_free (cmdline); cmdline = 0; grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_cpio_close (grub_file_t file) { struct grub_cpio_data *data; data = file->data; #ifdef MODE_USTAR grub_free (data->linkname); #endif grub_free (data); grub_dl_unref (my_mod); return grub_errno; }
static grub_err_t grub_linuxefi_unload (void) { grub_dl_unref (my_mod); loaded = 0; if (initrd_mem) grub_efi_free_pages((grub_efi_physical_address_t)initrd_mem, BYTES_TO_PAGES(params->ramdisk_size)); if (linux_cmdline) grub_efi_free_pages((grub_efi_physical_address_t)linux_cmdline, BYTES_TO_PAGES(params->cmdline_size + 1)); if (kernel_mem) grub_efi_free_pages((grub_efi_physical_address_t)kernel_mem, BYTES_TO_PAGES(kernel_size)); if (params) grub_efi_free_pages((grub_efi_physical_address_t)params, BYTES_TO_PAGES(16384)); return GRUB_ERR_NONE; }
/* Open a file named NAME and initialize FILE. */ static grub_err_t grub_ext2_open (struct grub_file *file, const char *name) { struct grub_ext2_data *data; struct grub_fshelp_node *fdiro = 0; grub_err_t err; grub_dl_ref (my_mod); data = grub_ext2_mount (file->device->disk); if (! data) { err = grub_errno; goto fail; } err = grub_fshelp_find_file (name, &data->diropen, &fdiro, grub_ext2_iterate_dir, grub_ext2_read_symlink, GRUB_FSHELP_REG); if (err) goto fail; if (! fdiro->inode_read) { err = grub_ext2_read_inode (data, fdiro->ino, &fdiro->inode); if (err) goto fail; } grub_memcpy (data->inode, &fdiro->inode, sizeof (struct grub_ext2_inode)); grub_free (fdiro); file->size = grub_le_to_cpu32 (data->inode->size); file->data = data; file->offset = 0; return 0; fail: if (fdiro != &data->diropen) grub_free (fdiro); grub_free (data); grub_dl_unref (my_mod); return err; }
static grub_err_t grub_ext2_label (grub_device_t device, char **label) { struct grub_ext2_data *data; grub_disk_t disk = device->disk; grub_dl_ref (my_mod); data = grub_ext2_mount (disk); if (data) *label = grub_strndup (data->sblock.volume_name, 14); else *label = NULL; grub_dl_unref (my_mod); grub_free (data); return grub_errno; }
/* Get mtime. */ static grub_err_t grub_ext2_mtime (grub_device_t device, grub_int32_t *tm) { struct grub_ext2_data *data; grub_disk_t disk = device->disk; grub_dl_ref (my_mod); data = grub_ext2_mount (disk); if (!data) *tm = 0; else *tm = grub_le_to_cpu32 (data->sblock.utime); grub_dl_unref (my_mod); grub_free (data); return grub_errno; }
static grub_err_t grub_ext2_dir (grub_device_t device, const char *path, int (*hook) (const char *filename, const struct grub_dirhook_info *info, void *closure), void *closure) { struct grub_ext2_data *data = 0; struct grub_fshelp_node *fdiro = 0; struct grub_ext2_dir_closure c; grub_dl_ref (my_mod); data = grub_ext2_mount (device->disk); if (! data) goto fail; grub_fshelp_find_file (path, &data->diropen, &fdiro, grub_ext2_iterate_dir, 0, grub_ext2_read_symlink, GRUB_FSHELP_DIR); if (grub_errno) goto fail; c.hook = hook; c.closure = closure; c.data = data; grub_ext2_iterate_dir (fdiro, iterate, &c); fail: if (fdiro != &data->diropen) grub_free (fdiro); grub_free (data); grub_dl_unref (my_mod); return grub_errno; }
static grub_err_t grub_pxechain_boot (void) { struct grub_relocator16_state state = { .cs = 0, .ip = 0x7c00, .ds = 0, .es = 0, .fs = 0, .gs = 0, .ss = 0, .sp = 0x7c00, .edx = edx }; struct grub_net_bootp_packet *bp; bp = grub_pxe_get_cached (GRUB_PXENV_PACKET_TYPE_DHCP_ACK); grub_video_set_mode ("text", 0, 0); if (bp && boot_file[0]) grub_memcpy (bp->boot_file, boot_file, sizeof (bp->boot_file)); if (bp && server_name[0]) grub_memcpy (bp->server_name, server_name, sizeof (bp->server_name)); return grub_relocator16_boot (rel, state); } static grub_err_t grub_pxechain_unload (void) { grub_relocator_unload (rel); rel = NULL; grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_cpio_dir (grub_device_t device, const char *path, int (*hook) (const char *filename, const struct grub_dirhook_info *info)) { struct grub_cpio_data *data; grub_uint32_t ofs; char *prev, *name; const char *np; int len; grub_dl_ref (my_mod); prev = 0; data = grub_cpio_mount (device->disk); if (!data) goto fail; np = path + 1; len = grub_strlen (path) - 1; data->hofs = 0; while (1) { if (grub_cpio_find_file (data, &name, &ofs)) goto fail; if (!ofs) break; if (grub_memcmp (np, name, len) == 0) { char *p, *n; n = name + len; if (*n == '/') n++; p = grub_strchr (name + len, '/'); if (p) *p = 0; if ((!prev) || (grub_strcmp (prev, name) != 0)) { struct grub_dirhook_info info; grub_memset (&info, 0, sizeof (info)); info.dir = (p != NULL); hook (name + len, &info); if (prev) grub_free (prev); prev = name; } else grub_free (name); } data->hofs = ofs; } fail: if (prev) grub_free (prev); if (data) grub_free (data); grub_dl_unref (my_mod); return grub_errno; }
static grub_err_t grub_chainloader_unload (void) { grub_dl_unref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t grub_cmd_appleloader (grub_command_t cmd __attribute__ ((unused)), int argc, char *argv[]) { grub_efi_boot_services_t *b; grub_efi_loaded_image_t *loaded_image; struct devdata *pdev; grub_dl_ref (my_mod); /* Initialize some global variables. */ image_handle = 0; b = grub_efi_system_table->boot_services; for (pdev = devs ; pdev->devpath ; pdev++) if (efi_call_6 (b->load_image, 0, grub_efi_image_handle, pdev->devpath, NULL, 0, &image_handle) == GRUB_EFI_SUCCESS) break; if (! pdev->devpath) { grub_error (GRUB_ERR_BAD_OS, "can't find model"); goto fail; } grub_dprintf ("appleload", "Model: %s\n", pdev->model); loaded_image = grub_efi_get_loaded_image (image_handle); if (! loaded_image) { grub_error (GRUB_ERR_BAD_OS, "no loaded image available"); goto fail; } if (argc > 0) { int i, len; grub_efi_char16_t *p16; for (i = 0, len = 0; i < argc; i++) len += grub_strlen (argv[i]) + 1; len *= sizeof (grub_efi_char16_t); cmdline = p16 = grub_malloc (len); if (! cmdline) goto fail; for (i = 0; i < argc; i++) { char *p8; p8 = argv[i]; while (*p8) *(p16++) = *(p8++); *(p16++) = ' '; } *(--p16) = 0; loaded_image->load_options = cmdline; loaded_image->load_options_size = len; } grub_loader_set (grub_appleloader_boot, grub_appleloader_unload, 0); return 0; fail: grub_dl_unref (my_mod); return grub_errno; }
static void grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags) { grub_file_t file = 0; grub_uint16_t signature; grub_device_t dev; int drive = -1; void *part_addr = 0; grub_dl_ref (my_mod); file = grub_file_open (filename); if (! file) goto fail; /* Read the first block. */ if (grub_file_read (file, (void *) 0x7C00, GRUB_DISK_SECTOR_SIZE) != GRUB_DISK_SECTOR_SIZE) { if (grub_errno == GRUB_ERR_NONE) grub_error (GRUB_ERR_BAD_OS, "too small"); goto fail; } /* Check the signature. */ signature = *((grub_uint16_t *) (0x7C00 + GRUB_DISK_SECTOR_SIZE - 2)); if (signature != grub_le_to_cpu16 (0xaa55) && ! (flags & GRUB_CHAINLOADER_FORCE)) { grub_error (GRUB_ERR_BAD_OS, "invalid signature"); goto fail; } grub_file_close (file); /* Obtain the partition table from the root device. */ drive = grub_get_root_biosnumber (); dev = grub_device_open (0); if (dev && dev->disk && dev->disk->partition) { grub_disk_t disk = dev->disk; if (disk) { grub_partition_t p = disk->partition; if (p && grub_strcmp (p->partmap->name, "msdos") == 0) { disk->partition = p->parent; grub_disk_read (disk, p->offset, 446, 64, (void *) GRUB_MEMORY_MACHINE_PART_TABLE_ADDR); part_addr = (void *) (GRUB_MEMORY_MACHINE_PART_TABLE_ADDR + (p->index << 4)); disk->partition = p; } } } if (dev) grub_device_close (dev); /* Ignore errors. Perhaps it's not fatal. */ grub_errno = GRUB_ERR_NONE; boot_drive = drive; boot_part_addr = part_addr; grub_loader_set (grub_chainloader_boot, grub_chainloader_unload, 1); return; fail: if (file) grub_file_close (file); grub_dl_unref (my_mod); }
static grub_err_t grub_cpio_open (grub_file_t file, const char *name_in) { struct grub_cpio_data *data; grub_disk_addr_t ofs; char *fn; char *name = grub_strdup (name_in + 1); int symlinknest = 0; if (!name) return grub_errno; canonicalize (name); grub_dl_ref (my_mod); data = grub_cpio_mount (file->device->disk); if (!data) { grub_free (name); return grub_errno; } data->hofs = 0; while (1) { grub_uint32_t mode; int restart; if (grub_cpio_find_file (data, &fn, NULL, &ofs, &mode)) goto fail; if (!ofs) { grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("file `%s' not found"), name_in); break; } if (handle_symlink (data, fn, &name, mode, &restart)) { grub_free (fn); goto fail; } if (restart) { ofs = 0; if (++symlinknest == 8) { grub_error (GRUB_ERR_SYMLINK_LOOP, N_("too deep nesting of symlinks")); goto fail; } goto no_match; } if (grub_strcmp (name, fn) != 0) goto no_match; file->data = data; file->size = data->size; grub_free (fn); grub_free (name); return GRUB_ERR_NONE; no_match: grub_free (fn); data->hofs = ofs; } fail: #ifdef MODE_USTAR grub_free (data->linkname); #endif grub_free (data); grub_free (name); grub_dl_unref (my_mod); return grub_errno; }
static grub_err_t grub_cpio_open (grub_file_t file, const char *name) { struct grub_cpio_data *data; grub_uint32_t ofs; char *fn; int i, j; grub_dl_ref (my_mod); data = grub_cpio_mount (file->device->disk); if (!data) goto fail; data->hofs = 0; while (1) { if (grub_cpio_find_file (data, &fn, &ofs)) goto fail; if (!ofs) { grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found"); break; } /* Compare NAME and FN by hand in order to cope with duplicate slashes. */ i = 0; j = 0; while (name[i] == '/') i++; while (1) { if (name[i] != fn[j]) goto no_match; if (name[i] == '\0') break; while (name[i] == '/' && name[i+1] == '/') i++; i++; j++; } if (name[i] != fn[j]) goto no_match; file->data = data; file->size = data->size; grub_free (fn); return GRUB_ERR_NONE; no_match: grub_free (fn); data->hofs = ofs; } fail: if (data) grub_free (data); grub_dl_unref (my_mod); return grub_errno; }
static grub_err_t grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)), int argc, char *argv[]) { grub_file_t file = 0; struct linux_kernel_header lh; grub_ssize_t len, start, filelen; void *kernel = NULL; grub_dl_ref (my_mod); if (argc == 0) { grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected")); goto fail; } file = grub_file_open (argv[0]); if (! file) goto fail; filelen = grub_file_size (file); kernel = grub_malloc(filelen); if (!kernel) { grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("cannot allocate kernel buffer")); goto fail; } if (grub_file_read (file, kernel, filelen) != filelen) { grub_error (GRUB_ERR_FILE_READ_ERROR, N_("Can't read kernel %s"), argv[0]); goto fail; } grub_tpm_measure (kernel, filelen, GRUB_KERNEL_PCR); if (! grub_linuxefi_secure_validate (kernel, filelen)) { grub_error (GRUB_ERR_INVALID_COMMAND, N_("%s has invalid signature"), argv[0]); grub_free (kernel); goto fail; } params = grub_efi_allocate_pages_max (0x3fffffff, BYTES_TO_PAGES(16384)); if (! params) { grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate kernel parameters"); goto fail; } grub_memset (params, 0, 16384); grub_memcpy (&lh, kernel, sizeof (lh)); if (lh.boot_flag != grub_cpu_to_le16 (0xaa55)) { grub_error (GRUB_ERR_BAD_OS, N_("invalid magic number")); goto fail; } if (lh.setup_sects > GRUB_LINUX_MAX_SETUP_SECTS) { grub_error (GRUB_ERR_BAD_OS, N_("too many setup sectors")); goto fail; } if (lh.version < grub_cpu_to_le16 (0x020b)) { grub_error (GRUB_ERR_BAD_OS, N_("kernel too old")); goto fail; } if (!lh.handover_offset) { grub_error (GRUB_ERR_BAD_OS, N_("kernel doesn't support EFI handover")); goto fail; } linux_cmdline = grub_efi_allocate_pages_max(0x3fffffff, BYTES_TO_PAGES(lh.cmdline_size + 1)); if (!linux_cmdline) { grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("can't allocate cmdline")); goto fail; } grub_memcpy (linux_cmdline, LINUX_IMAGE, sizeof (LINUX_IMAGE)); grub_create_loader_cmdline (argc, argv, linux_cmdline + sizeof (LINUX_IMAGE) - 1, lh.cmdline_size - (sizeof (LINUX_IMAGE) - 1)); grub_pass_verity_hash(&lh, linux_cmdline); lh.cmd_line_ptr = (grub_uint32_t)(grub_uint64_t)linux_cmdline; handover_offset = lh.handover_offset; start = (lh.setup_sects + 1) * 512; len = grub_file_size(file) - start; kernel_mem = grub_efi_allocate_pages(lh.pref_address, BYTES_TO_PAGES(lh.init_size)); if (!kernel_mem) kernel_mem = grub_efi_allocate_pages_max(0x3fffffff, BYTES_TO_PAGES(lh.init_size)); if (!kernel_mem) { grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("can't allocate kernel")); goto fail; } grub_memcpy (kernel_mem, (char *)kernel + start, len); grub_loader_set (grub_linuxefi_boot, grub_linuxefi_unload, 0); loaded=1; lh.code32_start = (grub_uint32_t)(grub_uint64_t) kernel_mem; grub_memcpy (params, &lh, 2 * 512); params->type_of_loader = 0x21; fail: if (file) grub_file_close (file); if (kernel) grub_free (kernel); if (grub_errno != GRUB_ERR_NONE) { grub_dl_unref (my_mod); loaded = 0; } if (linux_cmdline && !loaded) grub_efi_free_pages((grub_efi_physical_address_t)linux_cmdline, BYTES_TO_PAGES(lh.cmdline_size + 1)); if (kernel_mem && !loaded) grub_efi_free_pages((grub_efi_physical_address_t)kernel_mem, BYTES_TO_PAGES(kernel_size)); if (params && !loaded) grub_efi_free_pages((grub_efi_physical_address_t)params, BYTES_TO_PAGES(16384)); return grub_errno; }
void grub_multiboot2 (int argc, char *argv[]) { char *buffer; grub_file_t file = 0; grub_elf_t elf = 0; struct multiboot_header *header = 0; char *p; grub_ssize_t len; grub_err_t err; int header_found = 0; grub_loader_unset (); if (argc == 0) { grub_error (GRUB_ERR_BAD_ARGUMENT, "No kernel specified"); goto fail; } file = grub_gzfile_open (argv[0], 1); if (! file) { grub_error (GRUB_ERR_BAD_ARGUMENT, "Couldn't open file"); goto fail; } buffer = grub_malloc (MULTIBOOT2_HEADER_SEARCH); if (! buffer) return; len = grub_file_read (file, buffer, MULTIBOOT2_HEADER_SEARCH); if (len < 32) { grub_error (GRUB_ERR_BAD_OS, "File too small"); goto fail; } /* Look for the multiboot header in the buffer. The header should be at least 8 bytes and aligned on a 8-byte boundary. */ for (p = buffer; p <= buffer + len - 8; p += 8) { header = (struct multiboot_header *) p; if (header->magic == MULTIBOOT2_HEADER_MAGIC) { header_found = 1; break; } } if (! header_found) grub_dprintf ("loader", "No multiboot 2 header found.\n"); /* Create the basic tags. */ grub_dprintf ("loader", "Creating multiboot 2 tags\n"); grub_mb2_tags_create (); /* Load the kernel and create its tag. */ elf = grub_elf_file (file); if (elf) { grub_dprintf ("loader", "Loading ELF multiboot 2 file.\n"); err = grub_mb2_load_elf (elf, argc-1, &argv[1]); grub_elf_close (elf); } else { grub_errno = 0; grub_dprintf ("loader", "Loading non-ELF multiboot 2 file.\n"); if (header) err = grub_mb2_load_other (file, header); else err = grub_error (GRUB_ERR_BAD_OS, "Need multiboot 2 header to load non-ELF files."); grub_file_close (file); } grub_free (buffer); if (err) goto fail; /* Good to go. */ grub_loader_set (grub_mb2_boot, grub_mb2_unload, 1); return; fail: grub_mb2_tags_free (); grub_dl_unref (my_mod); }
static grub_err_t grub_cmd_multiboot (grub_command_t cmd __attribute__ ((unused)), int argc, char *argv[]) { grub_file_t file = 0; grub_err_t err; grub_loader_unset (); highest_load = 0; #ifndef GRUB_USE_MULTIBOOT2 grub_multiboot_quirks = GRUB_MULTIBOOT_QUIRKS_NONE; int option_found = 0; do { option_found = 0; if (argc != 0 && grub_strcmp (argv[0], "--quirk-bad-kludge") == 0) { argc--; argv++; option_found = 1; grub_multiboot_quirks |= GRUB_MULTIBOOT_QUIRK_BAD_KLUDGE; } if (argc != 0 && grub_strcmp (argv[0], "--quirk-modules-after-kernel") == 0) { argc--; argv++; option_found = 1; grub_multiboot_quirks |= GRUB_MULTIBOOT_QUIRK_MODULES_AFTER_KERNEL; } } while (option_found); #endif if (argc == 0) return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected")); file = grub_file_open (argv[0]); if (! file) return grub_errno; grub_dl_ref (my_mod); /* Skip filename. */ grub_multiboot_init_mbi (argc - 1, argv + 1); grub_relocator_unload (grub_multiboot_relocator); grub_multiboot_relocator = grub_relocator_new (); if (!grub_multiboot_relocator) goto fail; err = grub_multiboot_load (file, argv[0]); if (err) goto fail; grub_multiboot_set_bootdev (); grub_loader_set (grub_multiboot_boot, grub_multiboot_unload, 0); fail: if (file) grub_file_close (file); if (grub_errno != GRUB_ERR_NONE) { grub_relocator_unload (grub_multiboot_relocator); grub_multiboot_relocator = NULL; grub_dl_unref (my_mod); } else { /* Begin TCG Extension */ grub_TPM_measure_file( argv[0], TPM_LOADER_MEASUREMENT_PCR ); /* End TCG Extension */ } return grub_errno; }
static grub_err_t grub_cpio_dir (grub_device_t device, const char *path_in, int (*hook) (const char *filename, const struct grub_dirhook_info *info)) { struct grub_cpio_data *data; grub_disk_addr_t ofs; char *prev, *name, *path, *ptr; grub_size_t len; int symlinknest = 0; path = grub_strdup (path_in + 1); if (!path) return grub_errno; canonicalize (path); for (ptr = path + grub_strlen (path) - 1; ptr >= path && *ptr == '/'; ptr--) *ptr = 0; grub_dl_ref (my_mod); prev = 0; data = grub_cpio_mount (device->disk); if (!data) { grub_free (path); return grub_errno; } len = grub_strlen (path); data->hofs = 0; while (1) { grub_int32_t mtime; grub_uint32_t mode; grub_err_t err; if (grub_cpio_find_file (data, &name, &mtime, &ofs, &mode)) goto fail; if (!ofs) break; if (grub_memcmp (path, name, len) == 0 && (name[len] == 0 || name[len] == '/' || len == 0)) { char *p, *n; n = name + len; while (*n == '/') n++; p = grub_strchr (n, '/'); if (p) *p = 0; if (((!prev) || (grub_strcmp (prev, name) != 0)) && *n != 0) { struct grub_dirhook_info info; grub_memset (&info, 0, sizeof (info)); info.dir = (p != NULL) || ((mode & ATTR_TYPE) == ATTR_DIR); info.mtime = mtime; info.mtimeset = 1; if (hook (n, &info)) { grub_free (name); goto fail; } grub_free (prev); prev = name; } else { int restart = 0; err = handle_symlink (data, name, &path, mode, &restart); grub_free (name); if (err) goto fail; if (restart) { len = grub_strlen (path); if (++symlinknest == 8) { grub_error (GRUB_ERR_SYMLINK_LOOP, N_("too deep nesting of symlinks")); goto fail; } ofs = 0; } } } else grub_free (name); data->hofs = ofs; } fail: grub_free (path); grub_free (prev); #ifdef MODE_USTAR grub_free (data->linkname); #endif grub_free (data); grub_dl_unref (my_mod); return grub_errno; }