X-Git-Url: https://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fgrub2%2Fscript.c;h=fe65e2d43b5ce260fef3a0b896a9dc89cec934a5;hp=3fee4705622524f34d0139f1861e2cc07b789932;hb=e492b596187d283cfbd65a098fe1b2d0dafa311e;hpb=44e9d1d04a3120476ac50a14bfa34fbd091190c9 diff --git a/discover/grub2/script.c b/discover/grub2/script.c index 3fee470..fe65e2d 100644 --- a/discover/grub2/script.c +++ b/discover/grub2/script.c @@ -1,6 +1,5 @@ #include -#include #include #include @@ -11,6 +10,8 @@ container_of(stmt, struct grub2_statement_simple, st) #define to_stmt_if(stmt) \ container_of(stmt, struct grub2_statement_if, st) +#define to_stmt_menuentry(stmt) \ + container_of(stmt, struct grub2_statement_menuentry, st) struct env_entry { const char *name; @@ -18,51 +19,125 @@ struct env_entry { struct list_item list; }; -static const char *env_lookup(struct grub2_script *script, - const char *name, int name_len) +const char *script_env_get(struct grub2_script *script, const char *name) { struct env_entry *entry; list_for_each_entry(&script->environment, entry, list) - if (!strncmp(entry->name, name, name_len) - && entry->name[name_len] == '\0') + if (!strcmp(entry->name, name)) return entry->value; return NULL; } -static bool expand_word(struct grub2_script *script, struct grub2_word *word) +void script_env_set(struct grub2_script *script, + const char *name, const char *value) { - const char *val, *src; - char *dest = NULL; - regmatch_t match; - int n, i; + struct env_entry *e, *entry = NULL; - src = word->text; + list_for_each_entry(&script->environment, e, list) { + if (!strcmp(e->name, name)) { + entry = e; + break; + } + } - n = regexec(&script->var_re, src, 1, &match, 0); - if (n != 0) - return false; + if (!entry) { + entry = talloc(script, struct env_entry); + entry->name = name; + list_add(&script->environment, &entry->list); + } - i = 0; - if (src[match.rm_so + 1] == '{') - i++; + entry->value = value; +} - val = env_lookup(script, src + match.rm_so + 1 + i, - match.rm_eo - match.rm_so - 1 - (i * 2)); +static bool expand_var(struct grub2_script *script, struct grub2_word *word) +{ + const char *val; + + val = script_env_get(script, word->name); if (!val) val = ""; - dest = talloc_strndup(script, src, match.rm_so); - dest = talloc_asprintf_append(dest, "%s%s", val, src + match.rm_eo); + word->text = talloc_strdup(script, val); - word->text = dest; return true; } -/* iterate through the words in an argv, looking for expansions. If a - * word is marked with expand == true, then we process any variable - * substitutions. +static bool is_delim(char c) +{ + return c == ' ' || c == '\t'; +} + +/* For non-double-quoted variable expansions, we may need to split the + * variable's value into multiple argv items. + * + * This function sets the word->text to the initial set of non-delimiter chars + * in the expanded var value. We then skip any delimiter chars, and (if + * required), create the new argv item with the remaining text, and + * add it to the argv list, after top_word. + */ +static void process_split(struct grub2_script *script, + struct grub2_word *top_word, + struct grub2_word *word) +{ + int i, len, delim_start = -1, delim_end = -1; + struct grub2_word *new_word; + char *remainder; + + len = strlen(word->text); + + /* Scan our string for the start of a delim (delim_start), and the + * start of any new text (delim_end). */ + for (i = 0; i < len; i++) { + if (is_delim(word->text[i])) { + if (delim_start == -1) + delim_start = i; + } else if (delim_start != -1) { + delim_end = i; + break; + } + } + + /* No delim? nothing to do. The process_expansions loop will + * append this word's text to the top word, if necessary + */ + if (delim_start == -1) + return; + + /* Set this word's text value to the text before the delimiter. + * this will get appended to the top word + */ + word->text[delim_start] = '\0'; + + /* No trailing text? If there are no following word tokens, we're done. + * Otherwise, we need to start a new argv item with those tokens */ + if (delim_end == -1) { + if (!word->next) + return; + remainder = ""; + } else { + remainder = word->text + delim_end; + } + + new_word = talloc(script, struct grub2_word); + new_word->type = GRUB2_WORD_TEXT; + /* if there's no trailing text, we know we don't need to re-split */ + new_word->split = delim_end != -1; + new_word->next = word->next; + new_word->last = NULL; + new_word->text = talloc_strdup(new_word, remainder); + + /* stitch it into the argv list before this word */ + list_insert_after(&top_word->argv_list, + &new_word->argv_list); + + /* terminate this word */ + word->next = NULL; +} + +/* iterate through the words in an argv_list, looking for GRUB2_WORD_VAR + * expansions. * * Once that's done, we may (if split == true) have to split the word to create * new argv items @@ -70,14 +145,49 @@ static bool expand_word(struct grub2_script *script, struct grub2_word *word) static void process_expansions(struct grub2_script *script, struct grub2_argv *argv) { - struct grub2_word *word; + struct grub2_word *top_word, *word; + int i; + + argv->argc = 0; + + list_for_each_entry(&argv->words, top_word, argv_list) { + argv->argc++; + + /* expand vars and squash the list of words into the head + * of the argv word list */ + for (word = top_word; word; word = word->next) { + + /* if it's a variable, perform the substitution */ + if (word->type == GRUB2_WORD_VAR) { + expand_var(script, word); + word->type = GRUB2_WORD_TEXT; + } - list_for_each_entry(&argv->words, word, argv_list) { - if (!word->expand) - continue; + /* split; this will potentially insert argv + * entries after top_word. */ + if (word->split) + process_split(script, top_word, word); - expand_word(script, word); + /* accumulate word text into the top word, so + * we end up with a shallow tree of argv data */ + /* todo: don't do this in process_split */ + if (word != top_word) { + top_word->text = talloc_asprintf_append( + top_word->text, + "%s", word->text); + } + + + } + top_word->next = NULL; } + + /* convert the list to an argv array, to pass to the function */ + argv->argv = talloc_array(script, char *, argv->argc); + i = 0; + + list_for_each_entry(&argv->words, word, argv_list) + argv->argv[i++] = word->text; } int statements_execute(struct grub2_script *script, @@ -97,13 +207,26 @@ int statement_simple_execute(struct grub2_script *script, struct grub2_statement *statement) { struct grub2_statement_simple *st = to_stmt_simple(statement); + struct grub2_command *cmd; + int rc; if (!st->argv) return 0; process_expansions(script, st->argv); - return 0; + if (!st->argv->argc) + return 0; + + cmd = script_lookup_command(script, st->argv->argv[0]); + if (!cmd) { + fprintf(stderr, "undefined command '%s'\n", st->argv->argv[0]); + return 0; + } + + rc = cmd->exec(script, st->argv->argc, st->argv->argv); + + return rc; } int statement_if_execute(struct grub2_script *script, @@ -128,6 +251,17 @@ int statement_if_execute(struct grub2_script *script, return rc; } +int statement_menuentry_execute(struct grub2_script *script, + struct grub2_statement *statement) +{ + struct grub2_statement_menuentry *st = to_stmt_menuentry(statement); + + process_expansions(script, st->argv); + statements_execute(script, st->statements); + + return 0; +} + static void init_env(struct grub2_script *script) { struct env_entry *env; @@ -141,40 +275,40 @@ static void init_env(struct grub2_script *script) list_add(&script->environment, &env->list); } +struct grub2_command *script_lookup_command(struct grub2_script *script, + const char *name) +{ + struct grub2_command *command; -void script_execute(struct grub2_script *script) + list_for_each_entry(&script->commands, command, list) { + if (!strcmp(command->name, name)) + return command; + } + + return NULL; +} + +void script_register_command(struct grub2_script *script, + struct grub2_command *command) { - statements_execute(script, script->statements); + list_add(&script->commands, &command->list); } -static int script_destroy(void *p) + +void script_execute(struct grub2_script *script) { - struct grub2_script *script = p; - regfree(&script->var_re); - return 0; + statements_execute(script, script->statements); } struct grub2_script *create_script(void *ctx) { struct grub2_script *script; - int rc; script = talloc(ctx, struct grub2_script); - rc = regcomp(&script->var_re, - "\\$\\{?([[:alpha:]][_[:alnum:]]*|[0-9]|[\\?@\\*#])\\}?", - REG_EXTENDED); - if (rc) { - char err[200]; - regerror(rc, &script->var_re, err, sizeof(err)); - fprintf(stderr, "RE error %d: %s\n", rc, err); - talloc_free(script); - return NULL; - - } - talloc_set_destructor(script, script_destroy); - init_env(script); + list_init(&script->commands); + register_builtins(script); return script; }