grub/grub-core/osdep/windows/hostdisk.c

258 lines
5.8 KiB
C
Raw Normal View History

/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 1999,2000,2001,2002,2003,2004,2006,2007,2008,2009,2010,2011,2012,2013 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 <config-util.h>
#include <grub/disk.h>
#include <grub/partition.h>
#include <grub/msdos_partition.h>
#include <grub/types.h>
#include <grub/err.h>
#include <grub/emu/misc.h>
#include <grub/emu/hostdisk.h>
#include <grub/emu/getroot.h>
#include <grub/misc.h>
#include <grub/i18n.h>
#include <grub/list.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <limits.h>
#include <grub/util/windows.h>
#include <grub/charset.h>
#include <windows.h>
#include <winioctl.h>
#ifdef __CYGWIN__
LPTSTR
grub_util_get_windows_path (const char *path)
{
LPTSTR winpath;
winpath = xmalloc (sizeof (winpath[0]) * PATH_MAX);
if (cygwin_conv_path ((sizeof (winpath[0]) == 1 ? CCP_POSIX_TO_WIN_A
: CCP_POSIX_TO_WIN_W) | CCP_ABSOLUTE, path, winpath,
sizeof (winpath[0]) * PATH_MAX))
grub_util_error ("%s", _("cygwin_conv_path() failed"));
return winpath;
}
#else
LPTSTR
grub_util_get_windows_path (const char *path)
{
char *fpa;
const char *fp;
LPTSTR ret;
fp = fpa = xmalloc (PATH_MAX);
if (!_fullpath (fpa, path, PATH_MAX))
fp = path;
#if SIZEOF_TCHAR == 1
ret = xstrdup (fp);
#elif SIZEOF_TCHAR == 2
size_t ssz = strlen (fp);
size_t tsz = 2 * (GRUB_MAX_UTF16_PER_UTF8 * ssz + 1);
ret = xmalloc (tsz);
tsz = grub_utf8_to_utf16 (ret, tsz, (const grub_uint8_t *) fp, ssz, NULL);
ret[tsz] = 0;
#else
#error SIZEOF_TCHAR
#error "Unsupported TCHAR size"
#endif
free (fpa);
return ret;
}
#endif
grub_uint64_t
grub_util_get_fd_size (grub_util_fd_t hd, const char *name_in,
unsigned *log_secsize)
{
grub_int64_t size = -1LL;
int log_sector_size = 9;
LPTSTR name = grub_util_get_windows_path (name_in);
if (log_secsize)
*log_secsize = log_sector_size;
if (((name[0] == '/') || (name[0] == '\\')) &&
((name[1] == '/') || (name[1] == '\\')) &&
((name[2] == '.') || (name[2] == '?')) &&
((name[3] == '/') || (name[3] == '\\')))
{
DWORD nr;
DISK_GEOMETRY g;
if (! DeviceIoControl (hd, IOCTL_DISK_GET_DRIVE_GEOMETRY,
0, 0, &g, sizeof (g), &nr, 0))
goto fail;
size = g.Cylinders.QuadPart;
size *= g.TracksPerCylinder * g.SectorsPerTrack * g.BytesPerSector;
for (log_sector_size = 0;
(1 << log_sector_size) < g.BytesPerSector;
log_sector_size++);
}
else
{
ULARGE_INTEGER s;
s.LowPart = GetFileSize (hd, &s.HighPart);
size = s.QuadPart;
}
fail:
if (log_secsize)
*log_secsize = log_sector_size;
free (name);
return size;
}
void
grub_hostdisk_configure_device_driver (grub_util_fd_t fd __attribute__ ((unused)))
{
}
void
grub_hostdisk_flush_initial_buffer (const char *os_dev __attribute__ ((unused)))
{
}
grub_err_t
grub_util_fd_seek (grub_util_fd_t fd, const char *name, grub_uint64_t off)
{
LARGE_INTEGER offset;
offset.QuadPart = off;
if (!SetFilePointerEx (fd, offset, NULL, FILE_BEGIN))
return grub_error (GRUB_ERR_BAD_DEVICE, N_("cannot seek `%s': %s"),
name, strerror (errno));
return 0;
}
grub_util_fd_t
grub_util_fd_open (const char *os_dev, int flags)
{
DWORD flg = 0;
LPTSTR dev = grub_util_get_windows_path (os_dev);
grub_util_fd_t ret;
if (flags & O_WRONLY)
flg |= GENERIC_WRITE;
if (flags & O_RDONLY)
flg |= GENERIC_READ;
flg = GENERIC_READ;
ret = CreateFile (dev, flg, FILE_SHARE_READ | FILE_SHARE_WRITE,
0, OPEN_EXISTING, 0, 0);
free (dev);
grub_util_info ("handle = %p", ret);
return ret;
}
ssize_t
grub_util_fd_read (grub_util_fd_t fd, char *buf, size_t len)
{
DWORD real_read;
if (!ReadFile(fd, buf, len, &real_read, NULL))
{
grub_util_info ("read err %x", (int) GetLastError ());
return -1;
}
grub_util_info ("successful read");
return real_read;
}
ssize_t
grub_util_fd_write (grub_util_fd_t fd, const char *buf, size_t len)
{
DWORD real_read;
if (!WriteFile(fd, buf, len, &real_read, NULL))
{
grub_util_info ("write err %x", (int) GetLastError ());
return -1;
}
grub_util_info ("successful write");
return real_read;
}
void
grub_util_fd_sync (grub_util_fd_t fd)
{
FlushFileBuffers (fd);
}
void
grub_util_fd_close (grub_util_fd_t fd)
{
CloseHandle (fd);
}
const char *
grub_util_fd_strerror (void)
{
DWORD err;
static TCHAR tbuf[1024];
err = GetLastError ();
FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, err,
MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
tbuf, ARRAY_SIZE (tbuf), NULL);
#if SIZEOF_TCHAR == 1
return (char *) tbuf;
#elif SIZEOF_TCHAR == 2
static grub_uint8_t buf[ARRAY_SIZE (tbuf) * GRUB_MAX_UTF8_PER_UTF16 + 1];
*grub_utf16_to_utf8 (buf, tbuf, ARRAY_SIZE (tbuf)) = '\0';
return (char *) buf;
#else
#error "Unsupported TCHAR size"
#endif
}
char *
canonicalize_file_name (const char *path)
{
char *ret;
ret = xmalloc (PATH_MAX);
#ifndef __CYGWIN__
if (!_fullpath (ret, path, PATH_MAX))
return NULL;
#else
if (!realpath (path, ret))
return NULL;
#endif
return ret;
}