1 /* 2 * isohybrid.c: Post process an ISO 9660 image generated with mkisofs or 3 * genisoimage to allow - hybrid booting - as a CD-ROM or as a hard 4 * disk. 5 * 6 * This is based on the original Perl script written by H. Peter Anvin. The 7 * rewrite in C is to avoid dependency on Perl on a system under installation. 8 * 9 * Copyright (C) 2010 P J P <pj.pandit@yahoo.co.in> 10 * 11 * isohybrid is a free software; you can redistribute it and/or modify it 12 * under the terms of GNU General Public License as published by Free Software 13 * Foundation; either version 2 of the license, or (at your option) any later 14 * version. 15 * 16 * isohybrid is distributed in the hope that it will be useful, but WITHOUT 17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 19 * more details. 20 * 21 * You should have received a copy of the GNU General Public License along 22 * with isohybrid; if not, see: <http://www.gnu.org/licenses>. 23 * 24 */ 25 26 #define _FILE_OFFSET_BITS 64 27 //#include <err.h> 28 #include <time.h> 29 #include <ctype.h> 30 #include <fcntl.h> 31 #include <stdio.h> 32 //#include <alloca.h> 33 //#include <getopt.h> 34 #include <signal.h> 35 #include <stdlib.h> 36 #include <string.h> 37 //#include <unistd.h> 38 #include <sys/stat.h> 39 //#include <inttypes.h> 40 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 41 #include <uuid/uuid.h> 42 #endif 43 44 #include "isohybrid.h" 45 #include "reactos_support_code.h" 46 47 char *prog = NULL; 48 extern int opterr, optind; 49 struct stat isostat; 50 unsigned int padding = 0; 51 52 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 53 uuid_t disk_uuid, part_uuid, iso_uuid; 54 #endif 55 56 uint8_t mode = 0; 57 enum { VERBOSE = 1 , EFI = 2 , MAC = 4}; 58 59 /* user options */ 60 uint16_t head = 64; /* 1 <= head <= 256 */ 61 uint8_t sector = 32; /* 1 <= sector <= 63 */ 62 63 uint8_t entry = 0; /* partition number: 1 <= entry <= 4 */ 64 uint8_t offset = 0; /* partition offset: 0 <= offset <= 64 */ 65 uint16_t type = 0x17; /* partition type: 0 <= type <= 255 */ 66 uint32_t id = 0; /* MBR: 0 <= id <= 0xFFFFFFFF(4294967296) */ 67 68 uint8_t hd0 = 0; /* 0 <= hd0 <= 2 */ 69 uint8_t partok = 0; /* 0 <= partok <= 1 */ 70 71 char mbr_template_path[1024] = {0}; /* Path to MBR template */ 72 73 uint16_t ve[16]; 74 uint32_t catoffset = 0; 75 uint32_t c = 0, cc = 0, cs = 0; 76 77 uint32_t psize = 0, isosize = 0; 78 79 /* boot catalogue parameters */ 80 uint32_t de_lba = 0; 81 uint16_t de_seg = 0, de_count = 0, de_mbz2 = 0; 82 uint8_t de_boot = 0, de_media = 0, de_sys = 0, de_mbz1 = 0; 83 uint32_t efi_lba = 0, mac_lba = 0; 84 uint16_t efi_count = 0, mac_count = 0; 85 uint8_t efi_boot = 0, efi_media = 0, efi_sys = 0; 86 87 int apm_parts = 3; 88 89 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 90 uint8_t afp_header[] = { 0x45, 0x52, 0x08, 0x00, 0x00, 0x00, 0x90, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 91 92 uuid_t efi_system_partition = {0xC1, 0x2A, 0x73, 0x28, 0xF8, 0x1F, 0x11, 0xD2, 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B}; 93 uuid_t basic_partition = {0xEB,0xD0,0xA0,0xA2,0xB9,0xE5,0x44,0x33,0x87,0xC0,0x68,0xB6,0xB7,0x26,0x99,0xC7}; 94 uuid_t hfs_partition = {0x48, 0x46, 0x53, 0x00, 0x00, 0x00, 0x11, 0xAA, 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC}; 95 #endif 96 97 uint32_t crc_tab[256] = 98 { 99 0, 0x77073096, 0xEE0E612C, 0x990951BA, 100 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 101 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 102 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 103 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 104 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 105 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 106 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 107 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 108 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 109 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 110 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 111 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 112 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 113 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 114 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 115 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 116 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 117 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 118 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 119 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 120 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 121 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 122 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 123 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 124 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 125 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 126 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 127 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 128 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 129 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 130 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 131 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 132 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 133 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 134 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 135 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 136 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 137 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 138 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 139 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 140 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 141 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 142 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 143 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 144 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 145 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 146 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 147 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 148 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 149 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 150 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 151 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 152 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 153 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 154 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 155 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 156 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 157 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 158 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 159 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 160 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 161 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 162 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D 163 }; 164 165 struct iso_primary_descriptor { 166 uint8_t ignore [80]; 167 uint32_t size; 168 uint8_t ignore2 [44]; 169 uint16_t block_size; 170 }; 171 172 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 173 struct gpt_header { 174 uint64_t signature; 175 uint32_t revision; 176 uint32_t headerSize; 177 uint32_t headerCRC; 178 uint32_t reserved; 179 uint64_t currentLBA; 180 uint64_t backupLBA; 181 uint64_t firstUsableLBA; 182 uint64_t lastUsableLBA; 183 uuid_t diskGUID; 184 uint64_t partitionEntriesLBA; 185 uint32_t numParts; 186 uint32_t sizeOfPartitionEntries; 187 uint32_t partitionEntriesCRC; 188 uint8_t reserved2[420]; 189 }; 190 191 struct gpt_part_header { 192 uuid_t partTypeGUID; 193 uuid_t partGUID; 194 uint64_t firstLBA; 195 uint64_t lastLBA; 196 uint64_t attributes; 197 uint16_t name[36]; 198 }; 199 200 #define APM_OFFSET 2048 201 202 struct apple_part_header { 203 uint16_t signature; /* expected to be MAC_PARTITION_MAGIC */ 204 uint16_t res1; 205 uint32_t map_count; /* # blocks in partition map */ 206 uint32_t start_block; /* absolute starting block # of partition */ 207 uint32_t block_count; /* number of blocks in partition */ 208 char name[32]; /* partition name */ 209 char type[32]; /* string type description */ 210 uint32_t data_start; /* rel block # of first data block */ 211 uint32_t data_count; /* number of data blocks */ 212 uint32_t status; /* partition status bits */ 213 uint32_t boot_start; 214 uint32_t boot_count; 215 uint32_t boot_load; 216 uint32_t boot_load2; 217 uint32_t boot_entry; 218 uint32_t boot_entry2; 219 uint32_t boot_cksum; 220 char processor[16]; /* Contains 680x0, x=0,2,3,4; or empty */ 221 uint32_t driver_sig; 222 char _padding[372]; 223 }; 224 #endif 225 226 227 void 228 usage(void) 229 { 230 printf("Usage: %s [OPTIONS] <boot.iso>\n", prog); 231 } 232 233 234 void 235 printh(void) 236 { 237 #define FMT "%-20s %s\n" 238 239 usage(); 240 241 printf("\n"); 242 printf("Options:\n"); 243 printf(FMT, " -h <X>", "Number of geometry heads (default 64)"); 244 printf(FMT, " -s <X>", "Number of geometry sectors (default 32)"); 245 printf(FMT, " -e --entry", "Specify partition entry number (1-4)"); 246 printf(FMT, " -o --offset", "Specify partition offset (default 0)"); 247 printf(FMT, " -t --type", "Specify partition type (default 0x17)"); 248 printf(FMT, " -i --id", "Specify MBR ID (default random)"); 249 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 250 printf(FMT, " -u --uefi", "Build EFI bootable image"); 251 printf(FMT, " -m --mac", "Add AFP table support"); 252 #endif 253 printf(FMT, " -b --mbr <PATH>", "Load MBR from PATH"); 254 255 printf("\n"); 256 printf(FMT, " --forcehd0", "Assume we are loaded as disk ID 0"); 257 printf(FMT, " --ctrlhd0", "Assume disk ID 0 if the Ctrl key is pressed"); 258 printf(FMT, " --partok", "Allow booting from within a partition"); 259 260 printf("\n"); 261 printf(FMT, " -? --help", "Display this help"); 262 printf(FMT, " -v --verbose", "Display verbose output"); 263 printf(FMT, " -V --version", "Display version information"); 264 265 printf("\n"); 266 printf("Report bugs to <pj.pandit@yahoo.co.in>\n"); 267 } 268 269 270 int 271 check_option(int argc, char *argv[]) 272 { 273 char *err = NULL; 274 int n = 0, ind = 0; 275 276 const char optstr[] = ":h:s:e:o:t:i:b:umfcp?vV"; 277 struct option lopt[] = \ 278 { 279 { "entry", required_argument, NULL, 'e' }, 280 { "offset", required_argument, NULL, 'o' }, 281 { "type", required_argument, NULL, 't' }, 282 { "id", required_argument, NULL, 'i' }, 283 284 { "forcehd0", no_argument, NULL, 'f' }, 285 { "ctrlhd0", no_argument, NULL, 'c' }, 286 { "partok", no_argument, NULL, 'p'}, 287 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 288 { "uefi", no_argument, NULL, 'u'}, 289 { "mac", no_argument, NULL, 'm'}, 290 #endif 291 { "mbr", required_argument, NULL, 'b' }, 292 293 { "help", no_argument, NULL, '?' }, 294 { "verbose", no_argument, NULL, 'v' }, 295 { "version", no_argument, NULL, 'V' }, 296 297 { 0, 0, 0, 0 } 298 }; 299 300 opterr = mode = 0; 301 while ((n = getopt_long_only(argc, argv, optstr, lopt, &ind)) != -1) 302 { 303 switch (n) 304 { 305 case 'h': 306 head = strtoul(optarg, &err, 0); 307 if (head < 1 || head > 256) 308 errx(1, "invalid head: `%s', 1 <= head <= 256", optarg); 309 break; 310 311 case 's': 312 sector = strtoul(optarg, &err, 0); 313 if (sector < 1 || sector > 63) 314 errx(1, "invalid sector: `%s', 1 <= sector <= 63", optarg); 315 break; 316 317 case 'e': 318 entry = strtoul(optarg, &err, 0); 319 if (entry < 1 || entry > 4) 320 errx(1, "invalid entry: `%s', 1 <= entry <= 4", optarg); 321 if (mode & MAC || mode & EFI) 322 errx(1, "setting an entry is unsupported with EFI or Mac"); 323 break; 324 325 case 'o': 326 offset = strtoul(optarg, &err, 0); 327 if (*err || offset > 64) 328 errx(1, "invalid offset: `%s', 0 <= offset <= 64", optarg); 329 break; 330 331 case 't': 332 type = strtoul(optarg, &err, 0); 333 if (*err || type > 255) 334 errx(1, "invalid type: `%s', 0 <= type <= 255", optarg); 335 break; 336 337 case 'i': 338 id = strtoul(optarg, &err, 0); 339 if (*err) 340 errx(1, "invalid id: `%s'", optarg); 341 break; 342 343 case 'f': 344 hd0 = 1; 345 break; 346 347 case 'c': 348 hd0 = 2; 349 break; 350 351 case 'p': 352 partok = 1; 353 break; 354 355 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 356 case 'u': 357 mode |= EFI; 358 if (entry) 359 errx(1, "setting an entry is unsupported with EFI or Mac"); 360 break; 361 362 case 'm': 363 mode |= MAC; 364 if (entry) 365 errx(1, "setting an entry is unsupported with EFI or Mac"); 366 break; 367 #endif 368 369 case 'b': 370 if (strlen(optarg) >= sizeof(mbr_template_path)) 371 errx(1, "--mbr : Path too long"); 372 strcpy(mbr_template_path, optarg); 373 break; 374 375 case 'v': 376 mode |= VERBOSE; 377 break; 378 379 case 'V': 380 printf("%s version %s\n", prog, VERSION); 381 exit(0); 382 383 case ':': 384 errx(1, "option `-%c' takes an argument", optopt); 385 386 default: 387 case '?': 388 if (optopt) 389 errx(1, "invalid option `-%c', see --help", optopt); 390 391 printh(); 392 exit(0); 393 } 394 } 395 396 return optind; 397 } 398 399 uint16_t 400 bendian_short(const uint16_t s) 401 { 402 uint16_t r = 1; 403 404 if (!*(uint8_t *)&r) 405 return s; 406 407 r = (s & 0x00FF) << 8 | (s & 0xFF00) >> 8; 408 409 return r; 410 } 411 412 413 uint32_t 414 bendian_int(const uint32_t s) 415 { 416 uint32_t r = 1; 417 418 if (!*(uint8_t *)&r) 419 return s; 420 421 r = (s & 0x000000FF) << 24 | (s & 0xFF000000) >> 24 422 | (s & 0x0000FF00) << 8 | (s & 0x00FF0000) >> 8; 423 424 return r; 425 } 426 427 uint16_t 428 lendian_short(const uint16_t s) 429 { 430 uint16_t r = 1; 431 432 if (*(uint8_t *)&r) 433 return s; 434 435 r = (s & 0x00FF) << 8 | (s & 0xFF00) >> 8; 436 437 return r; 438 } 439 440 441 uint32_t 442 lendian_int(const uint32_t s) 443 { 444 uint32_t r = 1; 445 446 if (*(uint8_t *)&r) 447 return s; 448 449 r = (s & 0x000000FF) << 24 | (s & 0xFF000000) >> 24 450 | (s & 0x0000FF00) << 8 | (s & 0x00FF0000) >> 8; 451 452 return r; 453 } 454 455 uint64_t 456 lendian_64(const uint64_t s) 457 { 458 uint64_t r = 1; 459 460 if (*(uint8_t *)&r) 461 return s; 462 463 r = (s & 0x00000000000000FFull) << 56 | (s & 0xFF00000000000000ull) >> 56 464 | (s & 0x000000000000FF00ull) << 40 | (s & 0x00FF000000000000ull) >> 40 465 | (s & 0x0000000000FF0000ull) << 24 | (s & 0x0000FF0000000000ull) >> 24 466 | (s & 0x00000000FF000000ull) << 8 | (s & 0x000000FF00000000ull) >> 8; 467 468 return r; 469 } 470 471 472 int 473 check_banner(const uint8_t *buf) 474 { 475 static const char banner[] = "\0CD001\1EL TORITO SPECIFICATION\0\0\0\0" \ 476 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" \ 477 "\0\0\0\0\0"; 478 479 if (!buf || memcmp(buf, banner, sizeof(banner) - 1)) 480 return 1; 481 482 buf += sizeof(banner) - 1; 483 memcpy(&catoffset, buf, sizeof(catoffset)); 484 485 catoffset = lendian_int(catoffset); 486 487 return 0; 488 } 489 490 491 int 492 check_catalogue(const uint8_t *buf) 493 { 494 int i = 0; 495 496 for (i = 0, cs = 0; i < 16; i++) 497 { 498 ve[i] = 0; 499 memcpy(&ve[i], buf, sizeof(ve[i])); 500 501 ve[i] = lendian_short(ve[i]); 502 503 buf += 2; 504 cs += ve[i]; 505 506 if (mode & VERBOSE) 507 printf("ve[%d]: %d, cs: %d\n", i, ve[i], cs); 508 } 509 if ((ve[0] != 0x0001) || (ve[15] != 0xAA55) || (cs & 0xFFFF)) 510 return 1; 511 512 return 0; 513 } 514 515 516 int 517 read_catalogue(const uint8_t *buf) 518 { 519 memcpy(&de_boot, buf++, 1); 520 memcpy(&de_media, buf++, 1); 521 522 memcpy(&de_seg, buf, 2); 523 de_seg = lendian_short(de_seg); 524 buf += 2; 525 526 memcpy(&de_sys, buf++, 1); 527 memcpy(&de_mbz1, buf++, 1); 528 529 memcpy(&de_count, buf, 2); 530 de_count = lendian_short(de_count); 531 buf += 2; 532 533 memcpy(&de_lba, buf, 4); 534 de_lba = lendian_int(de_lba); 535 buf += 4; 536 537 memcpy(&de_mbz2, buf, 2); 538 de_mbz2 = lendian_short(de_mbz2); 539 buf += 2; 540 541 if (de_boot != 0x88 || de_media != 0 542 || (de_seg != 0 && de_seg != 0x7C0) || de_count != 4) 543 return 1; 544 545 return 0; 546 } 547 548 549 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 550 int 551 read_efi_section(const uint8_t *buf) 552 { 553 unsigned char header_indicator; 554 unsigned char platform_id; 555 short count; 556 557 memcpy(&header_indicator, buf++, 1); 558 memcpy(&platform_id, buf++, 1); 559 560 memcpy(&count, buf, 2); 561 count = lendian_short(count); 562 buf += 2; 563 564 if (platform_id == 0xef) 565 return 0; 566 567 return 1; 568 } 569 570 int 571 read_efi_catalogue(const uint8_t *buf, uint16_t *count, uint32_t *lba) 572 { 573 buf += 6; 574 575 memcpy(count, buf, 2); 576 *count = lendian_short(*count); 577 buf += 2; 578 579 memcpy(lba, buf, 4); 580 *lba = lendian_int(*lba); 581 buf += 6; 582 583 return 0; 584 } 585 #endif 586 587 588 void 589 display_catalogue(void) 590 { 591 printf("de_boot: %hhu\n", de_boot); 592 printf("de_media: %hhu\n", de_media); 593 printf("de_seg: %hu\n", de_seg); 594 printf("de_sys: %hhu\n", de_sys); 595 printf("de_mbz1: %hhu\n", de_mbz1); 596 printf("de_count: %hu\n", de_count); 597 printf("de_lba: %u\n", de_lba); 598 printf("de_mbz2: %hu\n", de_mbz2); 599 } 600 601 602 void 603 read_mbr_template(char *path, uint8_t *mbr) 604 { 605 FILE *fp; 606 int ret; 607 608 fp = fopen(path, "rb"); 609 if (fp == NULL) 610 err(1, "could not open MBR template file `%s'", path); 611 clearerr(fp); 612 ret = fread(mbr, 1, MBRSIZE, fp); 613 if (ferror(fp) || ret != MBRSIZE) 614 err(1, "error while reading MBR template file `%s'", path); 615 fclose(fp); 616 } 617 618 619 int 620 initialise_mbr(uint8_t *mbr) 621 { 622 int i = 0; 623 uint32_t tmp = 0; 624 uint8_t ptype = 0, *rbm = mbr; 625 uint8_t bhead = 0, bsect = 0, bcyle = 0; 626 uint8_t ehead = 0, esect = 0, ecyle = 0; 627 628 #ifndef ISOHYBRID_C_STANDALONE 629 extern unsigned char isohdpfx[][MBRSIZE]; 630 #endif 631 632 if (mbr_template_path[0]) { 633 read_mbr_template(mbr_template_path, mbr); 634 } else { 635 636 #ifdef ISOHYBRID_C_STANDALONE 637 638 err(1, "This is a standalone binary. You must specify --mbr. E.g with /usr/lib/syslinux/isohdpfx.bin"); 639 640 #else 641 642 memcpy(mbr, &isohdpfx[hd0 + 3 * partok], MBRSIZE); 643 644 #endif /* ! ISOHYBRID_C_STANDALONE */ 645 646 } 647 648 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 649 if (mode & MAC) { 650 memcpy(mbr, afp_header, sizeof(afp_header)); 651 } 652 #endif 653 654 if (!entry) 655 entry = 1; 656 657 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 658 if (mode & EFI) 659 type = 0; 660 #endif 661 662 mbr += MBRSIZE; /* offset 432 */ 663 664 tmp = lendian_int(de_lba * 4); 665 memcpy(mbr, &tmp, sizeof(tmp)); 666 mbr += sizeof(tmp); /* offset 436 */ 667 668 tmp = 0; 669 memcpy(mbr, &tmp, sizeof(tmp)); 670 mbr += sizeof(tmp); /* offset 440 */ 671 672 tmp = lendian_int(id); 673 memcpy(mbr, &tmp, sizeof(tmp)); 674 mbr += sizeof(tmp); /* offset 444 */ 675 676 mbr[0] = '\0'; 677 mbr[1] = '\0'; 678 mbr += 2; /* offset 446 */ 679 680 ptype = type; 681 psize = c * head * sector - offset; 682 683 bhead = (offset / sector) % head; 684 bsect = (offset % sector) + 1; 685 bcyle = offset / (head * sector); 686 687 bsect += (bcyle & 0x300) >> 2; 688 bcyle &= 0xFF; 689 690 ehead = head - 1; 691 esect = sector + (((cc - 1) & 0x300) >> 2); 692 ecyle = (cc - 1) & 0xFF; 693 694 for (i = 1; i <= 4; i++) 695 { 696 memset(mbr, 0, 16); 697 if (i == entry) 698 { 699 mbr[0] = 0x80; 700 mbr[1] = bhead; 701 mbr[2] = bsect; 702 mbr[3] = bcyle; 703 mbr[4] = ptype; 704 mbr[5] = ehead; 705 mbr[6] = esect; 706 mbr[7] = ecyle; 707 708 tmp = lendian_int(offset); 709 memcpy(&mbr[8], &tmp, sizeof(tmp)); 710 711 tmp = lendian_int(psize); 712 memcpy(&mbr[12], &tmp, sizeof(tmp)); 713 } 714 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 715 if (i == 2 && (mode & EFI)) 716 { 717 mbr[0] = 0x0; 718 mbr[1] = 0xfe; 719 mbr[2] = 0xff; 720 mbr[3] = 0xff; 721 mbr[4] = 0xef; 722 mbr[5] = 0xfe; 723 mbr[6] = 0xff; 724 mbr[7] = 0xff; 725 726 tmp = lendian_int(efi_lba * 4); 727 memcpy(&mbr[8], &tmp, sizeof(tmp)); 728 729 tmp = lendian_int(efi_count); 730 memcpy(&mbr[12], &tmp, sizeof(tmp)); 731 } 732 if (i == 3 && (mode & MAC)) 733 { 734 mbr[0] = 0x0; 735 mbr[1] = 0xfe; 736 mbr[2] = 0xff; 737 mbr[3] = 0xff; 738 mbr[4] = 0x0; 739 mbr[5] = 0xfe; 740 mbr[6] = 0xff; 741 mbr[7] = 0xff; 742 743 tmp = lendian_int(mac_lba * 4); 744 memcpy(&mbr[8], &tmp, sizeof(tmp)); 745 746 tmp = lendian_int(mac_count); 747 memcpy(&mbr[12], &tmp, sizeof(tmp)); 748 } 749 #endif 750 mbr += 16; 751 } 752 mbr[0] = 0x55; 753 mbr[1] = 0xAA; 754 mbr += 2; 755 756 return mbr - rbm; 757 } 758 759 void 760 display_mbr(const uint8_t *mbr, size_t len) 761 { 762 unsigned char c = 0; 763 unsigned int i = 0, j = 0; 764 765 printf("sizeof(MBR): %zu bytes\n", len); 766 for (i = 0; i < len; i++) 767 { 768 if (!(i % 16)) 769 printf("%04d ", i); 770 771 if (!(i % 8)) 772 printf(" "); 773 774 c = mbr[i]; 775 printf("%02x ", c); 776 777 if (!((i + 1) % 16)) 778 { 779 printf(" |"); 780 for (; j <= i; j++) 781 printf("%c", isprint(mbr[j]) ? mbr[j] : '.'); 782 printf("|\n"); 783 } 784 } 785 } 786 787 788 uint32_t chksum_crc32 (unsigned char *block, unsigned int length) 789 { 790 register unsigned long crc; 791 unsigned long i; 792 793 crc = 0xFFFFFFFF; 794 for (i = 0; i < length; i++) 795 { 796 crc = ((crc >> 8) & 0x00FFFFFF) ^ crc_tab[(crc ^ *block++) & 0xFF]; 797 } 798 return (crc ^ 0xFFFFFFFF); 799 } 800 801 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 802 void 803 reverse_uuid(uuid_t uuid) 804 { 805 uint8_t t, *p = (uint8_t *)uuid; 806 807 t = p[0]; p[0] = p[3]; p[3] = t; 808 t = p[1]; p[1] = p[2]; p[2] = t; 809 t = p[4]; p[4] = p[5]; p[5] = t; 810 t = p[6]; p[6] = p[7]; p[7] = t; 811 } 812 #endif 813 814 static uint16_t * 815 ascii_to_utf16le(uint16_t *dst, const char *src) 816 { 817 uint8_t *p = (uint8_t *)dst; 818 char c; 819 820 do { 821 c = *src++; 822 *p++ = c; 823 *p++ = 0; 824 } while (c); 825 826 return (uint16_t *)p; 827 } 828 829 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 830 void 831 initialise_gpt(uint8_t *gpt, uint32_t current, uint32_t alternate, int primary) 832 { 833 struct gpt_header *header = (struct gpt_header *)gpt; 834 struct gpt_part_header *part; 835 int hole = 0; 836 int gptsize = 128 / 4 + 2; 837 838 if (mac_lba) { 839 /* 2048 bytes per partition, plus round to 2048 boundary */ 840 hole = (apm_parts * 4) + 2; 841 } 842 843 if (primary) { 844 uuid_generate(disk_uuid); 845 reverse_uuid(disk_uuid); 846 } 847 848 header->signature = lendian_64(0x5452415020494645ull); 849 header->revision = lendian_int(0x010000); 850 header->headerSize = lendian_int(0x5c); 851 header->currentLBA = lendian_64(current); 852 header->backupLBA = lendian_64(alternate); 853 header->firstUsableLBA = lendian_64(gptsize + hole); 854 header->lastUsableLBA = lendian_64((isostat.st_size + padding)/512 - 855 gptsize); 856 if (primary) 857 header->partitionEntriesLBA = lendian_64(0x02 + hole); 858 else 859 header->partitionEntriesLBA = lendian_64(current - (128 / 4)); 860 header->numParts = lendian_int(0x80); 861 header->sizeOfPartitionEntries = lendian_int(0x80); 862 memcpy(header->diskGUID, disk_uuid, sizeof(uuid_t)); 863 864 if (primary) 865 gpt += sizeof(struct gpt_header) + hole * 512; 866 else 867 gpt -= header->sizeOfPartitionEntries * header->numParts; 868 869 part = (struct gpt_part_header *)gpt; 870 if (primary) { 871 uuid_generate(part_uuid); 872 uuid_generate(iso_uuid); 873 reverse_uuid(part_uuid); 874 reverse_uuid(iso_uuid); 875 } 876 877 memcpy(part->partGUID, iso_uuid, sizeof(uuid_t)); 878 memcpy(part->partTypeGUID, basic_partition, sizeof(uuid_t)); 879 part->firstLBA = lendian_64(0); 880 part->lastLBA = lendian_64(psize - 1); 881 ascii_to_utf16le(part->name, "ISOHybrid ISO"); 882 883 gpt += sizeof(struct gpt_part_header); 884 part++; 885 886 memcpy(part->partGUID, part_uuid, sizeof(uuid_t)); 887 memcpy(part->partTypeGUID, basic_partition, sizeof(uuid_t)); 888 part->firstLBA = lendian_64(efi_lba * 4); 889 part->lastLBA = lendian_64(part->firstLBA + efi_count - 1); 890 ascii_to_utf16le(part->name, "ISOHybrid"); 891 892 gpt += sizeof(struct gpt_part_header); 893 894 if (mac_lba) { 895 gpt += sizeof(struct gpt_part_header); 896 897 part++; 898 899 memcpy(part->partGUID, part_uuid, sizeof(uuid_t)); 900 memcpy(part->partTypeGUID, hfs_partition, sizeof(uuid_t)); 901 part->firstLBA = lendian_64(mac_lba * 4); 902 part->lastLBA = lendian_64(part->firstLBA + mac_count - 1); 903 ascii_to_utf16le(part->name, "ISOHybrid"); 904 905 part--; 906 } 907 908 part--; 909 910 header->partitionEntriesCRC = lendian_int (chksum_crc32((uint8_t *)part, 911 header->numParts * header->sizeOfPartitionEntries)); 912 913 header->headerCRC = lendian_int(chksum_crc32((uint8_t *)header, 914 header->headerSize)); 915 } 916 917 void 918 initialise_apm(uint8_t *gpt, uint32_t start) 919 { 920 struct apple_part_header *part = (struct apple_part_header *)gpt; 921 922 part->signature = bendian_short(0x504d); 923 part->map_count = bendian_int(apm_parts); 924 part->start_block = bendian_int(1); 925 part->block_count = bendian_int(4); 926 strcpy(part->name, "Apple"); 927 strcpy(part->type, "Apple_partition_map"); 928 part->data_start = bendian_int(0); 929 part->data_count = bendian_int(10); 930 part->status = bendian_int(0x03); 931 932 part = (struct apple_part_header *)(gpt + 2048); 933 934 part->signature = bendian_short(0x504d); 935 part->map_count = bendian_int(3); 936 part->start_block = bendian_int(efi_lba); 937 part->block_count = bendian_int(efi_count / 4); 938 strcpy(part->name, "EFI"); 939 strcpy(part->type, "Apple_HFS"); 940 part->data_start = bendian_int(0); 941 part->data_count = bendian_int(efi_count / 4); 942 part->status = bendian_int(0x33); 943 944 part = (struct apple_part_header *)(gpt + 4096); 945 946 if (mac_lba) 947 { 948 part->signature = bendian_short(0x504d); 949 part->map_count = bendian_int(3); 950 part->start_block = bendian_int(mac_lba); 951 part->block_count = bendian_int(mac_count / 4); 952 strcpy(part->name, "EFI"); 953 strcpy(part->type, "Apple_HFS"); 954 part->data_start = bendian_int(0); 955 part->data_count = bendian_int(mac_count / 4); 956 part->status = bendian_int(0x33); 957 } else { 958 part->signature = bendian_short(0x504d); 959 part->map_count = bendian_int(3); 960 part->start_block = bendian_int((start/2048) + 10); 961 part->block_count = bendian_int(efi_lba - start/2048 - 10); 962 strcpy(part->name, "ISO"); 963 strcpy(part->type, "Apple_Free"); 964 part->data_start = bendian_int(0); 965 part->data_count = bendian_int(efi_lba - start/2048 - 10); 966 part->status = bendian_int(0x01); 967 } 968 } 969 #endif 970 971 int 972 main(int argc, char *argv[]) 973 { 974 int i = 0; 975 FILE *fp = NULL; 976 uint8_t *buf = NULL, *bufz = NULL; 977 int cylsize = 0, frac = 0; 978 size_t orig_gpt_size, free_space, gpt_size; 979 struct iso_primary_descriptor descriptor; 980 981 prog = strcpy(alloca(strlen(argv[0]) + 1), argv[0]); 982 i = check_option(argc, argv); 983 argc -= i; 984 argv += i; 985 986 if (!argc) 987 { 988 usage(); 989 return 1; 990 } 991 992 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 993 if ((mode & EFI) && offset) 994 errx(1, "%s: --offset is invalid with UEFI images\n", argv[0]); 995 #endif 996 997 srand(time(NULL) << (getppid() << getpid())); 998 999 if (!(fp = fopen(argv[0], "rb+"))) 1000 err(1, "could not open file `%s'", argv[0]); 1001 1002 if (fseeko(fp, (off_t) (16 << 11), SEEK_SET)) 1003 err(1, "%s: seek error - 0", argv[0]); 1004 1005 if (fread(&descriptor, sizeof(char), sizeof(descriptor), fp) != sizeof(descriptor)) 1006 err(1, "%s: read error - 0", argv[0]); 1007 1008 if (fseeko(fp, (off_t) 17 * 2048, SEEK_SET)) 1009 err(1, "%s: seek error - 1", argv[0]); 1010 1011 bufz = buf = calloc(BUFSIZE, sizeof(char)); 1012 if (fread(buf, sizeof(char), BUFSIZE, fp) != BUFSIZE) 1013 err(1, "%s", argv[0]); 1014 1015 if (check_banner(buf)) 1016 errx(1, "%s: could not find boot record", argv[0]); 1017 1018 if (mode & VERBOSE) 1019 printf("catalogue offset: %d\n", catoffset); 1020 1021 if (fseeko(fp, ((off_t) catoffset) * 2048, SEEK_SET)) 1022 err(1, "%s: seek error - 2", argv[0]); 1023 1024 buf = bufz; 1025 memset(buf, 0, BUFSIZE); 1026 if (fread(buf, sizeof(char), BUFSIZE, fp) != BUFSIZE) 1027 err(1, "%s", argv[0]); 1028 1029 if (check_catalogue(buf)) 1030 errx(1, "%s: invalid boot catalogue", argv[0]); 1031 1032 buf += sizeof(ve); 1033 if (read_catalogue(buf)) 1034 errx(1, "%s: unexpected boot catalogue parameters", argv[0]); 1035 1036 if (mode & VERBOSE) 1037 display_catalogue(); 1038 1039 buf += 32; 1040 1041 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 1042 if (mode & EFI) 1043 { 1044 if (!read_efi_section(buf)) { 1045 buf += 32; 1046 if (!read_efi_catalogue(buf, &efi_count, &efi_lba) && efi_lba) { 1047 offset = 0; 1048 } else { 1049 errx(1, "%s: invalid efi catalogue", argv[0]); 1050 } 1051 } else { 1052 errx(1, "%s: unable to find efi image", argv[0]); 1053 } 1054 } 1055 #endif 1056 1057 buf += 32; 1058 1059 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 1060 if (mode & MAC) 1061 { 1062 if (!read_efi_section(buf)) { 1063 buf += 32; 1064 if (!read_efi_catalogue(buf, &mac_count, &mac_lba) && mac_lba) { 1065 offset = 0; 1066 } else { 1067 errx(1, "%s: invalid efi catalogue", argv[0]); 1068 } 1069 } else { 1070 errx(1, "%s: unable to find mac efi image", argv[0]); 1071 } 1072 } 1073 #endif 1074 1075 if (fseeko(fp, (((off_t) de_lba) * 2048 + 0x40), SEEK_SET)) 1076 err(1, "%s: seek error - 3", argv[0]); 1077 1078 buf = bufz; 1079 memset(buf, 0, BUFSIZE); 1080 if (fread(buf, sizeof(char), 4, fp) != 4) 1081 err(1, "%s", argv[0]); 1082 1083 if (memcmp(buf, "\xFB\xC0\x78\x70", 4)) 1084 errx(1, "%s: boot loader does not have an isolinux.bin hybrid " \ 1085 "signature. Note that isolinux-debug.bin does not support " \ 1086 "hybrid booting", argv[0]); 1087 1088 if (stat(argv[0], &isostat)) 1089 err(1, "%s", argv[0]); 1090 1091 isosize = lendian_int(descriptor.size) * lendian_short(descriptor.block_size); 1092 free_space = isostat.st_size - isosize; 1093 1094 cylsize = head * sector * 512; 1095 frac = isostat.st_size % cylsize; 1096 padding = (frac > 0) ? cylsize - frac : 0; 1097 1098 if (mode & VERBOSE) 1099 printf("imgsize: %zu, padding: %d\n", (size_t)isostat.st_size, padding); 1100 1101 cc = c = ( isostat.st_size + padding) / cylsize; 1102 if (c > 1024) 1103 { 1104 warnx("Warning: more than 1024 cylinders: %d", c); 1105 warnx("Not all BIOSes will be able to boot this device"); 1106 cc = 1024; 1107 } 1108 1109 if (!id) 1110 { 1111 if (fseeko(fp, (off_t) 440, SEEK_SET)) 1112 err(1, "%s: seek error - 4", argv[0]); 1113 1114 if (fread(&id, 1, 4, fp) != 4) 1115 err(1, "%s: read error", argv[0]); 1116 1117 id = lendian_int(id); 1118 if (!id) 1119 { 1120 if (mode & VERBOSE) 1121 printf("random "); 1122 id = rand(); 1123 } 1124 } 1125 if (mode & VERBOSE) 1126 printf("id: %u\n", id); 1127 1128 buf = bufz; 1129 memset(buf, 0, BUFSIZE); 1130 i = initialise_mbr(buf); 1131 1132 if (mode & VERBOSE) 1133 display_mbr(buf, i); 1134 1135 if (fseeko(fp, (off_t) 0, SEEK_SET)) 1136 err(1, "%s: seek error - 5", argv[0]); 1137 1138 if (fwrite(buf, sizeof(char), i, fp) != (size_t)i) 1139 err(1, "%s: write error - 1", argv[0]); 1140 1141 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 1142 if (efi_lba) { 1143 reverse_uuid(basic_partition); 1144 reverse_uuid(hfs_partition); 1145 1146 /* 512 byte header, 128 entries of 128 bytes */ 1147 orig_gpt_size = gpt_size = 512 + (128 * 128); 1148 1149 /* Leave space for the APM if necessary */ 1150 if (mac_lba) 1151 gpt_size += (4 * 2048); 1152 1153 buf = calloc(gpt_size, sizeof(char)); 1154 memset(buf, 0, gpt_size); 1155 1156 /* 1157 * We need to ensure that we have enough space for the secondary GPT. 1158 * Unlike the primary, this doesn't need a hole for the APM. We still 1159 * want to be 1MB aligned so just bump the padding by a megabyte. 1160 */ 1161 if (free_space < orig_gpt_size && padding < orig_gpt_size) { 1162 padding += 1024 * 1024; 1163 } 1164 1165 /* 1166 * Determine the size of the ISO filesystem. This will define the size 1167 * of the partition that covers it. 1168 */ 1169 psize = isosize / 512; 1170 1171 /* 1172 * Primary GPT starts at sector 1, secondary GPT starts at 1 sector 1173 * before the end of the image 1174 */ 1175 initialise_gpt(buf, 1, (isostat.st_size + padding - 512) / 512, 1); 1176 1177 if (fseeko(fp, (off_t) 512, SEEK_SET)) 1178 err(1, "%s: seek error - 6", argv[0]); 1179 1180 if (fwrite(buf, sizeof(char), gpt_size, fp) != (size_t)gpt_size) 1181 err(1, "%s: write error - 2", argv[0]); 1182 } 1183 1184 if (mac_lba) 1185 { 1186 /* Apple partition entries filling 2048 bytes each */ 1187 int apm_size = apm_parts * 2048; 1188 1189 buf = realloc(buf, apm_size); 1190 memset(buf, 0, apm_size); 1191 1192 initialise_apm(buf, APM_OFFSET); 1193 1194 fseeko(fp, (off_t) APM_OFFSET, SEEK_SET); 1195 fwrite(buf, sizeof(char), apm_size, fp); 1196 } 1197 #endif 1198 1199 if (padding) 1200 { 1201 if (fsync(fileno(fp))) 1202 err(1, "%s: could not synchronise", argv[0]); 1203 1204 if (ftruncate(fileno(fp), isostat.st_size + padding)) 1205 err(1, "%s: could not add padding bytes", argv[0]); 1206 } 1207 1208 #ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT 1209 if (efi_lba) { 1210 buf = realloc(buf, orig_gpt_size); 1211 memset(buf, 0, orig_gpt_size); 1212 1213 buf += orig_gpt_size - sizeof(struct gpt_header); 1214 1215 initialise_gpt(buf, (isostat.st_size + padding - 512) / 512, 1, 0); 1216 1217 /* Shift back far enough to write the 128 GPT entries */ 1218 buf -= 128 * sizeof(struct gpt_part_header); 1219 1220 /* 1221 * Seek far enough back that the gpt header is 512 bytes before the 1222 * end of the image 1223 */ 1224 1225 if (fseeko(fp, (isostat.st_size + padding) - orig_gpt_size, SEEK_SET)) 1226 err(1, "%s: seek error - 8", argv[0]); 1227 1228 if (fwrite(buf, sizeof(char), orig_gpt_size, fp) != orig_gpt_size) 1229 err(1, "%s: write error - 4", argv[0]); 1230 } 1231 #endif 1232 1233 free(buf); 1234 fclose(fp); 1235 1236 return 0; 1237 } 1238