/* * GRUB -- GRand Unified Bootloader * Copyright (C) 2002,2003,2005,2006,2007,2008,2009,2010 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 . */ #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_LIMITS_H #include #endif #include #include #include #include #include #include #include #include #include #define ENABLE_RELOCATABLE 0 #include "progname.h" /* Include malloc.h, only if memalign is available. It is known that memalign is declared in malloc.h in all systems, if present. */ #ifdef HAVE_MEMALIGN # include #endif #ifdef __MINGW32__ #include #include #endif #ifdef GRUB_UTIL int grub_err_printf (const char *fmt, ...) { va_list ap; int ret; va_start (ap, fmt); ret = vfprintf (stderr, fmt, ap); va_end (ap); return ret; } #endif char * grub_util_get_path (const char *dir, const char *file) { char *path; path = (char *) xmalloc (strlen (dir) + 1 + strlen (file) + 1); sprintf (path, "%s/%s", dir, file); return path; } size_t grub_util_get_fp_size (FILE *fp) { struct stat st; if (fflush (fp) == EOF) grub_util_error ("fflush failed"); if (fstat (fileno (fp), &st) == -1) grub_util_error ("fstat failed"); return st.st_size; } size_t grub_util_get_image_size (const char *path) { struct stat st; grub_util_info ("getting the size of %s", path); if (stat (path, &st) == -1) grub_util_error ("cannot stat %s", path); return st.st_size; } void grub_util_read_at (void *img, size_t size, off_t offset, FILE *fp) { if (fseeko (fp, offset, SEEK_SET) == -1) grub_util_error ("seek failed"); if (fread (img, 1, size, fp) != size) grub_util_error ("read failed"); } char * grub_util_read_image (const char *path) { char *img; FILE *fp; size_t size; grub_util_info ("reading %s", path); size = grub_util_get_image_size (path); img = (char *) xmalloc (size); fp = fopen (path, "rb"); if (! fp) grub_util_error ("cannot open %s", path); grub_util_read_at (img, size, 0, fp); fclose (fp); return img; } void grub_util_load_image (const char *path, char *buf) { FILE *fp; size_t size; grub_util_info ("reading %s", path); size = grub_util_get_image_size (path); fp = fopen (path, "rb"); if (! fp) grub_util_error ("cannot open %s", path); if (fread (buf, 1, size, fp) != size) grub_util_error ("cannot read %s", path); fclose (fp); } void grub_util_write_image_at (const void *img, size_t size, off_t offset, FILE *out) { grub_util_info ("writing 0x%x bytes at offset 0x%x", size, offset); if (fseeko (out, offset, SEEK_SET) == -1) grub_util_error ("seek failed"); if (fwrite (img, 1, size, out) != size) grub_util_error ("write failed"); } void grub_util_write_image (const char *img, size_t size, FILE *out) { grub_util_info ("writing 0x%x bytes", size); if (fwrite (img, 1, size, out) != size) grub_util_error ("write failed"); } /* Some functions that we don't use. */ void grub_mm_init_region (void *addr __attribute__ ((unused)), grub_size_t size __attribute__ ((unused))) { } #if GRUB_NO_MODULES void grub_register_exported_symbols (void) { } #endif #ifdef __MINGW32__ void grub_millisleep (grub_uint32_t ms) { Sleep (ms); } #else void grub_millisleep (grub_uint32_t ms) { struct timespec ts; ts.tv_sec = ms / 1000; ts.tv_nsec = (ms % 1000) * 1000000; nanosleep (&ts, NULL); } #endif #if !(defined (__i386__) || defined (__x86_64__)) && GRUB_NO_MODULES void grub_arch_sync_caches (void *address __attribute__ ((unused)), grub_size_t len __attribute__ ((unused))) { } #endif #ifdef __MINGW32__ void sync (void) { } int fsync (int fno __attribute__ ((unused))) { return 0; } void sleep (int s) { Sleep (s * 1000); } grub_int64_t grub_util_get_disk_size (char *name) { HANDLE hd; grub_int64_t size = -1LL; hd = CreateFile (name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0); if (hd == INVALID_HANDLE_VALUE) return size; if (((name[0] == '/') || (name[0] == '\\')) && ((name[1] == '/') || (name[1] == '\\')) && (name[2] == '.') && ((name[3] == '/') || (name[3] == '\\')) && (! strncasecmp (name + 4, "PHYSICALDRIVE", 13))) { 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; } else { LARGE_INTEGER s; s.LowPart = GetFileSize (hd, &s.HighPart); size = s.QuadPart; } fail: CloseHandle (hd); return size; } #endif /* __MINGW32__ */ char * canonicalize_file_name (const char *path) { char *ret; #ifdef PATH_MAX ret = xmalloc (PATH_MAX); (void) realpath (path, ret); #else ret = realpath (path, NULL); #endif return ret; } #ifdef GRUB_UTIL void grub_util_init_nls (void) { #if (defined(ENABLE_NLS) && ENABLE_NLS) setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); #endif /* (defined(ENABLE_NLS) && ENABLE_NLS) */ } #endif int grub_dl_ref (grub_dl_t mod) { (void) mod; return 0; } int grub_dl_unref (grub_dl_t mod) { (void) mod; return 0; }