/* grub_fatal() on error */ static void grub_TPM_readpcr( const unsigned long index, grub_uint8_t* result ) { CHECK_FOR_NULL_ARGUMENT( result ) PassThroughToTPM_InputParamBlock *passThroughInput = NULL; PCRReadIncoming* pcrReadIncoming = NULL; grub_uint16_t inputlen = sizeof( *passThroughInput ) - sizeof( passThroughInput->TPMOperandIn ) + sizeof( *pcrReadIncoming ); PassThroughToTPM_OutputParamBlock *passThroughOutput = NULL; PCRReadOutgoing* pcrReadOutgoing = NULL; grub_uint16_t outputlen = sizeof( *passThroughOutput ) - sizeof( passThroughOutput->TPMOperandOut ) + sizeof( *pcrReadOutgoing ); passThroughInput = grub_zalloc( inputlen ); if( ! passThroughInput ) { grub_fatal( "readpcr: memory allocation failed" ); } passThroughInput->IPBLength = inputlen; passThroughInput->OPBLength = outputlen; pcrReadIncoming = (void *)passThroughInput->TPMOperandIn; pcrReadIncoming->tag = grub_swap_bytes16_compile_time( TPM_TAG_RQU_COMMAND ); pcrReadIncoming->paramSize = grub_swap_bytes32( sizeof( *pcrReadIncoming ) ); pcrReadIncoming->ordinal = grub_swap_bytes32_compile_time( TPM_ORD_PcrRead ); pcrReadIncoming->pcrIndex = grub_swap_bytes32( (grub_uint32_t) index); passThroughOutput = grub_zalloc( outputlen ); if( ! passThroughOutput ) { grub_free( passThroughInput ); grub_fatal( "readpcr: memory allocation failed" ); } grub_TPM_int1A_passThroughToTPM( passThroughInput, passThroughOutput ); grub_free( passThroughInput ); pcrReadOutgoing = (void *)passThroughOutput->TPMOperandOut; grub_uint32_t tpm_PCRreadReturnCode = grub_swap_bytes32( pcrReadOutgoing->returnCode ); if( tpm_PCRreadReturnCode != TPM_SUCCESS ) { grub_free( passThroughOutput ); if( tpm_PCRreadReturnCode == TPM_BADINDEX ) { grub_fatal( "readpcr: bad pcr index" ); } grub_fatal( "readpcr: tpm_PCRreadReturnCode: %u", tpm_PCRreadReturnCode ); } grub_memcpy( result, pcrReadOutgoing->pcr_value, SHA1_DIGEST_SIZE ); grub_free( passThroughOutput ); }
enum grub_comb_type grub_unicode_get_comb_type (grub_uint32_t c) { static grub_uint8_t *comb_types = NULL; struct grub_unicode_compact_range *cur; if (!comb_types) { unsigned i; comb_types = grub_zalloc (GRUB_UNICODE_MAX_CACHED_CHAR); if (comb_types) for (cur = grub_unicode_compact; cur->len; cur++) for (i = cur->start; i < cur->start + (unsigned) cur->len && i < GRUB_UNICODE_MAX_CACHED_CHAR; i++) comb_types[i] = cur->comb_type; else grub_errno = GRUB_ERR_NONE; } if (comb_types && c < GRUB_UNICODE_MAX_CACHED_CHAR) return comb_types[c]; for (cur = grub_unicode_compact; cur->len; cur++) if (cur->start <= c && c < cur->start + (unsigned) cur->len) return cur->comb_type; return GRUB_UNICODE_COMB_NONE; }
static grub_err_t sun_pc_partition_map_iterate (grub_disk_t disk, int (*hook) (grub_disk_t disk, const grub_partition_t partition)) { grub_partition_t p; struct grub_sun_pc_block block; int partnum; grub_err_t err; p = (grub_partition_t) grub_zalloc (sizeof (struct grub_partition)); if (! p) return grub_errno; p->partmap = &grub_sun_pc_partition_map; err = grub_disk_read (disk, 1, 0, sizeof (struct grub_sun_pc_block), &block); if (err) { grub_free (p); return err; } if (GRUB_PARTMAP_SUN_PC_MAGIC != grub_le_to_cpu16 (block.magic)) { grub_free (p); return grub_error (GRUB_ERR_BAD_PART_TABLE, "not a sun_pc partition table"); } if (! grub_sun_is_valid (&block)) { grub_free (p); return grub_error (GRUB_ERR_BAD_PART_TABLE, "invalid checksum"); } /* Maybe another error value would be better, because partition table _is_ recognized but invalid. */ for (partnum = 0; partnum < GRUB_PARTMAP_SUN_PC_MAX_PARTS; partnum++) { struct grub_sun_pc_partition_descriptor *desc; if (block.partitions[partnum].id == 0 || block.partitions[partnum].id == GRUB_PARTMAP_SUN_PC_WHOLE_DISK_ID) continue; desc = &block.partitions[partnum]; p->start = grub_le_to_cpu32 (desc->start_sector); p->len = grub_le_to_cpu32 (desc->num_sectors); p->number = partnum; if (p->len) { if (hook (disk, p)) partnum = GRUB_PARTMAP_SUN_PC_MAX_PARTS; } } grub_free (p); return grub_errno; }
static struct grub_cpio_data * grub_cpio_mount (grub_disk_t disk) { struct head hd; struct grub_cpio_data *data; if (grub_disk_read (disk, 0, 0, sizeof (hd), &hd)) goto fail; if (grub_memcmp (hd.magic, MAGIC, sizeof (MAGIC) - 1) #ifdef MAGIC2 && grub_memcmp (hd.magic, MAGIC2, sizeof (MAGIC2) - 1) #endif ) goto fail; data = (struct grub_cpio_data *) grub_zalloc (sizeof (*data)); if (!data) goto fail; data->disk = disk; return data; fail: grub_error (GRUB_ERR_BAD_FS, "not a " #ifdef MODE_USTAR "tar" #else "cpio" #endif " filesystem"); return 0; }
static grub_err_t grub_cmd_password (grub_command_t cmd __attribute__ ((unused)), int argc, char **args) { grub_err_t err; char *pass; int copylen; if (argc != 2) return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments expected"); pass = grub_zalloc (GRUB_AUTH_MAX_PASSLEN); if (!pass) return grub_errno; copylen = grub_strlen (args[1]); if (copylen >= GRUB_AUTH_MAX_PASSLEN) copylen = GRUB_AUTH_MAX_PASSLEN - 1; grub_memcpy (pass, args[1], copylen); err = grub_auth_register_authentication (args[0], check_password, pass); if (err) { grub_free (pass); return err; } grub_dl_ref (my_mod); return GRUB_ERR_NONE; }
static grub_err_t http_open (struct grub_file *file, const char *filename) { grub_err_t err; struct http_data *data; data = grub_zalloc (sizeof (*data)); if (!data) return grub_errno; file->size = GRUB_FILE_SIZE_UNKNOWN; data->filename = grub_strdup (filename); if (!data->filename) { grub_free (data); return grub_errno; } file->not_easily_seekable = 0; file->data = data; err = http_establish (file, 0, 1); if (err) { grub_free (data->filename); grub_free (data); return err; } return GRUB_ERR_NONE; }
struct grub_xnu_devtree_key * grub_xnu_create_key (struct grub_xnu_devtree_key **parent, char *name) { struct grub_xnu_devtree_key *ret; ret = grub_xnu_find_key (*parent, name); if (ret) return ret; ret = (struct grub_xnu_devtree_key *) grub_zalloc (sizeof (*ret)); if (! ret) { grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create key %s", name); return 0; } ret->name = grub_strdup (name); if (! ret->name) { grub_free (ret); grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create key %s", name); return 0; } ret->datasize = -1; ret->next = *parent; *parent = ret; return ret; }
grub_ssize_t grub_zlib_decompress (char *inbuf, grub_size_t insize, grub_off_t off, char *outbuf, grub_size_t outsize) { grub_gzio_t gzio = 0; grub_ssize_t ret; gzio = grub_zalloc (sizeof (*gzio)); if (! gzio) return -1; gzio->mem_input = (grub_uint8_t *) inbuf; gzio->mem_input_size = insize; gzio->mem_input_off = 0; if (!test_zlib_header (gzio)) { grub_free (gzio); return -1; } ret = grub_gzio_read_real (gzio, off, outbuf, outsize); grub_free (gzio); /* FIXME: Check Adler. */ return ret; }
grub_elf_t grub_elf_file (grub_file_t file) { grub_elf_t elf; elf = grub_zalloc (sizeof (*elf)); if (! elf) return 0; elf->file = file; if (grub_file_seek (elf->file, 0) == (grub_off_t) -1) goto fail; if (grub_file_read (elf->file, &elf->ehdr, sizeof (elf->ehdr)) != sizeof (elf->ehdr)) { grub_error_push (); grub_error (GRUB_ERR_READ_ERROR, "cannot read ELF header"); goto fail; } if (grub_elf_check_header (elf)) goto fail; return elf; fail: grub_free (elf->phdrs); grub_free (elf); return 0; }
struct grub_xnu_devtree_key * grub_xnu_create_value (struct grub_xnu_devtree_key **parent, char *name) { struct grub_xnu_devtree_key *ret; ret = grub_xnu_find_key (*parent, name); if (ret) { if (ret->datasize == -1) grub_xnu_free_devtree (ret->first_child); else if (ret->datasize) grub_free (ret->data); ret->datasize = 0; ret->data = 0; return ret; } ret = (struct grub_xnu_devtree_key *) grub_zalloc (sizeof (*ret)); if (! ret) { grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create value %s", name); return 0; } ret->name = grub_strdup (name); if (! ret->name) { grub_free (ret); grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create value %s", name); return 0; } ret->next = *parent; *parent = ret; return ret; }
static struct grub_archelp_data * grub_cbfs_mount (grub_disk_t disk) { struct cbfs_file hd; struct grub_archelp_data *data = NULL; grub_uint32_t ptr; grub_off_t header_off; struct cbfs_header head; if (grub_disk_get_size (disk) == GRUB_DISK_SIZE_UNKNOWN) goto fail; if (grub_disk_read (disk, grub_disk_get_size (disk) - 1, GRUB_DISK_SECTOR_SIZE - sizeof (ptr), sizeof (ptr), &ptr)) goto fail; ptr = grub_cpu_to_le32 (ptr); header_off = (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS) + (grub_int32_t) ptr; if (grub_disk_read (disk, 0, header_off, sizeof (head), &head)) goto fail; if (!validate_head (&head)) goto fail; data = (struct grub_archelp_data *) grub_zalloc (sizeof (*data)); if (!data) goto fail; data->cbfs_start = (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS) - (grub_be_to_cpu32 (head.romsize) - grub_be_to_cpu32 (head.offset)); data->cbfs_end = (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS) - grub_be_to_cpu32 (head.bootblocksize); data->cbfs_align = grub_be_to_cpu32 (head.align); if (data->cbfs_start >= (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS)) goto fail; if (data->cbfs_end > (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS)) data->cbfs_end = (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS); data->next_hofs = data->cbfs_start; if (grub_disk_read (disk, 0, data->cbfs_start, sizeof (hd), &hd)) goto fail; if (grub_memcmp (hd.magic, CBFS_FILE_MAGIC, sizeof (CBFS_FILE_MAGIC) - 1)) goto fail; data->disk = disk; return data; fail: grub_free (data); grub_error (GRUB_ERR_BAD_FS, "not a cbfs filesystem"); return 0; }
grub_err_t grub_auth_authenticate (const char *user) { struct grub_auth_user *cur; cur = grub_named_list_find (GRUB_AS_NAMED_LIST (users), user); if (!cur) cur = grub_zalloc (sizeof (*cur)); if (!cur) return grub_errno; cur->authenticated = 1; if (! cur->name) { cur->name = grub_strdup (user); if (!cur->name) { grub_free (cur); return grub_errno; } grub_list_push (GRUB_AS_LIST_P (&users), GRUB_AS_LIST (cur)); } return GRUB_ERR_NONE; }
grub_err_t grub_auth_register_authentication (const char *user, grub_auth_callback_t callback, void *arg) { struct grub_auth_user *cur; cur = grub_named_list_find (GRUB_AS_NAMED_LIST (users), user); if (!cur) cur = grub_zalloc (sizeof (*cur)); if (!cur) return grub_errno; cur->callback = callback; cur->arg = arg; if (! cur->name) { cur->name = grub_strdup (user); if (!cur->name) { grub_free (cur); return grub_errno; } grub_list_push (GRUB_AS_LIST_P (&users), GRUB_AS_LIST (cur)); } return GRUB_ERR_NONE; }
/* This is similar to grub_file_open. */ static grub_err_t grub_mofile_open (struct grub_gettext_context *ctx, const char *filename) { struct header head; grub_err_t err; grub_file_t fd; /* Using fd_mo and not another variable because it's needed for grub_gettext_get_info. */ fd = grub_file_open (filename); if (!fd) return grub_errno; err = grub_gettext_pread (fd, &head, sizeof (head), 0); if (err) { grub_file_close (fd); return err; } if (head.magic != grub_cpu_to_le32_compile_time (MO_MAGIC_NUMBER)) { grub_file_close (fd); return grub_error (GRUB_ERR_BAD_FILE_TYPE, "mo: invalid mo magic in file: %s", filename); } if (head.version != 0) { grub_file_close (fd); return grub_error (GRUB_ERR_BAD_FILE_TYPE, "mo: invalid mo version in file: %s", filename); } ctx->grub_gettext_offset_original = grub_le_to_cpu32 (head.offset_original); ctx->grub_gettext_offset_translation = grub_le_to_cpu32 (head.offset_translation); ctx->grub_gettext_max = grub_le_to_cpu32 (head.number_of_strings); for (ctx->grub_gettext_max_log = 0; ctx->grub_gettext_max >> ctx->grub_gettext_max_log; ctx->grub_gettext_max_log++); ctx->grub_gettext_msg_list = grub_zalloc (ctx->grub_gettext_max * sizeof (ctx->grub_gettext_msg_list[0])); if (!ctx->grub_gettext_msg_list) { grub_file_close (fd); return grub_errno; } ctx->fd_mo = fd; if (grub_gettext != grub_gettext_translate) { grub_gettext_original = grub_gettext; grub_gettext = grub_gettext_translate; } return 0; }
static grub_err_t grub_env_new_context (int export_all) { struct grub_env_context *context; int i; struct menu_pointer *menu; context = grub_zalloc (sizeof (*context)); if (! context) return grub_errno; menu = grub_zalloc (sizeof (*menu)); if (! menu) { grub_free (context); return grub_errno; } context->prev = grub_current_context; grub_current_context = context; menu->prev = current_menu; current_menu = menu; /* Copy exported variables. */ for (i = 0; i < HASHSZ; i++) { struct grub_env_var *var; for (var = context->prev->vars[i]; var; var = var->next) if (var->global || export_all) { if (grub_env_set (var->name, var->value) != GRUB_ERR_NONE) { grub_env_context_close (); return grub_errno; } grub_env_export (var->name); grub_register_variable_hook (var->name, var->read_hook, var->write_hook); } } return GRUB_ERR_NONE; }
grub_file_t grub_file_offset_open (grub_file_t parent, enum grub_file_type type, grub_off_t start, grub_off_t size) { struct grub_offset_file *off_data; grub_file_t off_file, last_off_file; grub_file_filter_id_t filter; off_file = grub_zalloc (sizeof (*off_file)); off_data = grub_zalloc (sizeof (*off_data)); if (!off_file || !off_data) { grub_free (off_file); grub_free (off_data); return 0; } off_data->off = start; off_data->parent = parent; off_file->device = parent->device; off_file->data = off_data; off_file->fs = &grub_offset_fs; off_file->size = size; last_off_file = NULL; for (filter = GRUB_FILE_FILTER_COMPRESSION_FIRST; off_file && filter <= GRUB_FILE_FILTER_COMPRESSION_LAST; filter++) if (grub_file_filters[filter]) { last_off_file = off_file; off_file = grub_file_filters[filter] (off_file, type); } if (!off_file) { off_data->parent = NULL; grub_file_close (last_off_file); return 0; } return off_file; }
grub_command_t grub_register_command_prio (const char *name, grub_command_func_t func, const char *summary, const char *description, int prio) { grub_command_t cmd; int inactive = 0; grub_command_t *p, q; cmd = (grub_command_t) grub_zalloc (sizeof (*cmd)); if (! cmd) return 0; cmd->name = name; cmd->func = func; cmd->summary = (summary) ? summary : ""; cmd->description = description; cmd->flags = 0; cmd->prio = prio; for (p = &grub_command_list, q = *p; q; p = &(q->next), q = q->next) { int r; r = grub_strcmp (cmd->name, q->name); if (r < 0) break; if (r > 0) continue; if (cmd->prio >= (q->prio & GRUB_COMMAND_PRIO_MASK)) { q->prio &= ~GRUB_COMMAND_FLAG_ACTIVE; break; } inactive = 1; } *p = cmd; cmd->next = q; if (q) { q->prev = &cmd->next; } cmd->prev = p; if (! inactive) { cmd->prio |= GRUB_COMMAND_FLAG_ACTIVE; } return cmd; }
static struct ofdisk_hash_ent * ofdisk_hash_add_real (char *devpath) { struct ofdisk_hash_ent *p; struct ofdisk_hash_ent **head = &ofdisk_hash[ofdisk_hash_fn(devpath)]; const char *iptr; char *optr; p = grub_zalloc (sizeof (*p)); if (!p) return NULL; p->devpath = devpath; p->grub_devpath = grub_malloc (sizeof ("ieee1275/") + 2 * grub_strlen (p->devpath)); if (!p->grub_devpath) { grub_free (p); return NULL; } if (! grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_PARTITION_0)) { p->open_path = grub_malloc (grub_strlen (p->devpath) + 3); if (!p->open_path) { grub_free (p->grub_devpath); grub_free (p); return NULL; } optr = grub_stpcpy (p->open_path, p->devpath); *optr++ = ':'; *optr++ = '0'; *optr = '\0'; } else p->open_path = p->devpath; optr = grub_stpcpy (p->grub_devpath, "ieee1275/"); for (iptr = p->devpath; *iptr; ) { if (*iptr == ',') *optr++ = '\\'; *optr++ = *iptr++; } *optr = 0; p->next = *head; *head = p; return p; }
/* Parse the script passed in SCRIPT and return the parsed datastructure that is ready to be interpreted. */ struct grub_script * grub_script_parse (char *script, grub_reader_getline_t getline) { struct grub_script *parsed; struct grub_script_mem *membackup; struct grub_lexer_param *lexstate; struct grub_parser_param *parsestate; parsed = grub_script_create (0, 0); if (!parsed) return 0; parsestate = grub_zalloc (sizeof (*parsestate)); if (!parsestate) { grub_free (parsed); return 0; } /* Initialize the lexer. */ lexstate = grub_script_lexer_init (parsestate, script, getline); if (!lexstate) { grub_free (parsed); grub_free (parsestate); return 0; } parsestate->lexerstate = lexstate; membackup = grub_script_mem_record (parsestate); /* Parse the script. */ if (grub_script_yyparse (parsestate) || parsestate->err) { struct grub_script_mem *memfree; memfree = grub_script_mem_record_stop (parsestate, membackup); grub_script_mem_free (memfree); grub_script_lexer_fini (lexstate); grub_free (parsestate); grub_free (parsed); return 0; } parsed->mem = grub_script_mem_record_stop (parsestate, membackup); parsed->cmd = parsestate->parsed; parsed->children = parsestate->scripts; grub_script_lexer_fini (lexstate); grub_free (parsestate); return parsed; }
grub_uitree_t grub_uitree_create_node (const char *name) { grub_uitree_t n; n = grub_zalloc (sizeof (struct grub_uitree) + grub_strlen (name) + 1); if (! n) return 0; grub_strcpy (n->name, name); return n; }
grub_err_t grub_env_set (const char *name, const char *val) { struct grub_env_var *var; /* If the variable does already exist, just update the variable. */ var = grub_env_find (name); if (var) { char *old = var->value; if (var->write_hook) var->value = var->write_hook (var, val); else var->value = grub_strdup (val); if (! var->value) { var->value = old; return grub_errno; } grub_free (old); return GRUB_ERR_NONE; } /* The variable does not exist, so create a new one. */ var = grub_zalloc (sizeof (*var)); if (! var) return grub_errno; /* This is not necessary. But leave this for readability. */ var->global = 0; var->name = grub_strdup (name); if (! var->name) goto fail; var->value = grub_strdup (val); if (! var->value) goto fail; grub_env_insert (grub_current_context, var); return GRUB_ERR_NONE; fail: grub_free (var->name); grub_free (var->value); grub_free (var); return grub_errno; }
static grub_err_t grub_tpm1_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf, grub_size_t size, grub_uint8_t pcr, const char *description) { grub_tpm_event_t *event; grub_efi_status_t status; grub_efi_tpm_protocol_t *tpm; grub_efi_physical_address_t lastevent; grub_uint32_t algorithm; grub_uint32_t eventnum = 0; tpm = grub_efi_open_protocol (tpm_handle, &tpm_guid, GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL); if (!grub_tpm1_present (tpm)) return 0; event = grub_zalloc (sizeof (*event) + grub_strlen (description) + 1); if (!event) return grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("cannot allocate TPM event buffer")); event->PCRIndex = pcr; event->EventType = EV_IPL; event->EventSize = grub_strlen (description) + 1; grub_memcpy (event->Event, description, event->EventSize); algorithm = TCG_ALG_SHA; status = efi_call_7 (tpm->log_extend_event, tpm, buf, (grub_uint64_t) size, algorithm, event, &eventnum, &lastevent); switch (status) { case GRUB_EFI_SUCCESS: return 0; case GRUB_EFI_DEVICE_ERROR: return grub_error (GRUB_ERR_IO, N_("Command failed")); case GRUB_EFI_INVALID_PARAMETER: return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Invalid parameter")); case GRUB_EFI_BUFFER_TOO_SMALL: return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Output buffer too small")); case GRUB_EFI_NOT_FOUND: return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("TPM unavailable")); default: return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("Unknown TPM error")); } }
static grub_err_t grub_tpm2_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf, grub_size_t size, grub_uint8_t pcr, const char *description) { EFI_TCG2_EVENT *event; grub_efi_status_t status; grub_efi_tpm2_protocol_t *tpm; tpm = grub_efi_open_protocol (tpm_handle, &tpm2_guid, GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL); if (!grub_tpm2_present (tpm)) return 0; event = grub_zalloc (sizeof (EFI_TCG2_EVENT) + grub_strlen (description) + 1); if (!event) return grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("cannot allocate TPM event buffer")); event->Header.HeaderSize = sizeof (EFI_TCG2_EVENT_HEADER); event->Header.HeaderVersion = 1; event->Header.PCRIndex = pcr; event->Header.EventType = EV_IPL; event->Size = sizeof (*event) - sizeof (event->Event) + grub_strlen (description) + 1; grub_memcpy (event->Event, description, grub_strlen (description) + 1); status = efi_call_5 (tpm->hash_log_extend_event, tpm, 0, buf, (grub_uint64_t) size, event); switch (status) { case GRUB_EFI_SUCCESS: return 0; case GRUB_EFI_DEVICE_ERROR: return grub_error (GRUB_ERR_IO, N_("Command failed")); case GRUB_EFI_INVALID_PARAMETER: return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Invalid parameter")); case GRUB_EFI_BUFFER_TOO_SMALL: return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Output buffer too small")); case GRUB_EFI_NOT_FOUND: return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("TPM unavailable")); default: return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("Unknown TPM error")); } }
struct grub_font_glyph * grub_font_construct_glyph (grub_font_t hinted_font, const struct grub_unicode_glyph *glyph_id) { struct grub_font_glyph *main_glyph; struct grub_video_signed_rect bounds; struct grub_font_glyph *glyph; struct grub_font_glyph **combining_glyphs; main_glyph = grub_font_construct_dry_run (hinted_font, glyph_id, &bounds, &combining_glyphs, NULL); if (!main_glyph) return grub_font_dup_glyph (unknown_glyph); if (!combining_glyphs) return grub_font_dup_glyph (main_glyph); glyph = grub_zalloc (sizeof (*glyph) + (bounds.width * bounds.height + 7) / 8); if (!glyph) { grub_errno = GRUB_ERR_NONE; return grub_font_dup_glyph (main_glyph); } glyph->font = main_glyph->font; glyph->width = bounds.width; glyph->height = bounds.height; glyph->offset_x = bounds.x; glyph->offset_y = bounds.y; if (glyph_id->attributes & GRUB_UNICODE_GLYPH_ATTRIBUTE_MIRROR) grub_font_blit_glyph_mirror (glyph, main_glyph, main_glyph->offset_x - glyph->offset_x, (glyph->height + glyph->offset_y) - (main_glyph->height + main_glyph->offset_y)); else grub_font_blit_glyph (glyph, main_glyph, main_glyph->offset_x - glyph->offset_x, (glyph->height + glyph->offset_y) - (main_glyph->height + main_glyph->offset_y)); blit_comb (glyph_id, glyph, NULL, main_glyph, combining_glyphs, NULL); return glyph; }
static void unpack_join (void) { unsigned i; struct grub_unicode_compact_range *cur; join_types = grub_zalloc (GRUB_UNICODE_MAX_CACHED_CHAR); if (!join_types) { grub_errno = GRUB_ERR_NONE; return; } for (cur = grub_unicode_compact; cur->len; cur++) for (i = cur->start; i < cur->start + (unsigned) cur->len && i < GRUB_UNICODE_MAX_CACHED_CHAR; i++) join_types[i] = cur->join_type; }
struct grub_relocator * grub_relocator_new (void) { struct grub_relocator *ret; grub_cpu_relocator_init (); ret = grub_zalloc (sizeof (struct grub_relocator)); if (!ret) return NULL; ret->postchunks = ~(grub_phys_addr_t) 0; ret->relocators_size = grub_relocator_jumper_size; grub_dprintf ("relocator", "relocators_size=%lu\n", (unsigned long) ret->relocators_size); return ret; }
static grub_err_t http_seek (struct grub_file *file, grub_off_t off) { struct http_data *old_data, *data; grub_err_t err; old_data = file->data; /* FIXME: Reuse socket? */ grub_net_tcp_close (old_data->sock, GRUB_NET_TCP_ABORT); old_data->sock = 0; while (file->device->net->packs.first) { grub_netbuff_free (file->device->net->packs.first->nb); grub_net_remove_packet (file->device->net->packs.first); } file->device->net->stall = 0; file->device->net->offset = off; data = grub_zalloc (sizeof (*data)); if (!data) return grub_errno; data->size_recv = 1; data->filename = old_data->filename; if (!data->filename) { grub_free (data); file->data = 0; return grub_errno; } grub_free (old_data); file->data = data; err = http_establish (file, off, 0); if (err) { grub_free (data->filename); grub_free (data); file->data = 0; return err; } return GRUB_ERR_NONE; }
static void unpack_bidi (void) { unsigned i; struct grub_unicode_compact_range *cur; bidi_types = grub_zalloc (GRUB_UNICODE_MAX_CACHED_CHAR); if (!bidi_types) { grub_errno = GRUB_ERR_NONE; return; } for (cur = grub_unicode_compact; cur->len; cur++) for (i = cur->start; i < cur->start + (unsigned) cur->len && i < GRUB_UNICODE_MAX_CACHED_CHAR; i++) if (cur->bidi_mirror) bidi_types[i] = cur->bidi_type | 0x80; else bidi_types[i] = cur->bidi_type | 0x00; }
/* Open a new decompressing object on the top of IO. If TRANSPARENT is true, even if IO does not contain data compressed by gzip, return a valid file object. Note that this function won't close IO, even if an error occurs. */ static grub_file_t grub_gzio_open (grub_file_t io) { grub_file_t file; grub_gzio_t gzio = 0; file = (grub_file_t) grub_malloc (sizeof (*file)); if (! file) return 0; gzio = grub_zalloc (sizeof (*gzio)); if (! gzio) { grub_free (file); return 0; } gzio->file = io; file->device = io->device; file->offset = 0; file->data = gzio; file->read_hook = 0; file->fs = &grub_gzio_fs; file->not_easly_seekable = 1; if (! test_header (file)) { grub_free (gzio); grub_free (file); grub_file_seek (io, 0); if (grub_errno == GRUB_ERR_BAD_FILE_TYPE) { grub_errno = GRUB_ERR_NONE; return io; } } return file; }
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; }