static grub_err_t
grub_ls_list_devices (int longlist)
{
grub_device_iterate (grub_ls_print_devices, &longlist);
grub_xputs ("\n");
#if 0
{
grub_net_app_level_t proto;
int first = 1;
FOR_NET_APP_LEVEL (proto)
{
if (first)
grub_puts_ (N_ ("Network protocols:"));
first = 0;
grub_printf ("%s ", proto->name);
}
grub_xputs ("\n");
}
#endif
grub_refresh ();
return 0;
}
/* Wait until the user pushes any key so that the user
can see what happened. */
void
grub_wait_after_message (void)
{
grub_uint64_t endtime;
grub_xputs ("\n");
grub_printf_ (N_("Press any key to continue..."));
grub_refresh ();
endtime = grub_get_time_ms () + 10000;
while (grub_get_time_ms () < endtime
&& grub_getkey_noblock () == GRUB_TERM_NO_KEY);
grub_xputs ("\n");
}
int
grub_vprintf (const char *fmt, va_list args)
{
grub_size_t s;
static char buf[PREALLOC_SIZE + 1];
char *curbuf = buf;
va_list ap2;
va_copy (ap2, args);
s = grub_vsnprintf_real (buf, PREALLOC_SIZE, fmt, args);
if (s > PREALLOC_SIZE)
{
curbuf = grub_malloc (s + 1);
if (!curbuf)
{
grub_errno = GRUB_ERR_NONE;
buf[PREALLOC_SIZE - 3] = '.';
buf[PREALLOC_SIZE - 2] = '.';
buf[PREALLOC_SIZE - 1] = '.';
buf[PREALLOC_SIZE] = 0;
}
else
s = grub_vsnprintf_real (curbuf, s, fmt, ap2);
}
grub_xputs (curbuf);
if (curbuf != buf)
grub_free (curbuf);
return s;
}
void NESTED_FUNC_ATTR read_func (grub_disk_addr_t sector __attribute__ ((unused)),
unsigned offset __attribute__ ((unused)),
unsigned len __attribute__ ((unused)))
{
grub_xputs (".");
grub_refresh ();
}
/* Prompt to input a command and read the line. */
static grub_err_t
grub_rescue_read_line (char **line, int cont)
{
int c;
int pos = 0;
char str[4];
grub_printf ((cont) ? "> " : "grub rescue> ");
grub_memset (linebuf, 0, GRUB_RESCUE_BUF_SIZE);
while ((c = grub_getkey ()) != '\n' && c != '\r')
{
if (grub_isprint (c))
{
if (pos < GRUB_RESCUE_BUF_SIZE - 1)
{
str[0] = c;
str[1] = 0;
linebuf[pos++] = c;
grub_xputs (str);
}
}
else if (c == '\b')
{
if (pos > 0)
{
str[0] = c;
str[1] = ' ';
str[2] = c;
str[3] = 0;
linebuf[--pos] = 0;
grub_xputs (str);
}
}
grub_refresh ();
}
grub_xputs ("\n");
grub_refresh ();
*line = grub_strdup (linebuf);
return 0;
}
/* Wait until the user pushes any key so that the user
can see what happened. */
void
grub_wait_after_message (void)
{
grub_uint64_t endtime;
grub_xputs ("\n");
grub_printf_ (N_("Press any key to continue..."));
grub_refresh ();
endtime = grub_get_time_ms () + 10000;
while (grub_get_time_ms () < endtime)
if (grub_checkkey () >= 0)
{
grub_getkey ();
break;
}
grub_xputs ("\n");
}
int fputs(const char *s, FILE *stream)
{
grub_errno = GRUB_ERR_NONE;
if (stream != stdout && stream != stderr) {
grub_printf("Internal error: Python attempted to write to a file.\n");
return EOF;
}
grub_xputs(s);
return 1;
}
static grub_err_t
grub_cmd_cat (grub_extcmd_context_t ctxt, int argc, char **args)
{
struct grub_arg_list *state = ctxt->state;
int dos = 0;
grub_file_t file;
char buf[GRUB_DISK_SECTOR_SIZE];
grub_ssize_t size;
int key = 0;
if (state[0].set)
dos = 1;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
file = grub_file_open (args[0]);
if (! file)
return grub_errno;
while ((size = grub_file_read (file, buf, sizeof (buf))) > 0
&& key != GRUB_TERM_ESC)
{
int i;
for (i = 0; i < size; i++)
{
unsigned char c = buf[i];
if ((grub_isprint (c) || grub_isspace (c)) && c != '\r')
grub_printf ("%c", c);
else if (dos && c == '\r' && i + 1 < size && buf[i + 1] == '\n')
{
grub_printf ("\n");
i++;
}
else
{
grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
grub_printf ("<%x>", (int) c);
grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
}
}
while (grub_checkkey () >= 0 &&
(key = grub_getkey ()) != GRUB_TERM_ESC)
;
}
grub_xputs ("\n");
grub_refresh ();
grub_file_close (file);
return 0;
}
int fputc(int c, FILE *stream)
{
const char s[] = { (unsigned char)c, '\0' };
grub_errno = GRUB_ERR_NONE;
if (stream != stdout && stream != stderr) {
grub_printf("Internal error: Python attempted to write to a file.\n");
return EOF;
}
grub_xputs(s);
return (unsigned char)c;
}
static grub_err_t
grub_ls_list_devices (int longlist)
{
auto int grub_ls_print_devices (const char *name);
int grub_ls_print_devices (const char *name)
{
if (longlist)
grub_normal_print_device_info (name);
else
grub_printf ("(%s) ", name);
return 0;
}
grub_device_iterate (grub_ls_print_devices);
grub_xputs ("\n");
#if 0
{
grub_net_app_level_t proto;
int first = 1;
FOR_NET_APP_LEVEL (proto)
{
if (first)
grub_puts_ (N_ ("Network protocols:"));
first = 0;
grub_printf ("%s ", proto->name);
}
grub_xputs ("\n");
}
#endif
grub_refresh ();
return 0;
}
int
grub_password_get (char buf[], unsigned buf_size)
{
FILE *in;
struct termios s, t;
int tty_changed = 0;
char *ptr;
grub_refresh ();
/* Disable echoing. Based on glibc. */
in = fopen ("/dev/tty", "w+c");
if (in == NULL)
in = stdin;
if (tcgetattr (fileno (in), &t) == 0)
{
/* Save the old one. */
s = t;
/* Tricky, tricky. */
t.c_lflag &= ~(ECHO|ISIG);
tty_changed = (tcsetattr (fileno (in), TCSAFLUSH, &t) == 0);
}
else
tty_changed = 0;
grub_memset (buf, 0, buf_size);
if (!fgets (buf, buf_size, stdin))
return 0;
ptr = buf + strlen (buf) - 1;
while (buf <= ptr && (*ptr == '\n' || *ptr == '\r'))
*ptr-- = 0;
/* Restore the original setting. */
if (tty_changed)
(void) tcsetattr (fileno (in), TCSAFLUSH, &s);
grub_xputs ("\n");
grub_refresh ();
return 1;
}
/* Print the information on the device NAME. */
grub_err_t
grub_normal_print_device_info (const char *name)
{
grub_device_t dev;
char *p;
p = grub_strchr (name, ',');
if (p)
{
grub_xputs ("\t");
grub_printf_ (N_("Partition %s:"), name);
grub_xputs (" ");
}
else
{
grub_printf_ (N_("Device %s:"), name);
grub_xputs (" ");
}
dev = grub_device_open (name);
if (! dev)
grub_printf ("%s", _("Filesystem cannot be accessed"));
else if (dev->disk)
{
grub_fs_t fs;
fs = grub_fs_probe (dev);
/* Ignore all errors. */
grub_errno = 0;
if (fs)
{
grub_printf_ (N_("Filesystem type %s"), fs->name);
if (fs->label)
{
char *label;
(fs->label) (dev, &label);
if (grub_errno == GRUB_ERR_NONE)
{
if (label && grub_strlen (label))
{
grub_xputs (" ");
grub_printf_ (N_("- Label \"%s\""), label);
}
grub_free (label);
}
grub_errno = GRUB_ERR_NONE;
}
if (fs->mtime)
{
grub_int32_t tm;
struct grub_datetime datetime;
(fs->mtime) (dev, &tm);
if (grub_errno == GRUB_ERR_NONE)
{
grub_unixtime2datetime (tm, &datetime);
grub_xputs (" ");
grub_printf_ (N_("- Last modification time %d-%02d-%02d "
"%02d:%02d:%02d %s"),
datetime.year, datetime.month, datetime.day,
datetime.hour, datetime.minute, datetime.second,
grub_get_weekday_name (&datetime));
}
grub_errno = GRUB_ERR_NONE;
}
if (fs->uuid)
{
char *uuid;
(fs->uuid) (dev, &uuid);
if (grub_errno == GRUB_ERR_NONE)
{
if (uuid && grub_strlen (uuid))
grub_printf (", UUID %s", uuid);
grub_free (uuid);
}
grub_errno = GRUB_ERR_NONE;
}
}
else if (! dev->disk->has_partitions || dev->disk->partition)
grub_printf ("%s", _("Unknown filesystem"));
else
grub_printf ("%s", _("Partition table"));
grub_device_close (dev);
}
grub_xputs ("\n");
return grub_errno;
}
static grub_err_t
grub_ls_list_files (char *dirname, int longlist, int all, int human)
{
char *device_name;
grub_fs_t fs;
const char *path;
grub_device_t dev;
device_name = grub_file_get_device_name (dirname);
dev = grub_device_open (device_name);
if (! dev)
goto fail;
fs = grub_fs_probe (dev);
path = grub_strchr (dirname, ')');
if (! path)
path = dirname;
else
path++;
if (! path && ! device_name)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
goto fail;
}
if (! *path)
{
if (grub_errno == GRUB_ERR_UNKNOWN_FS)
grub_errno = GRUB_ERR_NONE;
grub_normal_print_device_info (device_name);
}
else if (fs)
{
struct grub_ls_list_files_ctx ctx = {
.dirname = dirname,
.all = all,
.human = human
};
if (longlist)
(fs->dir) (dev, path, print_files_long, &ctx);
else
(fs->dir) (dev, path, print_files, &ctx);
if (grub_errno == GRUB_ERR_BAD_FILE_TYPE
&& path[grub_strlen (path) - 1] != '/')
{
/* PATH might be a regular file. */
char *p;
grub_file_t file;
struct grub_dirhook_info info;
grub_errno = 0;
grub_file_filter_disable_compression ();
file = grub_file_open (dirname);
if (! file)
goto fail;
grub_file_close (file);
p = grub_strrchr (dirname, '/') + 1;
dirname = grub_strndup (dirname, p - dirname);
if (! dirname)
goto fail;
all = 1;
grub_memset (&info, 0, sizeof (info));
if (longlist)
print_files_long (p, &info, &ctx);
else
print_files (p, &info, &ctx);
grub_free (dirname);
}
if (grub_errno == GRUB_ERR_NONE)
grub_xputs ("\n");
grub_refresh ();
}
fail:
if (dev)
grub_device_close (dev);
grub_free (device_name);
return 0;
}
static grub_err_t
grub_ls_list_files (char *dirname, int longlist, int all, int human)
{
char *device_name;
grub_fs_t fs;
const char *path;
grub_device_t dev;
auto int print_files (const char *filename,
const struct grub_dirhook_info *info);
auto int print_files_long (const char *filename,
const struct grub_dirhook_info *info);
int print_files (const char *filename, const struct grub_dirhook_info *info)
{
if (all || filename[0] != '.')
grub_printf ("%s%s ", filename, info->dir ? "/" : "");
return 0;
}
int print_files_long (const char *filename,
const struct grub_dirhook_info *info)
{
if ((! all) && (filename[0] == '.'))
return 0;
if (! info->dir)
{
grub_file_t file;
char *pathname;
if (dirname[grub_strlen (dirname) - 1] == '/')
pathname = grub_xasprintf ("%s%s", dirname, filename);
else
pathname = grub_xasprintf ("%s/%s", dirname, filename);
if (!pathname)
return 1;
/* XXX: For ext2fs symlinks are detected as files while they
should be reported as directories. */
grub_file_filter_disable_compression ();
file = grub_file_open (pathname);
if (! file)
{
grub_errno = 0;
grub_free (pathname);
return 0;
}
if (! human)
grub_printf ("%-12llu", (unsigned long long) file->size);
else
{
grub_uint64_t fsize = file->size * 100ULL;
grub_uint64_t fsz = file->size;
int units = 0;
char buf[20];
while (fsz / 1024)
{
fsize = (fsize + 512) / 1024;
fsz /= 1024;
units++;
}
if (units)
{
grub_uint64_t whole, fraction;
whole = grub_divmod64 (fsize, 100, &fraction);
grub_snprintf (buf, sizeof (buf),
"%" PRIuGRUB_UINT64_T
".%02" PRIuGRUB_UINT64_T "%c", whole, fraction,
grub_human_sizes[units]);
grub_printf ("%-12s", buf);
}
else
grub_printf ("%-12llu", (unsigned long long) file->size);
}
grub_file_close (file);
grub_free (pathname);
}
else
grub_printf ("%-12s", _("DIR"));
if (info->mtimeset)
{
struct grub_datetime datetime;
grub_unixtime2datetime (info->mtime, &datetime);
if (human)
grub_printf (" %d-%02d-%02d %02d:%02d:%02d %-11s ",
datetime.year, datetime.month, datetime.day,
datetime.hour, datetime.minute,
datetime.second,
grub_get_weekday_name (&datetime));
else
grub_printf (" %04d%02d%02d%02d%02d%02d ",
datetime.year, datetime.month,
datetime.day, datetime.hour,
datetime.minute, datetime.second);
}
grub_printf ("%s%s\n", filename, info->dir ? "/" : "");
return 0;
}
device_name = grub_file_get_device_name (dirname);
dev = grub_device_open (device_name);
if (! dev)
goto fail;
fs = grub_fs_probe (dev);
path = grub_strchr (dirname, ')');
if (! path)
path = dirname;
else
path++;
if (! path && ! device_name)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
goto fail;
}
if (! *path)
{
if (grub_errno == GRUB_ERR_UNKNOWN_FS)
grub_errno = GRUB_ERR_NONE;
grub_normal_print_device_info (device_name);
}
else if (fs)
{
if (longlist)
(fs->dir) (dev, path, print_files_long);
else
(fs->dir) (dev, path, print_files);
if (grub_errno == GRUB_ERR_BAD_FILE_TYPE
&& path[grub_strlen (path) - 1] != '/')
{
/* PATH might be a regular file. */
char *p;
grub_file_t file;
struct grub_dirhook_info info;
grub_errno = 0;
grub_file_filter_disable_compression ();
file = grub_file_open (dirname);
if (! file)
goto fail;
grub_file_close (file);
p = grub_strrchr (dirname, '/') + 1;
dirname = grub_strndup (dirname, p - dirname);
if (! dirname)
goto fail;
all = 1;
grub_memset (&info, 0, sizeof (info));
if (longlist)
print_files_long (p, &info);
else
print_files (p, &info);
grub_free (dirname);
}
if (grub_errno == GRUB_ERR_NONE)
grub_xputs ("\n");
grub_refresh ();
}
fail:
if (dev)
grub_device_close (dev);
grub_free (device_name);
return 0;
}
static grub_err_t
grub_cmd_cat (grub_extcmd_context_t ctxt, int argc, char **args)
{
struct grub_arg_list *state = ctxt->state;
int dos = 0;
grub_file_t file;
unsigned char buf[GRUB_DISK_SECTOR_SIZE];
grub_ssize_t size;
int key = GRUB_TERM_NO_KEY;
grub_uint32_t code = 0;
int count = 0;
unsigned char utbuf[GRUB_MAX_UTF8_PER_CODEPOINT + 1];
int utcount = 0;
int is_0d = 0;
int j;
if (state[0].set)
dos = 1;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
file = grub_file_open (args[0], GRUB_FILE_TYPE_CAT);
if (! file)
return grub_errno;
while ((size = grub_file_read (file, buf, sizeof (buf))) > 0
&& key != GRUB_TERM_ESC)
{
int i;
for (i = 0; i < size; i++)
{
utbuf[utcount++] = buf[i];
if (is_0d && buf[i] != '\n')
{
grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
grub_printf ("<%x>", (int) '\r');
grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
}
is_0d = 0;
if (!grub_utf8_process (buf[i], &code, &count))
{
grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
for (j = 0; j < utcount - 1; j++)
grub_printf ("<%x>", (unsigned int) utbuf[j]);
code = 0;
count = 0;
if (utcount == 1 || !grub_utf8_process (buf[i], &code, &count))
{
grub_printf ("<%x>", (unsigned int) buf[i]);
code = 0;
count = 0;
utcount = 0;
grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
continue;
}
grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
utcount = 1;
}
if (count)
continue;
if ((code >= 0xa1 || grub_isprint (code)
|| grub_isspace (code)) && code != '\r')
{
grub_printf ("%C", code);
count = 0;
code = 0;
utcount = 0;
continue;
}
if (dos && code == '\r')
{
is_0d = 1;
count = 0;
code = 0;
utcount = 0;
continue;
}
grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
for (j = 0; j < utcount; j++)
grub_printf ("<%x>", (unsigned int) utbuf[j]);
grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
count = 0;
code = 0;
utcount = 0;
}
do
key = grub_getkey_noblock ();
while (key != GRUB_TERM_ESC && key != GRUB_TERM_NO_KEY);
}
if (is_0d)
{
grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
grub_printf ("<%x>", (unsigned int) '\r');
grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
}
if (utcount)
{
grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
for (j = 0; j < utcount; j++)
grub_printf ("<%x>", (unsigned int) utbuf[j]);
grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
}
grub_xputs ("\n");
grub_refresh ();
grub_file_close (file);
return 0;
}
