/* file.c - file I/O functions */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2002,2006,2007,2009 Free Software Foundation, Inc.
* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
*
* 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/misc.h>
#include <grub/err.h>
#include <grub/file.h>
#include <grub/net.h>
#include <grub/mm.h>
#include <grub/fs.h>
#include <grub/time.h>
#include <grub/env.h>
#include <grub/device.h>
#define SUPPORT_PROGRESS
#ifdef SUPPORT_PROGRESS
#include <grub/term.h>
#endif
void (*EXPORT_VAR (grub_grubnet_fini)) (void);
int grub_file_force_not_easily_seekable;
int grub_print_progress;
grub_file_filter_t grub_file_filters_all[GRUB_FILE_FILTER_MAX];
grub_file_filter_t grub_file_filters_enabled[GRUB_FILE_FILTER_MAX];
/* Get the device part of the filename NAME. It is enclosed by parentheses. */
char *
grub_file_get_device_name (const char *name)
{
if (name[0] == '(')
{
char *p = grub_strchr (name, ')');
char *ret;
if (! p)
{
grub_error (GRUB_ERR_BAD_FILENAME, "missing `)'");
return 0;
}
ret = (char *) grub_malloc (p - name);
if (! ret)
return 0;
grub_memcpy (ret, name + 1, p - name - 1);
ret[p - name - 1] = '\0';
return ret;
}
return 0;
}
grub_file_t
grub_file_open (const char *name)
{
grub_device_t device = 0;
grub_file_t file = 0, last_file = 0;
char *device_name;
char *file_name;
grub_file_filter_id_t filter;
device_name = grub_file_get_device_name (name);
if (grub_errno)
goto fail;
/* Get the file part of NAME. */
file_name = (name[0] == '(') ? grub_strchr (name, ')') : NULL;
if (file_name)
file_name++;
else
file_name = (char *) name;
device = grub_device_open (device_name);
grub_free (device_name);
if (! device)
goto fail;
file = (grub_file_t) grub_zalloc (sizeof (*file));
if (! file)
goto fail;
file->device = device;
if (device->disk && file_name[0] != '/')
/* This is a block list. */
file->fs = &grub_fs_blocklist;
else
{
file->fs = grub_fs_probe (device);
if (! file->fs)
goto fail;
}
{
const char *noprogress = grub_env_get("grub_file_noprogress");
file->enable_progress = noprogress ? 0 : grub_print_progress;
}
grub_print_progress = 0;
if ((file->fs->open) (file, file_name) != GRUB_ERR_NONE)
goto fail;
for (filter = 0; file && filter < ARRAY_SIZE (grub_file_filters_enabled);
filter++)
if (grub_file_filters_enabled[filter])
{
last_file = file;
file = grub_file_filters_enabled[filter] (file);
}
if (!file)
grub_file_close (last_file);
grub_memcpy (grub_file_filters_enabled, grub_file_filters_all,
sizeof (grub_file_filters_enabled));
grub_file_force_not_easily_seekable = 0;
return file;
fail:
if (device)
grub_device_close (device);
/* if (net) grub_net_close (net); */
grub_free (file);
grub_memcpy (grub_file_filters_enabled, grub_file_filters_all,
sizeof (grub_file_filters_enabled));
return 0;
}
#define PROGRESS_THRESHOLD (2000) /* 2s */
#define PROGRESS_BLOCKSIZE (32*1024)
void
grub_file_progress_hook(grub_file_t file, grub_size_t amt_read, int done)
{
grub_uint64_t curtime;
grub_off_t filesz;
if (file == NULL || !file->enable_progress)
return;
if (done)
{
file->enable_progress = 0;
grub_printf("done.\n");
grub_refresh();
return;
}
curtime = grub_get_time_ms();
file->progress_counter += amt_read;
filesz = grub_file_size(file);
if (file->progress_last == 0 ||
(curtime - file->progress_last) >= PROGRESS_THRESHOLD ||
file->progress_counter == filesz)
{
grub_dprintf("progress", "counter = 0x%llx | last = 0x%llx\n",
(unsigned long long) file->progress_counter,
(unsigned long long) file->progress_last);
file->progress_last = curtime;
if (filesz == 0 || file->progress_counter > filesz)
grub_printf("...");
else
{
unsigned pct = grub_divmod64(file->progress_counter * 100,
filesz, 0);
grub_printf("%u%%...", pct);
grub_dprintf("progress", "pct completed is %u\n", pct);
}
grub_refresh();
}
}
grub_ssize_t
grub_file_read (grub_file_t file, void *buf, grub_size_t len)
{
grub_ssize_t res;
#ifdef SUPPORT_PROGRESS
grub_ssize_t amt_read;
grub_size_t readsz;
#endif
if (!file->is_size_approximate)
{
if (file->offset > file->size)
{
grub_error (GRUB_ERR_OUT_OF_RANGE,
"attempt to read past the end of file");
return -1;
}
if (len == 0 || len > file->size - file->offset)
len = file->size - file->offset;
/* Prevent an overflow. */
if ((grub_ssize_t) len < 0)
len >>= 1;
if (len == 0)
return 0;
}
#ifdef SUPPORT_PROGRESS
if (!file->enable_progress || grub_strcmp(file->fs->name, "netfs") == 0)
{
#endif
res = (file->fs->read) (file, buf, len);
if (res > 0)
file->offset += res;
#ifdef SUPPORT_PROGRESS
}
else
{
char *buffer = buf;
grub_size_t remaining = len;
res = 0;
do
{
readsz = remaining;
if (readsz > PROGRESS_BLOCKSIZE)
readsz = PROGRESS_BLOCKSIZE;
amt_read = (file->fs->read) (file, buffer, readsz);
if (amt_read < 0)
{
res = amt_read;
break;
}
remaining -= amt_read;
buffer += amt_read;
res += amt_read;
file->offset += amt_read;
grub_file_progress_hook(file, amt_read, 0);
} while (remaining > 0 && (grub_size_t)amt_read == readsz);
}
#endif
return res;
}
grub_err_t
grub_file_close (grub_file_t file)
{
if (file->fs->close)
(file->fs->close) (file);
if (file->device)
grub_device_close (file->device);
#ifdef SUPPORT_PROGRESS
grub_file_progress_hook(file, 0, 1);
#endif
grub_free (file);
return grub_errno;
}
grub_off_t
grub_file_seek (grub_file_t file, grub_off_t offset)
{
grub_off_t old;
if (offset > file->size)
{
grub_error (GRUB_ERR_OUT_OF_RANGE,
"attempt to seek outside of the file");
return -1;
}
old = file->offset;
file->offset = offset;
return old;
}