3d8439da8c
With --disable-nls no locales exist. Avoid runtime error by moving code that copies locales into its own function. Return early in case nls was disabled. That way the compiler will throw away unreachable code, no need to put preprocessor conditionals everywhere to avoid warnings about unused code. Fix memleak by freeing srcf and dstf. Convert tabs to spaces in moved code. Signed-off-by: Olaf Hering <olaf@aepfle.de> Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
990 lines
26 KiB
C
990 lines
26 KiB
C
/*
|
|
* GRUB -- GRand Unified Bootloader
|
|
* Copyright (C) 1999,2000,2001,2002,2003,2004,2005,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.h>
|
|
#include <grub/types.h>
|
|
#include <grub/emu/misc.h>
|
|
#include <grub/util/misc.h>
|
|
#include <grub/misc.h>
|
|
#include <grub/device.h>
|
|
#include <grub/disk.h>
|
|
#include <grub/file.h>
|
|
#include <grub/fs.h>
|
|
#include <grub/env.h>
|
|
#include <grub/term.h>
|
|
#include <grub/mm.h>
|
|
#include <grub/lib/hexdump.h>
|
|
#include <grub/crypto.h>
|
|
#include <grub/command.h>
|
|
#include <grub/i18n.h>
|
|
#include <grub/zfs/zfs.h>
|
|
#include <grub/util/install.h>
|
|
#include <grub/util/resolve.h>
|
|
#include <grub/emu/hostfile.h>
|
|
#include <grub/emu/config.h>
|
|
#include <grub/emu/hostfile.h>
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
|
|
char *
|
|
grub_install_help_filter (int key, const char *text,
|
|
void *input __attribute__ ((unused)))
|
|
{
|
|
switch (key)
|
|
{
|
|
case GRUB_INSTALL_OPTIONS_INSTALL_THEMES:
|
|
return xasprintf(text, "starfield");
|
|
case GRUB_INSTALL_OPTIONS_INSTALL_FONTS:
|
|
return xasprintf(text, "unicode");
|
|
case GRUB_INSTALL_OPTIONS_DIRECTORY:
|
|
case GRUB_INSTALL_OPTIONS_DIRECTORY2:
|
|
return xasprintf(text, grub_util_get_pkglibdir ());
|
|
case GRUB_INSTALL_OPTIONS_LOCALE_DIRECTORY:
|
|
return xasprintf(text, grub_util_get_localedir ());
|
|
case GRUB_INSTALL_OPTIONS_THEMES_DIRECTORY:
|
|
return grub_util_path_concat (2, grub_util_get_pkgdatadir (), "themes");
|
|
default:
|
|
return (char *) text;
|
|
}
|
|
}
|
|
|
|
#pragma GCC diagnostic error "-Wformat-nonliteral"
|
|
|
|
static int (*compress_func) (const char *src, const char *dest) = NULL;
|
|
char *grub_install_copy_buffer;
|
|
static char *dtb;
|
|
|
|
int
|
|
grub_install_copy_file (const char *src,
|
|
const char *dst,
|
|
int is_needed)
|
|
{
|
|
grub_util_fd_t in, out;
|
|
ssize_t r;
|
|
|
|
grub_util_info ("copying `%s' -> `%s'", src, dst);
|
|
|
|
in = grub_util_fd_open (src, GRUB_UTIL_FD_O_RDONLY);
|
|
if (!GRUB_UTIL_FD_IS_VALID (in))
|
|
{
|
|
if (is_needed)
|
|
grub_util_error (_("cannot open `%s': %s"), src, grub_util_fd_strerror ());
|
|
else
|
|
grub_util_info (_("cannot open `%s': %s"), src, grub_util_fd_strerror ());
|
|
return 0;
|
|
}
|
|
out = grub_util_fd_open (dst, GRUB_UTIL_FD_O_WRONLY
|
|
| GRUB_UTIL_FD_O_CREATTRUNC);
|
|
if (!GRUB_UTIL_FD_IS_VALID (out))
|
|
{
|
|
grub_util_error (_("cannot open `%s': %s"), dst,
|
|
grub_util_fd_strerror ());
|
|
grub_util_fd_close (in);
|
|
return 0;
|
|
}
|
|
|
|
if (!grub_install_copy_buffer)
|
|
grub_install_copy_buffer = xmalloc (GRUB_INSTALL_COPY_BUFFER_SIZE);
|
|
|
|
while (1)
|
|
{
|
|
r = grub_util_fd_read (in, grub_install_copy_buffer, GRUB_INSTALL_COPY_BUFFER_SIZE);
|
|
if (r <= 0)
|
|
break;
|
|
grub_util_fd_write (out, grub_install_copy_buffer, r);
|
|
}
|
|
grub_util_fd_sync (out);
|
|
grub_util_fd_close (in);
|
|
grub_util_fd_close (out);
|
|
|
|
if (r < 0)
|
|
grub_util_error (_("cannot copy `%s' to `%s': %s"),
|
|
src, dst, grub_util_fd_strerror ());
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
grub_install_compress_file (const char *in_name,
|
|
const char *out_name,
|
|
int is_needed)
|
|
{
|
|
int ret;
|
|
|
|
if (!compress_func)
|
|
ret = grub_install_copy_file (in_name, out_name, is_needed);
|
|
else
|
|
{
|
|
grub_util_info ("compressing `%s' -> `%s'", in_name, out_name);
|
|
ret = !compress_func (in_name, out_name);
|
|
if (!ret && is_needed)
|
|
grub_util_warn (_("can't compress `%s' to `%s'"), in_name, out_name);
|
|
}
|
|
|
|
if (!ret && is_needed)
|
|
grub_util_error (_("cannot copy `%s' to `%s': %s"),
|
|
in_name, out_name, grub_util_fd_strerror ());
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
is_path_separator (char c)
|
|
{
|
|
#if defined (__MINGW32__) || defined (__CYGWIN__)
|
|
if (c == '\\')
|
|
return 1;
|
|
#endif
|
|
if (c == '/')
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
grub_install_mkdir_p (const char *dst)
|
|
{
|
|
char *t = xstrdup (dst);
|
|
char *p;
|
|
for (p = t; *p; p++)
|
|
{
|
|
if (is_path_separator (*p))
|
|
{
|
|
char s = *p;
|
|
*p = '\0';
|
|
grub_util_mkdir (t);
|
|
*p = s;
|
|
}
|
|
}
|
|
grub_util_mkdir (t);
|
|
free (t);
|
|
}
|
|
|
|
static void
|
|
clean_grub_dir (const char *di)
|
|
{
|
|
grub_util_fd_dir_t d;
|
|
grub_util_fd_dirent_t de;
|
|
|
|
d = grub_util_fd_opendir (di);
|
|
if (!d)
|
|
grub_util_error (_("cannot open directory `%s': %s"),
|
|
di, grub_util_fd_strerror ());
|
|
|
|
while ((de = grub_util_fd_readdir (d)))
|
|
{
|
|
const char *ext = strrchr (de->d_name, '.');
|
|
if ((ext && (strcmp (ext, ".mod") == 0
|
|
|| strcmp (ext, ".lst") == 0
|
|
|| strcmp (ext, ".img") == 0
|
|
|| strcmp (ext, ".mo") == 0)
|
|
&& strcmp (de->d_name, "menu.lst") != 0)
|
|
|| strcmp (de->d_name, "efiemu32.o") == 0
|
|
|| strcmp (de->d_name, "efiemu64.o") == 0)
|
|
{
|
|
char *x = grub_util_path_concat (2, di, de->d_name);
|
|
if (grub_util_unlink (x) < 0)
|
|
grub_util_error (_("cannot delete `%s': %s"), x,
|
|
grub_util_fd_strerror ());
|
|
free (x);
|
|
}
|
|
}
|
|
grub_util_fd_closedir (d);
|
|
}
|
|
|
|
struct install_list
|
|
{
|
|
int is_default;
|
|
char **entries;
|
|
size_t n_entries;
|
|
size_t n_alloc;
|
|
};
|
|
|
|
struct install_list install_modules = { 1, 0, 0, 0 };
|
|
struct install_list modules = { 1, 0, 0, 0 };
|
|
struct install_list install_locales = { 1, 0, 0, 0 };
|
|
struct install_list install_fonts = { 1, 0, 0, 0 };
|
|
struct install_list install_themes = { 1, 0, 0, 0 };
|
|
char *grub_install_source_directory = NULL;
|
|
char *grub_install_locale_directory = NULL;
|
|
char *grub_install_themes_directory = NULL;
|
|
|
|
void
|
|
grub_install_push_module (const char *val)
|
|
{
|
|
modules.is_default = 0;
|
|
if (modules.n_entries + 1 >= modules.n_alloc)
|
|
{
|
|
modules.n_alloc <<= 1;
|
|
if (modules.n_alloc < 16)
|
|
modules.n_alloc = 16;
|
|
modules.entries = xrealloc (modules.entries,
|
|
modules.n_alloc * sizeof (*modules.entries));
|
|
}
|
|
modules.entries[modules.n_entries++] = xstrdup (val);
|
|
modules.entries[modules.n_entries] = NULL;
|
|
}
|
|
|
|
void
|
|
grub_install_pop_module (void)
|
|
{
|
|
modules.n_entries--;
|
|
free (modules.entries[modules.n_entries]);
|
|
modules.entries[modules.n_entries] = NULL;
|
|
}
|
|
|
|
|
|
static void
|
|
handle_install_list (struct install_list *il, const char *val,
|
|
int default_all)
|
|
{
|
|
const char *ptr;
|
|
char **ce;
|
|
il->is_default = 0;
|
|
free (il->entries);
|
|
il->entries = NULL;
|
|
il->n_entries = 0;
|
|
if (strcmp (val, "all") == 0 && default_all)
|
|
{
|
|
il->is_default = 1;
|
|
return;
|
|
}
|
|
ptr = val;
|
|
while (1)
|
|
{
|
|
while (*ptr && grub_isspace (*ptr))
|
|
ptr++;
|
|
if (!*ptr)
|
|
break;
|
|
while (*ptr && !grub_isspace (*ptr))
|
|
ptr++;
|
|
il->n_entries++;
|
|
}
|
|
il->n_alloc = il->n_entries + 1;
|
|
il->entries = xmalloc (il->n_alloc * sizeof (il->entries[0]));
|
|
ptr = val;
|
|
for (ce = il->entries; ; ce++)
|
|
{
|
|
const char *bptr;
|
|
while (*ptr && grub_isspace (*ptr))
|
|
ptr++;
|
|
if (!*ptr)
|
|
break;
|
|
bptr = ptr;
|
|
while (*ptr && !grub_isspace (*ptr))
|
|
ptr++;
|
|
*ce = xmalloc (ptr - bptr + 1);
|
|
memcpy (*ce, bptr, ptr - bptr);
|
|
(*ce)[ptr - bptr] = '\0';
|
|
}
|
|
*ce = NULL;
|
|
}
|
|
|
|
static char **pubkeys;
|
|
static size_t npubkeys;
|
|
static grub_compression_t compression;
|
|
|
|
int
|
|
grub_install_parse (int key, char *arg)
|
|
{
|
|
switch (key)
|
|
{
|
|
case 'C':
|
|
if (grub_strcmp (arg, "xz") == 0)
|
|
{
|
|
#ifdef HAVE_LIBLZMA
|
|
compression = GRUB_COMPRESSION_XZ;
|
|
#else
|
|
grub_util_error ("%s",
|
|
_("grub-mkimage is compiled without XZ support"));
|
|
#endif
|
|
}
|
|
else if (grub_strcmp (arg, "none") == 0)
|
|
compression = GRUB_COMPRESSION_NONE;
|
|
else if (grub_strcmp (arg, "auto") == 0)
|
|
compression = GRUB_COMPRESSION_AUTO;
|
|
else
|
|
grub_util_error (_("Unknown compression format %s"), arg);
|
|
return 1;
|
|
case 'k':
|
|
pubkeys = xrealloc (pubkeys,
|
|
sizeof (pubkeys[0])
|
|
* (npubkeys + 1));
|
|
pubkeys[npubkeys++] = xstrdup (arg);
|
|
return 1;
|
|
|
|
case GRUB_INSTALL_OPTIONS_VERBOSITY:
|
|
verbosity++;
|
|
return 1;
|
|
|
|
case GRUB_INSTALL_OPTIONS_DIRECTORY:
|
|
case GRUB_INSTALL_OPTIONS_DIRECTORY2:
|
|
free (grub_install_source_directory);
|
|
grub_install_source_directory = xstrdup (arg);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_LOCALE_DIRECTORY:
|
|
free (grub_install_locale_directory);
|
|
grub_install_locale_directory = xstrdup (arg);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_THEMES_DIRECTORY:
|
|
free (grub_install_themes_directory);
|
|
grub_install_themes_directory = xstrdup (arg);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_INSTALL_MODULES:
|
|
handle_install_list (&install_modules, arg, 0);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_MODULES:
|
|
handle_install_list (&modules, arg, 0);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_INSTALL_LOCALES:
|
|
handle_install_list (&install_locales, arg, 0);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_INSTALL_THEMES:
|
|
handle_install_list (&install_themes, arg, 0);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_INSTALL_FONTS:
|
|
handle_install_list (&install_fonts, arg, 0);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_DTB:
|
|
if (dtb)
|
|
free (dtb);
|
|
dtb = xstrdup (arg);
|
|
return 1;
|
|
case GRUB_INSTALL_OPTIONS_INSTALL_COMPRESS:
|
|
if (strcmp (arg, "no") == 0
|
|
|| strcmp (arg, "none") == 0)
|
|
{
|
|
compress_func = NULL;
|
|
return 1;
|
|
}
|
|
if (strcmp (arg, "gz") == 0)
|
|
{
|
|
compress_func = grub_install_compress_gzip;
|
|
return 1;
|
|
}
|
|
if (strcmp (arg, "xz") == 0)
|
|
{
|
|
compress_func = grub_install_compress_xz;
|
|
return 1;
|
|
}
|
|
if (strcmp (arg, "lzo") == 0)
|
|
{
|
|
compress_func = grub_install_compress_lzop;
|
|
return 1;
|
|
}
|
|
grub_util_error (_("Unrecognized compression `%s'"), arg);
|
|
case GRUB_INSTALL_OPTIONS_GRUB_MKIMAGE:
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int
|
|
decompressors (void)
|
|
{
|
|
if (compress_func == grub_install_compress_gzip)
|
|
{
|
|
grub_install_push_module ("gzio");
|
|
return 1;
|
|
}
|
|
if (compress_func == grub_install_compress_xz)
|
|
{
|
|
grub_install_push_module ("xzio");
|
|
grub_install_push_module ("gcry_crc");
|
|
return 2;
|
|
}
|
|
if (compress_func == grub_install_compress_lzop)
|
|
{
|
|
grub_install_push_module ("lzopio");
|
|
grub_install_push_module ("adler32");
|
|
grub_install_push_module ("gcry_crc");
|
|
return 3;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
grub_install_make_image_wrap_file (const char *dir, const char *prefix,
|
|
FILE *fp, const char *outname,
|
|
char *memdisk_path,
|
|
char *config_path,
|
|
const char *mkimage_target, int note)
|
|
{
|
|
const struct grub_install_image_target_desc *tgt;
|
|
const char *const compnames[] =
|
|
{
|
|
[GRUB_COMPRESSION_AUTO] = "auto",
|
|
[GRUB_COMPRESSION_NONE] = "none",
|
|
[GRUB_COMPRESSION_XZ] = "xz",
|
|
[GRUB_COMPRESSION_LZMA] = "lzma",
|
|
};
|
|
grub_size_t slen = 1;
|
|
char *s, *p;
|
|
char **pk, **md;
|
|
int dc = decompressors ();
|
|
|
|
if (memdisk_path)
|
|
slen += 20 + grub_strlen (memdisk_path);
|
|
if (config_path)
|
|
slen += 20 + grub_strlen (config_path);
|
|
|
|
for (pk = pubkeys; pk < pubkeys + npubkeys; pk++)
|
|
slen += 20 + grub_strlen (*pk);
|
|
|
|
for (md = modules.entries; *md; md++)
|
|
{
|
|
slen += 10 + grub_strlen (*md);
|
|
}
|
|
|
|
p = s = xmalloc (slen);
|
|
if (memdisk_path)
|
|
{
|
|
p = grub_stpcpy (p, "--memdisk '");
|
|
p = grub_stpcpy (p, memdisk_path);
|
|
*p++ = '\'';
|
|
*p++ = ' ';
|
|
}
|
|
if (config_path)
|
|
{
|
|
p = grub_stpcpy (p, "--config '");
|
|
p = grub_stpcpy (p, config_path);
|
|
*p++ = '\'';
|
|
*p++ = ' ';
|
|
}
|
|
for (pk = pubkeys; pk < pubkeys + npubkeys; pk++)
|
|
{
|
|
p = grub_stpcpy (p, "--pubkey '");
|
|
p = grub_stpcpy (p, *pk);
|
|
*p++ = '\'';
|
|
*p++ = ' ';
|
|
}
|
|
|
|
for (md = modules.entries; *md; md++)
|
|
{
|
|
*p++ = '\'';
|
|
p = grub_stpcpy (p, *md);
|
|
*p++ = '\'';
|
|
*p++ = ' ';
|
|
}
|
|
|
|
*p = '\0';
|
|
|
|
grub_util_info ("grub-mkimage --directory '%s' --prefix '%s'"
|
|
" --output '%s' "
|
|
" --dtb '%s' "
|
|
"--format '%s' --compression '%s' %s %s\n",
|
|
dir, prefix,
|
|
outname, dtb ? : "", mkimage_target,
|
|
compnames[compression], note ? "--note" : "", s);
|
|
free (s);
|
|
|
|
tgt = grub_install_get_image_target (mkimage_target);
|
|
if (!tgt)
|
|
grub_util_error (_("unknown target format %s"), mkimage_target);
|
|
|
|
grub_install_generate_image (dir, prefix, fp, outname,
|
|
modules.entries, memdisk_path,
|
|
pubkeys, npubkeys, config_path, tgt,
|
|
note, compression, dtb);
|
|
while (dc--)
|
|
grub_install_pop_module ();
|
|
}
|
|
|
|
void
|
|
grub_install_make_image_wrap (const char *dir, const char *prefix,
|
|
const char *outname, char *memdisk_path,
|
|
char *config_path,
|
|
const char *mkimage_target, int note)
|
|
{
|
|
FILE *fp;
|
|
|
|
fp = grub_util_fopen (outname, "wb");
|
|
if (! fp)
|
|
grub_util_error (_("cannot open `%s': %s"), outname,
|
|
strerror (errno));
|
|
grub_install_make_image_wrap_file (dir, prefix, fp, outname,
|
|
memdisk_path, config_path,
|
|
mkimage_target, note);
|
|
grub_util_file_sync (fp);
|
|
fclose (fp);
|
|
}
|
|
|
|
static void
|
|
copy_by_ext (const char *srcd,
|
|
const char *dstd,
|
|
const char *extf,
|
|
int req)
|
|
{
|
|
grub_util_fd_dir_t d;
|
|
grub_util_fd_dirent_t de;
|
|
|
|
d = grub_util_fd_opendir (srcd);
|
|
if (!d && !req)
|
|
return;
|
|
if (!d)
|
|
grub_util_error (_("cannot open directory `%s': %s"),
|
|
srcd, grub_util_fd_strerror ());
|
|
|
|
while ((de = grub_util_fd_readdir (d)))
|
|
{
|
|
const char *ext = strrchr (de->d_name, '.');
|
|
if (ext && strcmp (ext, extf) == 0)
|
|
{
|
|
char *srcf = grub_util_path_concat (2, srcd, de->d_name);
|
|
char *dstf = grub_util_path_concat (2, dstd, de->d_name);
|
|
grub_install_compress_file (srcf, dstf, 1);
|
|
free (srcf);
|
|
free (dstf);
|
|
}
|
|
}
|
|
grub_util_fd_closedir (d);
|
|
}
|
|
|
|
static void
|
|
copy_all (const char *srcd,
|
|
const char *dstd)
|
|
{
|
|
grub_util_fd_dir_t d;
|
|
grub_util_fd_dirent_t de;
|
|
|
|
d = grub_util_fd_opendir (srcd);
|
|
if (!d)
|
|
grub_util_error (_("cannot open directory `%s': %s"),
|
|
srcd, grub_util_fd_strerror ());
|
|
|
|
while ((de = grub_util_fd_readdir (d)))
|
|
{
|
|
char *srcf;
|
|
char *dstf;
|
|
if (strcmp (de->d_name, ".") == 0
|
|
|| strcmp (de->d_name, "..") == 0)
|
|
continue;
|
|
srcf = grub_util_path_concat (2, srcd, de->d_name);
|
|
if (grub_util_is_special_file (srcf)
|
|
|| grub_util_is_directory (srcf))
|
|
continue;
|
|
dstf = grub_util_path_concat (2, dstd, de->d_name);
|
|
grub_install_compress_file (srcf, dstf, 1);
|
|
free (srcf);
|
|
free (dstf);
|
|
}
|
|
grub_util_fd_closedir (d);
|
|
}
|
|
|
|
#if !(defined (GRUB_UTIL) && defined(ENABLE_NLS) && ENABLE_NLS)
|
|
static const char *
|
|
get_localedir (void)
|
|
{
|
|
if (grub_install_locale_directory)
|
|
return grub_install_locale_directory;
|
|
else
|
|
return grub_util_get_localedir ();
|
|
}
|
|
|
|
static void
|
|
copy_locales (const char *dstd)
|
|
{
|
|
grub_util_fd_dir_t d;
|
|
grub_util_fd_dirent_t de;
|
|
const char *locale_dir = get_localedir ();
|
|
|
|
d = grub_util_fd_opendir (locale_dir);
|
|
if (!d)
|
|
{
|
|
grub_util_warn (_("cannot open directory `%s': %s"),
|
|
locale_dir, grub_util_fd_strerror ());
|
|
return;
|
|
}
|
|
|
|
while ((de = grub_util_fd_readdir (d)))
|
|
{
|
|
char *srcf;
|
|
char *dstf;
|
|
char *ext;
|
|
if (strcmp (de->d_name, ".") == 0)
|
|
continue;
|
|
if (strcmp (de->d_name, "..") == 0)
|
|
continue;
|
|
ext = grub_strrchr (de->d_name, '.');
|
|
if (ext && (grub_strcmp (ext, ".mo") == 0
|
|
|| grub_strcmp (ext, ".gmo") == 0))
|
|
{
|
|
srcf = grub_util_path_concat (2, locale_dir, de->d_name);
|
|
dstf = grub_util_path_concat (2, dstd, de->d_name);
|
|
ext = grub_strrchr (dstf, '.');
|
|
grub_strcpy (ext, ".mo");
|
|
}
|
|
else
|
|
{
|
|
srcf = grub_util_path_concat_ext (4, locale_dir, de->d_name,
|
|
"LC_MESSAGES", PACKAGE, ".mo");
|
|
dstf = grub_util_path_concat_ext (2, dstd, de->d_name, ".mo");
|
|
}
|
|
grub_install_compress_file (srcf, dstf, 0);
|
|
free (srcf);
|
|
free (dstf);
|
|
}
|
|
grub_util_fd_closedir (d);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
grub_install_copy_nls(const char *src __attribute__ ((unused)),
|
|
const char *dst __attribute__ ((unused)))
|
|
{
|
|
#if !(defined (GRUB_UTIL) && defined(ENABLE_NLS) && ENABLE_NLS)
|
|
char *dst_locale;
|
|
|
|
dst_locale = grub_util_path_concat (2, dst, "locale");
|
|
grub_install_mkdir_p (dst_locale);
|
|
clean_grub_dir (dst_locale);
|
|
|
|
if (install_locales.is_default)
|
|
{
|
|
char *srcd = grub_util_path_concat (2, src, "po");
|
|
copy_by_ext (srcd, dst_locale, ".mo", 0);
|
|
copy_locales (dst_locale);
|
|
free (srcd);
|
|
}
|
|
else
|
|
{
|
|
size_t i;
|
|
const char *locale_dir = get_localedir ();
|
|
|
|
for (i = 0; i < install_locales.n_entries; i++)
|
|
{
|
|
char *srcf = grub_util_path_concat_ext (3, src, "po",
|
|
install_locales.entries[i],
|
|
".mo");
|
|
char *dstf = grub_util_path_concat_ext (2, dst_locale,
|
|
install_locales.entries[i],
|
|
".mo");
|
|
if (grub_install_compress_file (srcf, dstf, 0))
|
|
{
|
|
free (srcf);
|
|
free (dstf);
|
|
continue;
|
|
}
|
|
free (srcf);
|
|
srcf = grub_util_path_concat_ext (4, locale_dir,
|
|
install_locales.entries[i],
|
|
"LC_MESSAGES", PACKAGE, ".mo");
|
|
if (grub_install_compress_file (srcf, dstf, 0) == 0)
|
|
grub_util_error (_("cannot find locale `%s'"),
|
|
install_locales.entries[i]);
|
|
free (srcf);
|
|
free (dstf);
|
|
}
|
|
}
|
|
free (dst_locale);
|
|
#endif
|
|
}
|
|
|
|
static struct
|
|
{
|
|
const char *cpu;
|
|
const char *platform;
|
|
} platforms[GRUB_INSTALL_PLATFORM_MAX] =
|
|
{
|
|
[GRUB_INSTALL_PLATFORM_I386_PC] = { "i386", "pc" },
|
|
[GRUB_INSTALL_PLATFORM_I386_EFI] = { "i386", "efi" },
|
|
[GRUB_INSTALL_PLATFORM_I386_QEMU] = { "i386", "qemu" },
|
|
[GRUB_INSTALL_PLATFORM_I386_COREBOOT] = { "i386", "coreboot" },
|
|
[GRUB_INSTALL_PLATFORM_I386_MULTIBOOT] = { "i386", "multiboot" },
|
|
[GRUB_INSTALL_PLATFORM_I386_IEEE1275] = { "i386", "ieee1275" },
|
|
[GRUB_INSTALL_PLATFORM_X86_64_EFI] = { "x86_64", "efi" },
|
|
[GRUB_INSTALL_PLATFORM_I386_XEN] = { "i386", "xen" },
|
|
[GRUB_INSTALL_PLATFORM_X86_64_XEN] = { "x86_64", "xen" },
|
|
[GRUB_INSTALL_PLATFORM_MIPSEL_LOONGSON] = { "mipsel", "loongson" },
|
|
[GRUB_INSTALL_PLATFORM_MIPSEL_QEMU_MIPS] = { "mipsel", "qemu_mips" },
|
|
[GRUB_INSTALL_PLATFORM_MIPS_QEMU_MIPS] = { "mips", "qemu_mips" },
|
|
[GRUB_INSTALL_PLATFORM_MIPSEL_ARC] = { "mipsel", "arc" },
|
|
[GRUB_INSTALL_PLATFORM_MIPS_ARC] = { "mips", "arc" },
|
|
[GRUB_INSTALL_PLATFORM_SPARC64_IEEE1275] = { "sparc64", "ieee1275" },
|
|
[GRUB_INSTALL_PLATFORM_POWERPC_IEEE1275] = { "powerpc", "ieee1275" },
|
|
[GRUB_INSTALL_PLATFORM_IA64_EFI] = { "ia64", "efi" },
|
|
[GRUB_INSTALL_PLATFORM_ARM_EFI] = { "arm", "efi" },
|
|
[GRUB_INSTALL_PLATFORM_ARM64_EFI] = { "arm64", "efi" },
|
|
[GRUB_INSTALL_PLATFORM_ARM_UBOOT] = { "arm", "uboot" },
|
|
[GRUB_INSTALL_PLATFORM_ARM_COREBOOT] = { "arm", "coreboot" },
|
|
};
|
|
|
|
char *
|
|
grub_install_get_platforms_string (void)
|
|
{
|
|
char **arr = xmalloc (sizeof (char *) * ARRAY_SIZE (platforms));
|
|
int platform_strins_len = 0;
|
|
char *platforms_string;
|
|
char *ptr;
|
|
unsigned i;
|
|
for (i = 0; i < ARRAY_SIZE (platforms); i++)
|
|
{
|
|
arr[i] = xasprintf ("%s-%s", platforms[i].cpu,
|
|
platforms[i].platform);
|
|
platform_strins_len += strlen (arr[i]) + 2;
|
|
}
|
|
ptr = platforms_string = xmalloc (platform_strins_len);
|
|
qsort (arr, ARRAY_SIZE (platforms), sizeof (char *), grub_qsort_strcmp);
|
|
for (i = 0; i < ARRAY_SIZE (platforms); i++)
|
|
{
|
|
strcpy (ptr, arr[i]);
|
|
ptr += strlen (arr[i]);
|
|
*ptr++ = ',';
|
|
*ptr++ = ' ';
|
|
free (arr[i]);
|
|
}
|
|
ptr[-2] = 0;
|
|
free (arr);
|
|
|
|
return platforms_string;
|
|
}
|
|
|
|
char *
|
|
grub_install_get_platform_name (enum grub_install_plat platid)
|
|
{
|
|
return xasprintf ("%s-%s", platforms[platid].cpu,
|
|
platforms[platid].platform);
|
|
}
|
|
|
|
const char *
|
|
grub_install_get_platform_cpu (enum grub_install_plat platid)
|
|
{
|
|
return platforms[platid].cpu;
|
|
}
|
|
|
|
const char *
|
|
grub_install_get_platform_platform (enum grub_install_plat platid)
|
|
{
|
|
return platforms[platid].platform;
|
|
}
|
|
|
|
|
|
void
|
|
grub_install_copy_files (const char *src,
|
|
const char *dst,
|
|
enum grub_install_plat platid)
|
|
{
|
|
char *dst_platform, *dst_fonts;
|
|
const char *pkgdatadir = grub_util_get_pkgdatadir ();
|
|
char *themes_dir;
|
|
|
|
{
|
|
char *platform;
|
|
platform = xasprintf ("%s-%s", platforms[platid].cpu,
|
|
platforms[platid].platform);
|
|
dst_platform = grub_util_path_concat (2, dst, platform);
|
|
free (platform);
|
|
}
|
|
dst_fonts = grub_util_path_concat (2, dst, "fonts");
|
|
grub_install_mkdir_p (dst_platform);
|
|
clean_grub_dir (dst);
|
|
clean_grub_dir (dst_platform);
|
|
|
|
grub_install_copy_nls(src, dst);
|
|
|
|
if (install_modules.is_default)
|
|
copy_by_ext (src, dst_platform, ".mod", 1);
|
|
else
|
|
{
|
|
struct grub_util_path_list *path_list, *p;
|
|
|
|
path_list = grub_util_resolve_dependencies (src, "moddep.lst",
|
|
install_modules.entries);
|
|
for (p = path_list; p; p = p->next)
|
|
{
|
|
const char *srcf = p->name;
|
|
const char *dir;
|
|
char *dstf;
|
|
|
|
dir = grub_strrchr (srcf, '/');
|
|
if (dir)
|
|
dir++;
|
|
else
|
|
dir = srcf;
|
|
dstf = grub_util_path_concat (2, dst_platform, dir);
|
|
grub_install_compress_file (srcf, dstf, 1);
|
|
free (dstf);
|
|
}
|
|
|
|
grub_util_free_path_list (path_list);
|
|
}
|
|
|
|
const char *pkglib_DATA[] = {"efiemu32.o", "efiemu64.o",
|
|
"moddep.lst", "command.lst",
|
|
"fs.lst", "partmap.lst",
|
|
"parttool.lst",
|
|
"video.lst", "crypto.lst",
|
|
"terminal.lst", "modinfo.sh" };
|
|
size_t i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE (pkglib_DATA); i++)
|
|
{
|
|
char *srcf = grub_util_path_concat (2, src, pkglib_DATA[i]);
|
|
char *dstf = grub_util_path_concat (2, dst_platform, pkglib_DATA[i]);
|
|
if (i == 0 || i == 1)
|
|
grub_install_compress_file (srcf, dstf, 0);
|
|
else
|
|
grub_install_compress_file (srcf, dstf, 1);
|
|
free (srcf);
|
|
free (dstf);
|
|
}
|
|
|
|
if (install_themes.is_default)
|
|
{
|
|
install_themes.is_default = 0;
|
|
install_themes.n_entries = 1;
|
|
install_themes.entries = xmalloc (2 * sizeof (install_themes.entries[0]));
|
|
install_themes.entries[0] = xstrdup ("starfield");
|
|
install_themes.entries[1] = NULL;
|
|
}
|
|
|
|
if (grub_install_themes_directory)
|
|
themes_dir = xstrdup (grub_install_themes_directory);
|
|
else
|
|
themes_dir = grub_util_path_concat (2, grub_util_get_pkgdatadir (),
|
|
"themes");
|
|
|
|
for (i = 0; i < install_themes.n_entries; i++)
|
|
{
|
|
char *srcf = grub_util_path_concat (3, themes_dir,
|
|
install_themes.entries[i],
|
|
"theme.txt");
|
|
if (grub_util_is_regular (srcf))
|
|
{
|
|
char *srcd = grub_util_path_concat (2, themes_dir,
|
|
install_themes.entries[i]);
|
|
char *dstd = grub_util_path_concat (3, dst, "themes",
|
|
install_themes.entries[i]);
|
|
grub_install_mkdir_p (dstd);
|
|
copy_all (srcd, dstd);
|
|
free (srcd);
|
|
free (dstd);
|
|
}
|
|
free (srcf);
|
|
}
|
|
|
|
free (themes_dir);
|
|
|
|
if (install_fonts.is_default)
|
|
{
|
|
install_fonts.is_default = 0;
|
|
install_fonts.n_entries = 1;
|
|
install_fonts.entries = xmalloc (2 * sizeof (install_fonts.entries[0]));
|
|
install_fonts.entries[0] = xstrdup ("unicode");
|
|
install_fonts.entries[1] = NULL;
|
|
}
|
|
|
|
grub_install_mkdir_p (dst_fonts);
|
|
|
|
for (i = 0; i < install_fonts.n_entries; i++)
|
|
{
|
|
char *srcf = grub_util_path_concat_ext (2, pkgdatadir,
|
|
install_fonts.entries[i],
|
|
".pf2");
|
|
char *dstf = grub_util_path_concat_ext (2, dst_fonts,
|
|
install_fonts.entries[i],
|
|
".pf2");
|
|
|
|
grub_install_compress_file (srcf, dstf, 0);
|
|
free (srcf);
|
|
free (dstf);
|
|
}
|
|
|
|
free (dst_platform);
|
|
free (dst_fonts);
|
|
}
|
|
|
|
enum grub_install_plat
|
|
grub_install_get_target (const char *src)
|
|
{
|
|
char *fn;
|
|
grub_util_fd_t f;
|
|
char buf[8192];
|
|
ssize_t r;
|
|
char *c, *pl, *p;
|
|
size_t i;
|
|
fn = grub_util_path_concat (2, src, "modinfo.sh");
|
|
f = grub_util_fd_open (fn, GRUB_UTIL_FD_O_RDONLY);
|
|
if (!GRUB_UTIL_FD_IS_VALID (f))
|
|
grub_util_error (_("%s doesn't exist. Please specify --target or --directory"),
|
|
fn);
|
|
r = grub_util_fd_read (f, buf, sizeof (buf) - 1);
|
|
if (r < 0)
|
|
grub_util_error (_("cannot read `%s': %s"), fn, strerror (errno));
|
|
grub_util_fd_close (f);
|
|
buf[r] = '\0';
|
|
c = strstr (buf, "grub_modinfo_target_cpu=");
|
|
if (!c || (c != buf && !grub_isspace (*(c-1))))
|
|
grub_util_error (_("invalid modinfo file `%s'"), fn);
|
|
pl = strstr (buf, "grub_modinfo_platform=");
|
|
if (!pl || (pl != buf && !grub_isspace (*(pl-1))))
|
|
grub_util_error (_("invalid modinfo file `%s'"), fn);
|
|
c += sizeof ("grub_modinfo_target_cpu=") - 1;
|
|
pl += sizeof ("grub_modinfo_platform=") - 1;
|
|
for (p = c; *p && !grub_isspace (*p); p++);
|
|
*p = '\0';
|
|
for (p = pl; *p && !grub_isspace (*p); p++);
|
|
*p = '\0';
|
|
|
|
for (i = 0; i < ARRAY_SIZE (platforms); i++)
|
|
if (strcmp (platforms[i].cpu, c) == 0
|
|
&& strcmp (platforms[i].platform, pl) == 0)
|
|
{
|
|
free (fn);
|
|
return i;
|
|
}
|
|
grub_util_error (_("Unknown platform `%s-%s'"), c, pl);
|
|
}
|
|
|
|
|
|
void
|
|
grub_util_unlink_recursive (const char *name)
|
|
{
|
|
grub_util_fd_dir_t d;
|
|
grub_util_fd_dirent_t de;
|
|
|
|
d = grub_util_fd_opendir (name);
|
|
|
|
while ((de = grub_util_fd_readdir (d)))
|
|
{
|
|
char *fp;
|
|
if (strcmp (de->d_name, ".") == 0)
|
|
continue;
|
|
if (strcmp (de->d_name, "..") == 0)
|
|
continue;
|
|
fp = grub_util_path_concat (2, name, de->d_name);
|
|
if (grub_util_is_special_file (fp))
|
|
{
|
|
free (fp);
|
|
continue;
|
|
}
|
|
if (grub_util_is_regular (fp))
|
|
grub_util_unlink (fp);
|
|
else if (grub_util_is_directory (fp))
|
|
grub_util_unlink_recursive (fp);
|
|
free (fp);
|
|
}
|
|
grub_util_rmdir (name);
|
|
grub_util_fd_closedir (d);
|
|
}
|