static int is_authenticated_hook (grub_list_t item, void *closure) { struct is_authenticated_closure *c = closure; const char *name; if (!((struct grub_auth_user *) item)->authenticated) return 0; name = ((struct grub_auth_user *) item)->name; return (c->userlist && grub_strword (c->userlist, name)) || grub_strword (c->superusers, name); }
void dvprintf(const char *debug_context, const char *fmt, va_list args) { const char *debug_env = grub_env_get("debug"); if (debug_env && grub_strword(debug_env, debug_context)) grub_vprintf(fmt, args); }
void grub_real_dprintf (const char *file, const int line, const char *condition, const char *fmt, ...) { va_list args; const char *debug = grub_env_get ("debug"); if (! debug) return; if (grub_strword (debug, "all") || grub_strword (debug, condition)) { grub_printf ("%s:%d: ", file, line); va_start (args, fmt); grub_vprintf (fmt, args); va_end (args); } }
/* Returns true if the kext should be loaded according to plist and osbundlereq. Also fill BINNAME. */ static int grub_xnu_check_os_bundle_required (char *plistname, char *osbundlereq, char **binname) { grub_file_t file; char *buf = 0, *tagstart = 0, *ptr1 = 0, *keyptr = 0; char *stringptr = 0, *ptr2 = 0; grub_size_t size; int depth = 0; int ret; int osbundlekeyfound = 0, binnamekeyfound = 0; if (binname) *binname = 0; file = grub_gzfile_open (plistname, 1); if (! file) { grub_file_close (file); grub_error_push (); grub_error (GRUB_ERR_BAD_OS, "couldn't read file %s", plistname); return 0; } size = grub_file_size (file); buf = grub_malloc (size); if (! buf) { grub_file_close (file); grub_error_push (); grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't read file %s", plistname); return 0; } if (grub_file_read (file, buf, size) != (grub_ssize_t) (size)) { grub_file_close (file); grub_error_push (); grub_error (GRUB_ERR_BAD_OS, "couldn't read file %s", plistname); return 0; } grub_file_close (file); /* Set the return value for the case when no OSBundleRequired tag is found. */ if (osbundlereq) ret = grub_strword (osbundlereq, "all") || grub_strword (osbundlereq, "-"); else ret = 1; /* Parse plist. It's quite dirty and inextensible but does its job. */ for (ptr1 = buf; ptr1 < buf + size; ptr1++) switch (*ptr1) { case '<': tagstart = ptr1; *ptr1 = 0; if (keyptr && depth == 4 && grub_strcmp (keyptr, "OSBundleRequired") == 0) osbundlekeyfound = 1; if (keyptr && depth == 4 && grub_strcmp (keyptr, "CFBundleExecutable") == 0) binnamekeyfound = 1; if (stringptr && osbundlekeyfound && osbundlereq && depth == 4) { for (ptr2 = stringptr; *ptr2; ptr2++) *ptr2 = grub_tolower (*ptr2); ret = grub_strword (osbundlereq, stringptr) || grub_strword (osbundlereq, "all"); } if (stringptr && binnamekeyfound && binname && depth == 4) { if (*binname) grub_free (*binname); *binname = grub_strdup (stringptr); } *ptr1 = '<'; keyptr = 0; stringptr = 0; break; case '>': if (! tagstart) { grub_free (buf); grub_error (GRUB_ERR_BAD_OS, "can't parse %s", plistname); return 0; } *ptr1 = 0; if (tagstart[1] == '?' || ptr1[-1] == '/') { osbundlekeyfound = 0; *ptr1 = '>'; break; } if (depth == 3 && grub_strcmp (tagstart + 1, "key") == 0) keyptr = ptr1 + 1; if (depth == 3 && grub_strcmp (tagstart + 1, "string") == 0) stringptr = ptr1 + 1; else if (grub_strcmp (tagstart + 1, "/key") != 0) { osbundlekeyfound = 0; binnamekeyfound = 0; } *ptr1 = '>'; if (tagstart[1] == '/') depth--; else depth++; break; } grub_free (buf); return ret; }
static grub_err_t grub_cmd_acpi (struct grub_extcmd_context *ctxt, int argc, char **args) { struct grub_arg_list *state = ctxt->state; struct grub_acpi_rsdp_v10 *rsdp; struct efiemu_acpi_table *cur, *t; int i, mmapregion; int numoftables; /* Default values if no RSDP is found. */ rev1 = 1; rev2 = 3; facs_addr = 0; playground = playground_ptr = 0; playground_size = 0; rsdp = (struct grub_acpi_rsdp_v10 *) grub_machine_acpi_get_rsdpv2 (); if (! rsdp) rsdp = grub_machine_acpi_get_rsdpv1 (); if (rsdp) { grub_uint32_t *entry_ptr; char *exclude = 0; char *load_only = 0; char *ptr; /* RSDT consists of header and an array of 32-bit pointers. */ struct grub_acpi_table_header *rsdt; exclude = state[0].set ? grub_strdup (state[0].arg) : 0; if (exclude) { for (ptr = exclude; *ptr; ptr++) *ptr = grub_tolower (*ptr); } load_only = state[1].set ? grub_strdup (state[1].arg) : 0; if (load_only) { for (ptr = load_only; *ptr; ptr++) *ptr = grub_tolower (*ptr); } /* Set revision variables to replicate the same version as host. */ rev1 = ! rsdp->revision; rev2 = rsdp->revision; rsdt = (struct grub_acpi_table_header *) (grub_addr_t) rsdp->rsdt_addr; /* Load host tables. */ for (entry_ptr = (grub_uint32_t *) (rsdt + 1); entry_ptr < (grub_uint32_t *) (((grub_uint8_t *) rsdt) + rsdt->length); entry_ptr++) { char signature[5]; struct efiemu_acpi_table *table; struct grub_acpi_table_header *curtable = (struct grub_acpi_table_header *) (grub_addr_t) *entry_ptr; signature[4] = 0; for (i = 0; i < 4;i++) signature[i] = grub_tolower (curtable->signature[i]); /* If it's FADT it contains addresses of DSDT and FACS. */ if (grub_strcmp (signature, "facp") == 0) { struct grub_acpi_table_header *dsdt; struct grub_acpi_fadt *fadt = (struct grub_acpi_fadt *) curtable; /* Set root header variables to the same values as FADT by default. */ grub_memcpy (&root_oemid, &(fadt->hdr.oemid), sizeof (root_oemid)); grub_memcpy (&root_oemtable, &(fadt->hdr.oemtable), sizeof (root_oemtable)); root_oemrev = fadt->hdr.oemrev; grub_memcpy (&root_creator_id, &(fadt->hdr.creator_id), sizeof (root_creator_id)); root_creator_rev = fadt->hdr.creator_rev; /* Load DSDT if not excluded. */ dsdt = (struct grub_acpi_table_header *) (grub_addr_t) fadt->dsdt_addr; if (dsdt && (! exclude || ! grub_strword (exclude, "dsdt")) && (! load_only || grub_strword (load_only, "dsdt")) && dsdt->length >= sizeof (*dsdt)) { dsdt_size = dsdt->length; table_dsdt = grub_malloc (dsdt->length); if (! table_dsdt) { free_tables (); grub_free (exclude); grub_free (load_only); return grub_errno; } grub_memcpy (table_dsdt, dsdt, dsdt->length); } /* Save FACS address. FACS shouldn't be overridden. */ facs_addr = fadt->facs_addr; } /* Skip excluded tables. */ if (exclude && grub_strword (exclude, signature)) continue; if (load_only && ! grub_strword (load_only, signature)) continue; /* Sanity check. */ if (curtable->length < sizeof (*curtable)) continue; table = (struct efiemu_acpi_table *) grub_malloc (sizeof (struct efiemu_acpi_table)); if (! table) { free_tables (); grub_free (exclude); grub_free (load_only); return grub_errno; } table->size = curtable->length; table->addr = grub_malloc (table->size); playground_size += table->size; if (! table->addr) { free_tables (); return grub_errno; } table->next = acpi_tables; acpi_tables = table; grub_memcpy (table->addr, curtable, table->size); } grub_free (exclude); grub_free (load_only); } /* Does user specify versions to generate? */ if (state[2].set || state[3].set) { rev1 = state[2].set; if (state[3].set) rev2 = rev2 ? : 2; else