arch/all-pc/boot/grub2-aros/grub-core/loader/macho.c

   1 /* macho.c - load Mach-O files. */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2009  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /* This Mach-O loader is incomplete and can load only non-relocatable segments.
  21    This is however enough to boot xnu (otool -l and Mach-O specs for more info).
  22 */
  23
  24 #include <grub/err.h>
  25 #include <grub/macho.h>
  26 #include <grub/machoload.h>
  27 #include <grub/file.h>
  28 #include <grub/misc.h>
  29 #include <grub/mm.h>
  30 #include <grub/i18n.h>
  31 #include <grub/dl.h>
  32
  33 GRUB_MOD_LICENSE ("GPLv3+");
  34
  35 grub_err_t
  36 grub_macho_close (grub_macho_t macho)
  37 {
  38   grub_file_t file = macho->file;
  39
  40   if (!macho->uncompressed32)
  41     grub_free (macho->cmds32);
  42   grub_free (macho->uncompressed32);
  43   if (!macho->uncompressed64)
  44     grub_free (macho->cmds64);
  45   grub_free (macho->uncompressed64);
  46
  47   grub_free (macho);
  48
  49   if (file)
  50     grub_file_close (file);
  51
  52   return grub_errno;
  53 }
  54
  55 grub_macho_t
  56 grub_macho_file (grub_file_t file, const char *filename, int is_64bit)
  57 {
  58   grub_macho_t macho;
  59   union grub_macho_filestart filestart;
  60
  61   macho = grub_malloc (sizeof (*macho));
  62   if (! macho)
  63     return 0;
  64
  65   macho->file = file;
  66   macho->offset32 = -1;
  67   macho->offset64 = -1;
  68   macho->end32 = -1;
  69   macho->end64 = -1;
  70   macho->cmds32 = 0;
  71   macho->cmds64 = 0;
  72   macho->uncompressed32 = 0;
  73   macho->uncompressed64 = 0;
  74   macho->compressed32 = 0;
  75   macho->compressed64 = 0;
  76
  77   if (grub_file_seek (macho->file, 0) == (grub_off_t) -1)
  78     goto fail;
  79
  80   if (grub_file_read (macho->file, &filestart, sizeof (filestart))
  81       != sizeof (filestart))
  82     {
  83       if (!grub_errno)
  84         grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
  85                     filename);
  86       goto fail;
  87     }
  88
  89   /* Is it a fat file? */
  90   if (filestart.fat.magic == grub_cpu_to_be32_compile_time (GRUB_MACHO_FAT_MAGIC))
  91     {
  92       struct grub_macho_fat_arch *archs;
  93       int i, narchs;
  94
  95       /* Load architecture description. */
  96       narchs = grub_be_to_cpu32 (filestart.fat.nfat_arch);
  97       if (grub_file_seek (macho->file, sizeof (struct grub_macho_fat_header))
  98           == (grub_off_t) -1)
  99         goto fail;
 100       archs = grub_malloc (sizeof (struct grub_macho_fat_arch) * narchs);
 101       if (!archs)
 102         goto fail;
 103       if (grub_file_read (macho->file, archs,
 104                           sizeof (struct grub_macho_fat_arch) * narchs)
 105           != (grub_ssize_t) sizeof(struct grub_macho_fat_arch) * narchs)
 106         {
 107           grub_free (archs);
 108           if (!grub_errno)
 109             grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
 110                         filename);
 111           goto fail;
 112         }
 113
 114       for (i = 0; i < narchs; i++)
 115         {
 116           if ((archs[i].cputype
 117                == grub_cpu_to_be32_compile_time (GRUB_MACHO_CPUTYPE_IA32))
 118               && !is_64bit)
 119             {
 120               macho->offset32 = grub_be_to_cpu32 (archs[i].offset);
 121               macho->end32 = grub_be_to_cpu32 (archs[i].offset)
 122                 + grub_be_to_cpu32 (archs[i].size);
 123             }
 124           if ((archs[i].cputype
 125                == grub_cpu_to_be32_compile_time (GRUB_MACHO_CPUTYPE_AMD64))
 126               && is_64bit)
 127             {
 128               macho->offset64 = grub_be_to_cpu32 (archs[i].offset);
 129               macho->end64 = grub_be_to_cpu32 (archs[i].offset)
 130                 + grub_be_to_cpu32 (archs[i].size);
 131             }
 132         }
 133       grub_free (archs);
 134     }
 135
 136   /* Is it a thin 32-bit file? */
 137   if (filestart.thin32.magic == GRUB_MACHO_MAGIC32 && !is_64bit)
 138     {
 139       macho->offset32 = 0;
 140       macho->end32 = grub_file_size (file);
 141     }
 142
 143   /* Is it a thin 64-bit file? */
 144   if (filestart.thin64.magic == GRUB_MACHO_MAGIC64 && is_64bit)
 145     {
 146       macho->offset64 = 0;
 147       macho->end64 = grub_file_size (file);
 148     }
 149
 150   if (grub_memcmp (filestart.lzss.magic, GRUB_MACHO_LZSS_MAGIC,
 151                    sizeof (filestart.lzss.magic)) == 0 && !is_64bit)
 152     {
 153       macho->offset32 = 0;
 154       macho->end32 = grub_file_size (file);
 155     }
 156
 157   /* Is it a thin 64-bit file? */
 158   if (grub_memcmp (filestart.lzss.magic, GRUB_MACHO_LZSS_MAGIC,
 159                    sizeof (filestart.lzss.magic)) == 0 && is_64bit)
 160     {
 161       macho->offset64 = 0;
 162       macho->end64 = grub_file_size (file);
 163     }
 164
 165   grub_macho_parse32 (macho, filename);
 166   grub_macho_parse64 (macho, filename);
 167
 168   if (macho->offset32 == -1 && !is_64bit)
 169     {
 170       grub_error (GRUB_ERR_BAD_OS,
 171                   "Mach-O doesn't contain suitable 32-bit architecture");
 172       goto fail;
 173     }
 174
 175   if (macho->offset64 == -1 && is_64bit)
 176     {
 177       grub_error (GRUB_ERR_BAD_OS,
 178                   "Mach-O doesn't contain suitable 64-bit architecture");
 179       goto fail;
 180     }
 181
 182   return macho;
 183
 184 fail:
 185   macho->file = 0;
 186   grub_macho_close (macho);
 187   return 0;
 188 }
 189
 190 grub_macho_t
 191 grub_macho_open (const char *name, int is_64bit)
 192 {
 193   grub_file_t file;
 194   grub_macho_t macho;
 195
 196   file = grub_file_open (name);
 197   if (! file)
 198     return 0;
 199
 200   macho = grub_macho_file (file, name, is_64bit);
 201   if (! macho)
 202     grub_file_close (file);
 203
 204   return macho;
 205 }