vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

merge with mainline

Browse source
This commit is contained in:
BVK Chaitanya 2010-06-12 20:36:46 +05:30
commit 20ebf73276
223 changed files with 8279 additions and 14993 deletions
Download patch file Download diff file Expand all files Collapse all files

48
normal/auth.c
View file

@ -133,25 +133,24 @@ static int
is_authenticated (const char *userlist)
{
const char *superusers;
auto int hook (grub_list_t item);
int hook (grub_list_t item)
{
const char *name;
if (!((struct grub_auth_user *) item)->authenticated)
return 0;
name = ((struct grub_auth_user *) item)->name;
return (userlist && grub_strword (userlist, name))
|| grub_strword (superusers, name);
}
struct grub_auth_user *user;
superusers = grub_env_get ("superusers");
if (!superusers)
return 1;
return grub_list_iterate (GRUB_AS_LIST (users), hook);
FOR_LIST_ELEMENTS (user, users)
{
if (!(user->authenticated))
continue;
if ((userlist && grub_strword (userlist, user->name))
|| grub_strword (superusers, user->name))
return 1;
}
return 0;
}
static int
@ -205,22 +204,7 @@ grub_auth_check_authentication (const char *userlist)
grub_err_t err;
static unsigned long punishment_delay = 1;
char entered[GRUB_AUTH_MAX_PASSLEN];
auto int hook (grub_list_t item);
int hook (grub_list_t item)
{
if (grub_strcmp (login, ((struct grub_auth_user *) item)->name) == 0)
cur = (struct grub_auth_user *) item;
return 0;
}
auto int hook_any (grub_list_t item);
int hook_any (grub_list_t item)
{
if (((struct grub_auth_user *) item)->callback)
cur = (struct grub_auth_user *) item;
return 0;
}
struct grub_auth_user *user;
grub_memset (login, 0, sizeof (login));
@ -240,7 +224,11 @@ grub_auth_check_authentication (const char *userlist)
if (!grub_password_get (entered, GRUB_AUTH_MAX_PASSLEN))
goto access_denied;
grub_list_iterate (GRUB_AS_LIST (users), hook);
FOR_LIST_ELEMENTS (user, users)
{
if (grub_strcmp (login, user->name) == 0)
cur = user;
}
if (!cur || ! cur->callback)
goto access_denied;

37
normal/completion.c
View file

@ -176,21 +176,6 @@ iterate_dev (const char *devname)
return 0;
}
static int
iterate_command (grub_command_t cmd)
{
if (cmd->prio & GRUB_PRIO_LIST_FLAG_ACTIVE)
{
if (cmd->flags & GRUB_COMMAND_FLAG_CMDLINE)
{
if (add_completion (cmd->name, " ", GRUB_COMPLETION_TYPE_COMMAND))
return 1;
}
}
return 0;
}
/* Complete a device. */
static int
complete_device (void)
@ -414,6 +399,14 @@ grub_normal_do_completion (char *buf, int *restore,
else
current_word = argv[argc - 1];
if (argc > 1 && ! grub_strcmp (argv[0], "set"))
{
char *equals = grub_strchr (current_word, '=');
if (equals)
/* Complete the value of the variable. */
current_word = equals + 1;
}
/* Determine the state the command line is in, depending on the
state, it can be determined how to complete. */
cmdline_state = get_state (buf);
@ -421,8 +414,18 @@ grub_normal_do_completion (char *buf, int *restore,
if (argc == 1 || argc == 0)
{
/* Complete a command. */
if (grub_command_iterate (iterate_command))
goto fail;
grub_command_t cmd;
FOR_COMMANDS(cmd)
{
if (cmd->prio & GRUB_PRIO_LIST_FLAG_ACTIVE)
{
if (cmd->flags & GRUB_COMMAND_FLAG_CMDLINE)
{
if (add_completion (cmd->name, " ", GRUB_COMPLETION_TYPE_COMMAND))
goto fail;
}
}
}
}
else if (*current_word == '-')
{

231
normal/handler.c
View file

@ -1,231 +0,0 @@
/* handler.c - support handler loading */
/*
* 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/mm.h>
#include <grub/err.h>
#include <grub/env.h>
#include <grub/misc.h>
#include <grub/command.h>
#include <grub/handler.h>
#include <grub/normal.h>
struct grub_handler_list
{
struct grub_handler_list *next;
char *name;
grub_command_t cmd;
};
static grub_list_t handler_list;
static grub_err_t
grub_handler_cmd (struct grub_command *cmd,
int argc __attribute__ ((unused)),
char **args __attribute__ ((unused)))
{
char *p;
grub_handler_class_t class;
grub_handler_t handler;
p = grub_strchr (cmd->name, '.');
if (! p)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid command name");
if (cmd->data)
{
if (! grub_dl_get (cmd->data))
{
grub_dl_t mod;
mod = grub_dl_load (cmd->data);
if (mod)
grub_dl_ref (mod);
else
return grub_errno;
}
grub_free (cmd->data);
cmd->data = 0;
}
*p = 0;
class = grub_named_list_find (GRUB_AS_NAMED_LIST (grub_handler_class_list),
cmd->name);
*p = '.';
if (! class)
return grub_error (GRUB_ERR_FILE_NOT_FOUND, "class not found");
handler = grub_named_list_find (GRUB_AS_NAMED_LIST (class->handler_list),
p + 1);
if (! handler)
return grub_error (GRUB_ERR_FILE_NOT_FOUND, "handler not found");
grub_handler_set_current (class, handler);
return 0;
}
static void
insert_handler (char *name, char *module)
{
struct grub_handler_list *item;
char *data;
if (grub_command_find (name))
return;
item = grub_malloc (sizeof (*item));
if (! item)
return;
item->name = grub_strdup (name);
if (! item->name)
{
grub_free (item);
return;
}
if (module)
{
data = grub_strdup (module);
if (! data)
{
grub_free (item->name);
grub_free (item);
return;
}
}
else
data = 0;
item->cmd = grub_register_command (item->name, grub_handler_cmd, 0,
"Set active handler.");
if (! item->cmd)
{
grub_free (data);
grub_free (item->name);
grub_free (item);
return;
}
item->cmd->data = data;
grub_list_push (&handler_list, GRUB_AS_LIST (item));
}
/* Read the file handler.lst for auto-loading. */
void
read_handler_list (void)
{
const char *prefix;
static int first_time = 1;
const char *class_name;
auto int iterate_handler (grub_handler_t handler);
int iterate_handler (grub_handler_t handler)
{
char name[grub_strlen (class_name) + grub_strlen (handler->name) + 2];
grub_strcpy (name, class_name);
grub_strcat (name, ".");
grub_strcat (name, handler->name);
insert_handler (name, 0);
return 0;
}
auto int iterate_class (grub_handler_class_t class);
int iterate_class (grub_handler_class_t class)
{
class_name = class->name;
grub_list_iterate (GRUB_AS_LIST (class->handler_list),
(grub_list_hook_t) iterate_handler);
return 0;
}
/* Make sure that this function does not get executed twice. */
if (! first_time)
return;
first_time = 0;
prefix = grub_env_get ("prefix");
if (prefix)
{
char *filename;
filename = grub_xasprintf ("%s/handler.lst", prefix);
if (filename)
{
grub_file_t file;
file = grub_file_open (filename);
if (file)
{
char *buf = NULL;
for (;; grub_free (buf))
{
char *p;
buf = grub_file_getline (file);
if (! buf)
break;
if (! grub_isgraph (buf[0]))
continue;
p = grub_strchr (buf, ':');
if (! p)
continue;
*p = '\0';
while (*++p == ' ')
;
insert_handler (buf, p);
}
grub_file_close (file);
}
grub_free (filename);
}
}
grub_list_iterate (GRUB_AS_LIST (grub_handler_class_list),
(grub_list_hook_t) iterate_class);
/* Ignore errors. */
grub_errno = GRUB_ERR_NONE;
}
void
free_handler_list (void)
{
struct grub_handler_list *item;
while ((item = grub_list_pop (&handler_list)) != 0)
{
grub_free (item->cmd->data);
grub_unregister_command (item->cmd);
grub_free (item->name);
grub_free (item);
}
}

57
normal/main.c
View file

@ -31,6 +31,7 @@
#include <grub/auth.h>
#include <grub/i18n.h>
#include <grub/charset.h>
#include <grub/script_sh.h>
#define GRUB_DEFAULT_HISTORY_SIZE 50
@ -204,7 +205,7 @@ grub_normal_add_menu_entry (int argc, const char **args,
for (i = 0; i < argc; i++)
{
/* Capture arguments. */
if (grub_strncmp ("--", args[i], 2) == 0)
if (grub_strncmp ("--", args[i], 2) == 0 && i + 1 < argc)
{
const char *arg = &args[i][2];
@ -347,7 +348,6 @@ static grub_menu_t
read_config_file (const char *config)
{
grub_file_t file;
grub_parser_t old_parser = 0;
auto grub_err_t getline (char **line, int cont);
grub_err_t getline (char **line, int cont __attribute__ ((unused)))
@ -361,36 +361,7 @@ read_config_file (const char *config)
return grub_errno;
if (buf[0] == '#')
{
if (buf[1] == '!')
{
grub_parser_t parser;
grub_named_list_t list;
buf += 2;
while (grub_isspace (*buf))
buf++;
if (! old_parser)
old_parser = grub_parser_get_current ();
list = GRUB_AS_NAMED_LIST (grub_parser_class.handler_list);
parser = grub_named_list_find (list, buf);
if (parser)
grub_parser_set_current (parser);
else
{
char cmd_name[8 + grub_strlen (buf)];
/* Perhaps it's not loaded yet, try the autoload
command. */
grub_strcpy (cmd_name, "parser.");
grub_strcat (cmd_name, buf);
grub_command_execute (cmd_name, 0, 0);
}
}
grub_free (*line);
}
grub_free (*line);
else
break;
}
@ -426,15 +397,12 @@ read_config_file (const char *config)
if ((getline (&line, 0)) || (! line))
break;
grub_parser_get_current ()->parse_line (line, getline);
grub_normal_parse_line (line, getline);
grub_free (line);
}
grub_file_close (file);
if (old_parser)
grub_parser_set_current (old_parser);
return newmenu;
}
@ -499,7 +467,6 @@ grub_normal_execute (const char *config, int nested, int batch)
const char *prefix = grub_env_get ("prefix");
read_lists (prefix);
read_handler_list ();
grub_register_variable_hook ("prefix", NULL, read_lists_hook);
grub_command_execute ("parser.grub", 0, 0);
@ -605,17 +572,15 @@ grub_normal_reader_init (int nested)
return 0;
}
static grub_err_t
grub_normal_read_line_real (char **line, int cont, int nested)
{
grub_parser_t parser = grub_parser_get_current ();
char *prompt;
const char *prompt;
if (cont)
prompt = grub_xasprintf (">");
prompt = ">";
else
prompt = grub_xasprintf ("%s>", parser->name);
prompt = "grub>";
if (!prompt)
return grub_errno;
@ -629,14 +594,11 @@ grub_normal_read_line_real (char **line, int cont, int nested)
if (cont || nested)
{
grub_free (*line);
grub_free (prompt);
*line = 0;
return grub_errno;
}
}
grub_free (prompt);
return 0;
}
@ -677,7 +639,7 @@ grub_cmdline_run (int nested)
if (! line)
break;
grub_parser_get_current ()->parse_line (line, grub_normal_read_line);
grub_normal_parse_line (line, grub_normal_read_line);
grub_free (line);
}
}
@ -693,6 +655,7 @@ grub_env_write_pager (struct grub_env_var *var __attribute__ ((unused)),
GRUB_MOD_INIT(normal)
{
grub_context_init ();
grub_script_init ();
/* Normal mode shouldn't be unloaded. */
if (mod)
@ -721,9 +684,9 @@ GRUB_MOD_INIT(normal)
GRUB_MOD_FINI(normal)
{
grub_context_fini ();
grub_script_fini ();
grub_set_history (0);
grub_register_variable_hook ("pager", 0, 0);
grub_fs_autoload_hook = 0;
free_handler_list ();
}

3
normal/menu_entry.c
View file

@ -23,6 +23,7 @@
#include <grub/loader.h>
#include <grub/command.h>
#include <grub/parser.h>
#include <grub/script_sh.h>
#include <grub/auth.h>
#include <grub/i18n.h>
@ -1189,7 +1190,7 @@ run (struct screen *screen)
while (currline < screen->num_lines)
{
editor_getline (&nextline, 0);
if (grub_parser_get_current ()->parse_line (nextline, editor_getline))
if (grub_normal_parse_line (nextline, editor_getline))
break;
}