Chameleon

Chameleon Svn Source Tree

Root/branches/ErmaC/Enoch/i386/boot2/drivers.c

1/*␊
2 * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 * ␊
6 * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights␊
7 * Reserved. This file contains Original Code and/or Modifications of␊
8 * Original Code as defined in and that are subject to the Apple Public␊
9 * Source License Version 2.0 (the 'License'). You may not use this file␊
10 * except in compliance with the License. Please obtain a copy of the␊
11 * License at http://www.apple.com/publicsource and read it before using␊
12 * this file.␊
13 * ␊
14 * The Original Code and all software distributed under the License are␊
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the␊
19 * License for the specific language governing rights and limitations␊
20 * under the License.␊
21 * ␊
22 * @APPLE_LICENSE_HEADER_END@␊
23 */␊
24/*␊
25 * drivers.c - Driver Loading Functions.␊
26 *␊
27 * Copyright (c) 2000 Apple Computer, Inc.␊
28 *␊
29 * DRI: Josh de Cesare␊
30 */␊
31␊
32#include <mach-o/fat.h>␊
33#include <libkern/OSByteOrder.h>␊
34#include <mach/machine.h>␊
35␊
36#include "config.h"␊
37#include "sl.h"␊
38#include "boot.h"␊
39#include "bootstruct.h"␊
40#include "xml.h"␊
41#include "ramdisk.h"␊
42#include "kernel_patcher_internal.h"␊
43#include "modules.h"␊
44␊
45#if FAKESMC_SUPPORT␊
46␉#include "FakeSMC.h"␊
47␉#include "FakeSMCInfo.plist.h"␊
48#endif␊
49␊
50#if DEBUG␊
51␉#define DBG(x...)␉printf(x)␊
52#else␊
53␉#define DBG(x...)␉msglog(x)␊
54#endif␊
55␊
56bool gUseCommonAndOSdir = true;␊
57␊
58struct Module { ␊
59␉struct Module *nextModule;␊
60␉long willLoad;␊
61␉TagPtr dict;␊
62␉char *plistAddr;␊
63␉long plistLength;␊
64␉char *executablePath;␊
65␉char *bundlePath;␊
66␉long bundlePathLength;␊
67};␊
68typedef struct Module Module, *ModulePtr;␊
69␊
70struct DriverInfo {␊
71␉char *plistAddr;␊
72␉long plistLength;␊
73␉void *executableAddr;␊
74␉long executableLength;␊
75␉void *bundlePathAddr;␊
76␉long bundlePathLength;␊
77};␊
78typedef struct DriverInfo DriverInfo, *DriverInfoPtr;␊
79␊
80#define kDriverPackageSignature1 'MKXT'␊
81#define kDriverPackageSignature2 'MOSX'␊
82␊
83struct DriversPackage {␊
84␉unsigned long signature1;␊
85␉unsigned long signature2;␊
86␉unsigned long length;␊
87␉unsigned long adler32;␊
88␉unsigned long version;␊
89␉unsigned long numDrivers;␊
90␉unsigned long reserved1;␊
91␉unsigned long reserved2;␊
92};␊
93typedef struct DriversPackage DriversPackage;␊
94␊
95enum {␊
96␉kCFBundleType2,␊
97␉kCFBundleType3␊
98};␊
99␊
100long (*LoadExtraDrivers_p)(FileLoadDrivers_t FileLoadDrivers_p);␊
101␊
102static inline unsigned long Adler32( unsigned char * buffer, long length );␊
103␊
104long FileLoadDrivers(char *dirSpec, long plugin);␊
105long NetLoadDrivers(char *dirSpec);␊
106long LoadDriverMKext(char *fileSpec);␊
107long LoadDriverPList(char *dirSpec, char *name, long bundleType);␊
108␊
109#if FAKESMC_SUPPORT␊
110␉void loadEmbeddedFakeSMC(void);␊
111#endif␊
112␊
113long LoadEmbeddedKext( char *InjectorPlist, size_t length, char *name );␊
114long LoadMatchedModules(void);␊
115void buildAndLoadInjectorPList(void);␊
116static long MatchPersonalities(void);␊
117static long MatchLibraries(void);␊
118␊
119#ifdef NOTDEF␊
120␉static ModulePtr FindModule(char *name);␊
121␉static void ThinFatFile(void **loadAddrP, unsigned long *lengthP);␊
122#endif␊
123␊
124bool isKextForcedToLoad(char *kext);␊
125static long ParseXML(char *buffer, ModulePtr *module, TagPtr *personalities, bool forceKextToLoad);␊
126static long InitDriverSupport(void);␊
127␊
128ModulePtr gModuleHead, gModuleTail;␊
129static TagPtr␉gPersonalityHead, gPersonalityTail;␊
130static char␉*gExtensionsSpec;␊
131static char␉*gDriverSpec;␊
132static char␉*gFileSpec;␊
133static char␉*gTempSpec;␊
134static char␉*gFileName;␊
135// Bungo:␊
136char gDarwinBuildVerStr[256] = "Darwin Kernel Version";␊
137␊
138static inline unsigned long Adler32( unsigned char *buffer, long length )␊
139{␊
140␉long cnt;␊
141␉unsigned long result, lowHalf, highHalf;␊
142␊
143␉lowHalf = 1;␊
144␉highHalf = 0;␊
145␊
146␉for (cnt = 0; cnt < length; cnt++)␊
147␉{␊
148␉␉if ((cnt % 5000) == 0)␊
149␉␉{␊
150␉␉␉lowHalf %= 65521L;␊
151␉␉␉highHalf %= 65521L;␊
152␉␉}␊
153␊
154␉␉lowHalf += buffer[cnt];␊
155␉␉highHalf += lowHalf;␊
156␉}␊
157␊
158␉lowHalf %= 65521L;␊
159␉highHalf %= 65521L;␊
160␊
161␉result = (highHalf << 16) | lowHalf;␊
162␊
163␉return result;␊
164}␊
165␊
166//==========================================================================␊
167// InitDriverSupport␊
168static long InitDriverSupport( void )␊
169{␊
170␉gExtensionsSpec = malloc( 4096 );␊
171␉gDriverSpec = malloc( 4096 );␊
172␉gFileSpec = malloc( 4096 );␊
173␉gTempSpec = malloc( 4096 );␊
174␉gFileName = malloc( 4096 );␊
175␊
176␉if ( !gExtensionsSpec || !gDriverSpec || !gFileSpec || !gTempSpec || !gFileName )␊
177␉{␊
178␉␉stop("InitDriverSupport error");␊
179␉}␊
180␊
181␉return 0;␊
182}␊
183␊
184//==========================================================================␊
185// LoadDrivers␊
186long LoadDrivers( char *dirSpec )␊
187{␊
188␉char dirSpecExtra[1024];␊
189␉long flags, ret=-1;␊
190␉u_int32_t time;␊
191␊
192␉if ( InitDriverSupport() != 0 )␊
193␉{␊
194␉␉return 0;␊
195␉}␊
196␊
197␉// ========================================␊
198␉gUseCommonAndOSdir = false; // old behavior␊
199␊
200␉ret = GetFileInfo("bt(0,0)/Extra/Extensions/", "Common", &flags, &time);␊
201␊
202␉// if the boot partition contains /Extra/Extensions/Common there is no need␊
203␉// to look else where because users will have also /Extra/Extensions/10.x␊
204␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory))␊
205␉{␊
206␉␉gUseCommonAndOSdir = true;␊
207␉␉verbose("/Extra/Extensions/Common and /Extra/Extensions/%s in use.\n", gBootVolume->OSVersion);␊
208␉␉//getchar();␊
209␉}␊
210␉// ========================================␊
211␊
212␉// Load extra drivers if a hook has been installed.␊
213␉if (LoadExtraDrivers_p != NULL)␊
214␉{␊
215␉␉(*LoadExtraDrivers_p)(&FileLoadDrivers);␊
216␉}␊
217␊
218␉if ( gBootFileType == kNetworkDeviceType )␊
219␉{␊
220␉␉if (NetLoadDrivers(dirSpec) != 0)␊
221␉␉{␊
222␉␉␉error("LoadDrivers: Could not load drivers from the network\n");␊
223␉␉␉return -1;␊
224␉␉}␊
225␉}␊
226␉else if ( gBootFileType == kBlockDeviceType )␊
227␉{␊
228␉␉// First try to load Extra extensions from the ramdisk if isn't aliased as bt(0,0).␊
229␉␉if (gRAMDiskVolume && !gRAMDiskBTAliased)␊
230␉␉{␊
231␉␉␉strcpy(dirSpecExtra, "rd(0,0)/Extra/");␊
232␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
233␉␉}␊
234␉␉// =====================================================================␊
235␉␉// Secondly try to load drivers from Common folder if in use␊
236␉␉if (gUseCommonAndOSdir)␊
237␉␉{␊
238␉␉␉sprintf(dirSpecExtra, "bt(0,0)/Extra/Extensions/Common");␊
239␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
240␉␉}␊
241␉␉// =====================================================================␊
242␊
243␉␉// Next try to load Extra extensions from the selected root partition.␊
244␉␉if (gUseCommonAndOSdir)␊
245␉␉{␊
246␉␉␉sprintf(dirSpecExtra, "bt(0,0)/Extra/Extensions/%s", gBootVolume->OSVersion);␊
247␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
248␉␉␉//verbose("gUseCommonAndOSdir = %s\n", dirSpecExtra);␊
249␉␉␉//getchar();␊
250␉␉}␊
251␉␉else␊
252␉␉{␊
253␉␉␉strlcpy(dirSpecExtra, "/Extra/", sizeof(dirSpecExtra));␊
254␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
255␉␉␉{␊
256␉␉␉␉// If failed, then try to load Extra extensions from the boot partition␊
257␉␉␉␉// in case we have a separate booter partition or a bt(0,0) aliased ramdisk.␊
258␉␉␉␉if ( !(gBIOSBootVolume->biosdev == gBootVolume->biosdev && gBIOSBootVolume->part_no == gBootVolume->part_no)␊
259␉␉␉␉␉|| (gRAMDiskVolume && gRAMDiskBTAliased) )␊
260␉␉␉␉{␊
261␉␉␉␉␉// Next try a specfic OS version folder ie 10.12␊
262␉␉␉␉␉sprintf(dirSpecExtra, "bt(0,0)/Extra/%s/", &gMacOSVersion[0]);␊
263␉␉␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
264␉␉␉␉␉{␊
265␉␉␉␉␉␉// Next we'll try the base␊
266␉␉␉␉␉␉strlcpy(dirSpecExtra, "bt(0,0)/Extra/", sizeof(dirSpecExtra));␊
267␉␉␉␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
268␉␉␉␉␉}␊
269␉␉␉␉}␊
270␉␉␉}␊
271␉␉}␊
272␊
273␉␉if(!gHaveKernelCache)␊
274␉␉{␊
275␉␉␉// Don't load main driver (from /System/Library/Extentions) if gHaveKernelCache is set.␊
276␉␉␉// since these drivers will already be in the kernel cache.␊
277␉␉␉// NOTE: when gHaveKernelCache, xnu cannot (by default) load *any* extra kexts from the bootloader.␊
278␉␉␉// The /Extra code is not disabled in this case due to a kernel patch that allows for this to happen.␊
279␊
280␉␉␉// Also try to load Extensions from boot helper partitions.␊
281␉␉␉if (gBootVolume->flags & kBVFlagBooter)␊
282␉␉␉{␊
283␉␉␉␉strlcpy(dirSpecExtra, "/com.apple.boot.P/System/Library/", sizeof(dirSpecExtra));␊
284␉␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
285␉␉␉␉{␊
286␉␉␉␉␉strlcpy(dirSpecExtra, "/com.apple.boot.R/System/Library/", sizeof(dirSpecExtra));␊
287␉␉␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
288␉␉␉␉␉{␊
289␉␉␉␉␉␉strlcpy(dirSpecExtra, "/com.apple.boot.S/System/Library/", sizeof(dirSpecExtra));␊
290␉␉␉␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
291␉␉␉␉␉}␊
292␉␉␉␉}␊
293␉␉␉}␊
294␊
295␉␉␉if (gMKextName[0] != '\0')␊
296␉␉␉{␊
297␉␉␉␉verbose("LoadDrivers: Loading from '%s'\n", gMKextName);␊
298␉␉␉␉if ( LoadDriverMKext(gMKextName) != 0 )␊
299␉␉␉␉{␊
300␉␉␉␉␉error("Could not load %s\n", gMKextName);␊
301␉␉␉␉␉return -1;␊
302␉␉␉␉}␊
303␉␉␉}␊
304␉␉␉else␊
305␉␉␉{␊
306␉␉␉␉verbose("Attempting to load drivers from standard repositories:\n");␊
307␊
308␉␉␉␉if ( (gMacOSVersion[3] == '9') || ((gMacOSVersion[3] == '1') && ((gMacOSVersion[4] == '0') || (gMacOSVersion[4] == '1') || (gMacOSVersion[4] == '2') ) )) // issue 352␊
309␉␉␉␉{␊
310␉␉␉␉␉verbose("\t- Third party extensions search path: /Library/Extensions\n");␊
311␉␉␉␉␉strlcpy(gExtensionsSpec, dirSpec, 4087); /* 4096 - sizeof("Library/") mean 4096 - 9 = 4087 */␊
312␉␉␉␉␉strcat(gExtensionsSpec, gUseCommonAndOSdir ? "Library/Extensions" : "Library/");␊
313␉␉␉␉␉FileLoadDrivers(gExtensionsSpec, 0);␊
314␉␉␉␉}␊
315␊
316␉␉␉␉verbose("\t- Apple extensions search path: /System/Library/Extensions\n");␊
317␉␉␉␉strlcpy(gExtensionsSpec, dirSpec, 4080); /* 4096 - sizeof("System/Library/") mean 4096 -16 = 4080 */␊
318␉␉␉␉strcat(gExtensionsSpec, gUseCommonAndOSdir ? "System/Library/Extensions" : "System/Library/");␊
319␉␉␉␉FileLoadDrivers(gExtensionsSpec, 0);␊
320␉␉␉}␊
321␊
322␉␉}␊
323␉}␊
324␉else␊
325␉{␊
326␉␉return 0;␊
327␉}␊
328␊
329#if FAKESMC_SUPPORT␊
330␉if (!FakeSMCLoaded && archCpuType != CPU_TYPE_I386)␊
331␉{␊
332␉␉loadEmbeddedFakeSMC();␊
333␉}␊
334#endif␊
335␊
336␉buildAndLoadInjectorPList();␊
337␊
338␉MatchPersonalities();␊
339␊
340␉MatchLibraries();␊
341␊
342␉LoadMatchedModules();␊
343␊
344␉return 0;␊
345}␊
346␊
347//==========================================================================␊
348// FileLoadMKext␊
349static long FileLoadMKext( const char *dirSpec, const char *extDirSpec )␊
350{␊
351␉long␉␉ret, flags;␊
352␉u_int32_t␉time, time2;␊
353␉char␉␉altDirSpec[512];␊
354␉␊
355␉snprintf(altDirSpec, sizeof(altDirSpec), "%s%s", dirSpec, extDirSpec);␊
356␉ret = GetFileInfo(altDirSpec, "Extensions.mkext", &flags, &time);␊
357␊
358␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeFlat))␊
359␉{␊
360␉␉ret = GetFileInfo(dirSpec, "Extensions", &flags, &time2);␊
361␊
362␉␉if ((ret != 0)␊
363␉␉␉|| ((flags & kFileTypeMask) != kFileTypeDirectory)␊
364␉␉␉|| (((gBootMode & kBootModeSafe) == 0) && (time == (time2 + 1))))␊
365␉␉{␊
366␉␉␉snprintf(gDriverSpec, sizeof(altDirSpec) + 18, "%sExtensions.mkext", altDirSpec);␊
367␉␉␉verbose("LoadDrivers: Loading from '%s'\n", gDriverSpec);␊
368␊
369␉␉␉if (LoadDriverMKext(gDriverSpec) == 0)␊
370␉␉␉{␊
371␉␉␉␉return 0;␊
372␉␉␉}␊
373␉␉}␊
374␉}␊
375␉return -1;␊
376}␊
377␊
378//==========================================================================␊
379// FileLoadDrivers␊
380long FileLoadDrivers( char *dirSpec, long plugin )␊
381{␊
382␉long long␉index;␊
383␉long␉␉ret, length, flags, bundleType;␊
384␉long␉␉result = -1;␊
385␉u_int32_t␉time;␊
386␉const char␉* name;␊
387␊
388␉if ( !plugin )␊
389␉{␊
390␉␉// First try 10.6's path for loading Extensions.mkext.␊
391␉␉if (FileLoadMKext(dirSpec, "Caches/com.apple.kext.caches/Startup/") == 0) {␊
392␉␉␉return 0;␊
393␉␉}␊
394␊
395␉␉// Next try the legacy path.␊
396␉␉else if (FileLoadMKext(dirSpec, "") == 0)␊
397␉␉{␊
398␉␉␉return 0;␊
399␉␉}␊
400␊
401␉␉if (!gUseCommonAndOSdir)␊
402␉␉{␊
403␉␉␉// means that we already provide a full path to the Extensions directory␊
404␉␉␉strcat(dirSpec, "Extensions");␊
405␉␉}␊
406␉}␊
407␊
408␉index = 0;␊
409␉while (1)␊
410␉{␊
411␉␉ret = GetDirEntry(dirSpec, &index, &name, &flags, &time);␊
412␉␉if (ret == -1) {␊
413␉␉␉break;␊
414␉␉}␊
415␊
416␉␉// Make sure this is a directory.␊
417␉␉if ((flags & kFileTypeMask) != kFileTypeDirectory)␊
418␉␉{␊
419␉␉␉continue;␊
420␉␉}␊
421␊
422␉␉// Make sure this is a kext.␊
423␉␉length = strlen(name);␊
424␉␉if (strncmp(name + length - 5, ".kext", sizeof(".kext") ))␊
425␉␉{␊
426␉␉␉continue;␊
427␉␉}␊
428␊
429␉␉// Save the file name.␊
430␉␉strlcpy(gFileName, name, 4096);␊
431␊
432␉␉// Determine the bundle type.␊
433␉␉snprintf(gTempSpec, 4096, "%s/%s", dirSpec, gFileName);␊
434␉␉ret = GetFileInfo(gTempSpec, "Contents", &flags, &time);␊
435␉␉if (ret == 0)␊
436␉␉{␊
437␉␉␉bundleType = kCFBundleType2;␊
438␉␉}␊
439␉␉else␊
440␉␉{␊
441␉␉␉bundleType = kCFBundleType3;␊
442␉␉}␊
443␊
444␉␉if (!plugin)␊
445␉␉{␊
446␉␉␉snprintf(gDriverSpec, 4096, "%s/%s/%sPlugIns", dirSpec, gFileName, (bundleType == kCFBundleType2) ? "Contents/" : "");␊
447␉␉}␊
448␊
449␉␉ret = LoadDriverPList(dirSpec, gFileName, bundleType);␊
450␊
451␉␉if (result != 0)␊
452␉␉{␊
453␉␉␉result = ret;␊
454␉␉}␊
455␊
456␉␉if (!plugin)␊
457␉␉{␊
458␉␉␉FileLoadDrivers(gDriverSpec, 1);␊
459␉␉}␊
460␉}␊
461␊
462␉return result;␊
463}␊
464␊
465//==========================================================================␊
466// ␊
467long NetLoadDrivers( char *dirSpec )␊
468{␊
469␉long tries;␊
470␊
471#if NODEF␊
472␉long cnt;␊
473␊
474␉// Get the name of the kernel␊
475␉cnt = strlen(gBootFile);␊
476␉while (cnt--) {␊
477␉␉if ((gBootFile[cnt] == '\\') || (gBootFile[cnt] == ','))␊
478␉␉{␊
479␉␉␉cnt++;␊
480␉␉␉break;␊
481␉␉}␊
482␉}␊
483#endif␊
484␊
485␉// INTEL modification␊
486␉snprintf(gDriverSpec, 4096, "%s%s.mkext", dirSpec, bootInfo->bootFile);␊
487 ␊
488␉verbose("NetLoadDrivers: Loading from [%s]\n", gDriverSpec);␊
489 ␊
490␉tries = 3;␊
491␉while (tries--)␊
492␉{␊
493␉␉if (LoadDriverMKext(gDriverSpec) == 0)␊
494␉␉{␊
495␉␉␉break;␊
496␉␉}␊
497␉}␊
498␉if (tries == -1)␊
499␉{␊
500␉␉return -1;␊
501␉}␊
502␊
503␉return 0;␊
504}␊
505␊
506//==========================================================================␊
507// loadDriverMKext␊
508long LoadDriverMKext( char *fileSpec )␊
509{␊
510␉unsigned long␉driversAddr, driversLength;␊
511␉long␉␉length;␊
512␉char␉␉segName[32];␊
513␉DriversPackage␉*package;␊
514␊
515#define GetPackageElement(e) OSSwapBigToHostInt32(package->e)␊
516␊
517␉// Load the MKext.␊
518␉length = LoadThinFatFile(fileSpec, (void **)&package);␊
519␉if (length < sizeof (DriversPackage))␊
520␉{␊
521␉␉return -1;␊
522␉}␊
523␊
524␉// call hook to notify modules that the mkext has been loaded␊
525␉execute_hook("LoadDriverMKext", (void *)fileSpec, (void *)package, (void *) &length, NULL);␊
526␊
527␉␊
528␉// Verify the MKext.␊
529␉if (( GetPackageElement(signature1) != kDriverPackageSignature1) ||␊
530␉␉( GetPackageElement(signature2) != kDriverPackageSignature2) ||␊
531␉␉( GetPackageElement(length) > kLoadSize ) ||␊
532␉␉( GetPackageElement(adler32) !=␊
533␉␉Adler32((unsigned char *)&package->version, GetPackageElement(length) - 0x10) ) )␊
534␉{␊
535␉␉return -1;␊
536␉}␊
537␊
538␉// Make space for the MKext.␊
539␉driversLength = GetPackageElement(length);␊
540␉driversAddr = AllocateKernelMemory(driversLength);␊
541␊
542␉// Copy the MKext.␊
543␉memcpy((void *)driversAddr, (void *)package, driversLength);␊
544␊
545␉// Add the MKext to the memory map.␊
546␉snprintf(segName, sizeof(segName), "DriversPackage-%lx", driversAddr);␊
547␉AllocateMemoryRange(segName, driversAddr, driversLength, kBootDriverTypeMKEXT);␊
548␊
549␉return 0;␊
550}␊
551␊
552//==========================================================================␊
553// buildAndLoadInjectorPList␊
554void buildAndLoadInjectorPList(void)␊
555{␊
556␉TagPtr PersTag = NULL;␊
557␉if ((PersTag = XMLCastDict(XMLGetProperty(bootInfo->kextConfig.dictionary, (const char *)"PersonalitiesInjector"))))␊
558␉{␊
559␉␉unsigned long count = XMLTagCount(PersTag);␊
560␉␉if (count)␊
561␉␉{␊
562␉␉␉verbose("Attempting to generate and load custom injectors kexts:\n");␊
563␉␉}␊
564␊
565␉␉while(count)␊
566␉␉{␊
567␉␉␉bool canLoad = false;␊
568␉␉␉//int length = 0;␊
569␉␉␉char *kextName = strdup(XMLCastString(XMLGetKey(PersTag, count)));␊
570␊
571␉␉␉TagPtr sub = XMLGetProperty(PersTag, kextName);␊
572␊
573␉␉␉if (sub && XMLIsDict(sub))␊
574␉␉␉{␊
575␉␉␉␉TagPtr IOKPTag = NULL;␊
576␉␉␉␉char *MatchOS = NULL;␊
577␉␉␉␉char *Comment = NULL;␊
578␉␉␉␉char *OSBundleRequired = NULL;␊
579␉␉␉␉IOKPTag = XMLGetProperty(sub, (const char*)"IOKitPersonalities");␊
580␉␉␉␉Comment = XMLCastString(XMLGetProperty(sub, (const char*)"Comment"));␊
581␉␉␉␉MatchOS = XMLCastString(XMLGetProperty(sub, (const char*)"MatchOS"));␊
582␉␉␉␉OSBundleRequired = XMLCastString(XMLGetProperty(sub, (const char*)"OSBundleRequired"));␊
583␊
584␉␉␉␉Comment = (Comment != NULL && strlen(Comment) >0) ? Comment : "untitled";␊
585␉␉␉␉MatchOS = (MatchOS != NULL && strlen(MatchOS) >0) ? MatchOS : "";␊
586␉␉␉␉OSBundleRequired = (OSBundleRequired != NULL && strlen(OSBundleRequired) >0) ? OSBundleRequired : "";␊
587␉␉␉␉canLoad = true;␊
588␊
589␉␉␉␉if (strlen(MatchOS))␊
590␉␉␉␉{␊
591␉␉␉␉␉// check MatchOS and disable this patch if does not match␊
592␉␉␉␉␉canLoad = IsPatchEnabled(MatchOS, (char *)gMacOSVersion);␊
593␉␉␉␉}␊
594␉␉␉␉else␊
595␉␉␉␉{␊
596␉␉␉␉␉MatchOS = "not set";␊
597␉␉␉␉}␊
598␊
599␉␉␉␉if (canLoad)␊
600␉␉␉␉{␊
601␉␉␉␉␉if (XMLIsDict(IOKPTag))␊
602␉␉␉␉␉{␊
603␉␉␉␉␉␉char *inj= XMLGenerateKextInjectorFromTag(IOKPTag, kextName, OSBundleRequired);␊
604␊
605␉␉␉␉␉␉if (inj != NULL && strlen(inj))␊
606␉␉␉␉␉␉{␊
607␉␉␉␉␉␉␉verbose("\t- Loading %s.kext (%s) MatchOS[ %s ]: ", kextName, Comment, MatchOS);␊
608␉␉␉␉␉␉␉verbose("%s!\n", (LoadEmbeddedKext( inj, strlen(inj)+1, kextName ) == 0) ? "success" : "failed");␊
609␉␉␉␉␉␉}␊
610␉␉␉␉␉␉else␊
611␉␉␉␉␉␉{␊
612␉␉␉␉␉␉␉verbose("\t- Error building %s personality, skipped\n", kextName);␊
613␉␉␉␉␉␉}␊
614␉␉␉␉␉}␊
615␉␉␉␉␉else␊
616␉␉␉␉␉{␊
617␉␉␉␉␉␉verbose("\t- skipping %s personality (%s) MatchOS[ %s ]: not a dictionary\n", kextName, Comment, MatchOS);␊
618␉␉␉␉␉}␊
619␉␉␉␉}␊
620␉␉␉␉else␊
621␉␉␉␉{␊
622␉␉␉␉␉verbose("\t- skipping %s personality (%s) MatchOS[ %s ]\n", kextName, Comment, MatchOS);␊
623␉␉␉␉}␊
624␉␉␉}␊
625␉␉count--;␊
626␉␉}␊
627␉}␊
628}␊
629//==========================================================================␊
630// loadEmbeddedFakeSMC␊
631#if FAKESMC_SUPPORT␊
632void loadEmbeddedFakeSMC(void)␊
633{␊
634␉void *embedded = NULL;␊
635␉embedded = malloc(FakeSMCInfo_plist_un_len); // don't free, will be done in LoadEmbeddedKext␊
636␉size_t size = lzvn_decode(embedded,␊
637 FakeSMCInfo_plist_un_len,␊
638 FakeSMCInfo_plist,␊
639 FakeSMCInfo_plist_lzvn_len);␊
640␊
641␉if (FakeSMCInfo_plist_un_len != size)␊
642␉{␊
643␉␉verbose("\n\t ERROR! FakeSMC size mismatch from lzvn (found: %zx, expected: %zx), failed!\n", size, FakeSMCInfo_plist_un_len);␊
644␉}␊
645␉else␊
646␉{␊
647␉␉LoadEmbeddedKext((char *)embedded, size, "EmbeddedFakeSMC" );␊
648␉}␊
649}␊
650#endif␊
651␊
652//==========================================================================␊
653// LoadEmbeddedKext␊
654long LoadEmbeddedKext( char *InjectorPlist, size_t length, char *name )␊
655{␊
656␉long␉␉executablePathLength, bundlePathLength;␊
657␉ModulePtr␉module;␊
658␉TagPtr␉␉personalities;␊
659␉char␉␉*tmpExecutablePath = 0;␊
660␉char␉␉*tmpBundlePath = 0;␊
661␉char␉␉*realAddr = NULL;␊
662␉long␉␉ret = -1;␊
663␊
664␉do {␊
665␉␉snprintf(gFileSpec, 4096, "%s/%s.kext/%s", "/System/Library/Extensions", name, "Contents/MacOS/");␊
666␉␉executablePathLength = strlen(gFileSpec) + 1;␊
667␊
668␉␉tmpExecutablePath = malloc(executablePathLength);␊
669␊
670␉␉if (tmpExecutablePath == 0)␊
671␉␉{␊
672␉␉␉break;␊
673␉␉}␊
674␊
675␉␉strlcpy(tmpExecutablePath, gFileSpec, executablePathLength);␊
676␉␉snprintf(gFileSpec, 4096, "%s/%s.kext", "/System/Library/Extensions", name);␊
677␉␉bundlePathLength = strlen(gFileSpec) + 1;␊
678␊
679␉␉tmpBundlePath = malloc(bundlePathLength);␊
680␊
681␉␉if (tmpBundlePath == 0)␊
682␉␉{␊
683␉␉␉break;␊
684␉␉}␊
685␊
686␉␉strlcpy(tmpBundlePath, gFileSpec, bundlePathLength);␊
687␊
688␉␉// Construct the file spec to the plist, then load it.␊
689␉␉snprintf(gFileSpec, 4096, "%s/%s.kext/Contents/Info.plist", "/System/Library/Extensions", name);␊
690␊
691␉␉// bug, after ParseXML something weired happened to InjectorPlist. Making a copy␊
692␉␉realAddr = malloc(length);␊
693␉␉strlcpy(realAddr, InjectorPlist, length);␊
694␉␉ret = ParseXML((char *)InjectorPlist, &module, &personalities, true);␊
695␊
696␉␉if (ret != 0)␊
697␉␉{␊
698␉␉␉break;␊
699␉␉}␊
700␊
701␉␉if (!module) // cparm␊
702␉␉{␊
703␉␉␉ret = -1;␊
704␉␉␉break;␊
705␉␉} // Should never happen but it will make the compiler happy␊
706␊
707␉␉// Allocate memory for the driver path and the plist.␊
708␉␉module->executablePath = tmpExecutablePath;␊
709␉␉module->bundlePath = tmpBundlePath;␊
710␉␉module->bundlePathLength = bundlePathLength;␊
711␊
712␉␉module->plistAddr = malloc(length);␊
713␊
714␉␉if ((module->executablePath == 0) || (module->bundlePath == 0) || (module->plistAddr == 0))␊
715␉␉{␊
716␉␉␉verbose("(executablePath or bundlePath or plistAddr are 0) ");␊
717␉␉␉ret = -1;␊
718␉␉␉break;␊
719␉␉}␊
720␊
721␉␉tmpExecutablePath = 0;␊
722␉␉tmpBundlePath = 0;␊
723␊
724␉␉strlcpy(module->plistAddr, realAddr, length);␊
725␉␉module->plistLength = length;␊
726␉␉// Add the module to the end of the module list.␊
727␊
728␉␉if (gModuleHead == 0)␊
729␉␉{␊
730␉␉␉gModuleHead = module;␊
731␉␉}␊
732␉␉else␊
733␉␉{␊
734␉␉␉gModuleTail->nextModule = module;␊
735␉␉}␊
736␉␉gModuleTail = module;␊
737␊
738␉␉// Add the persionalities to the personality list.␊
739␉␉if (personalities)␊
740␉␉{␊
741␉␉␉personalities = personalities->tag;␊
742␉␉}␊
743␉␉while (personalities != 0)␊
744␉␉{␊
745␉␉␉if (gPersonalityHead == 0)␊
746␉␉␉{␊
747␉␉␉␉gPersonalityHead = personalities->tag;␊
748␉␉␉}␊
749␉␉␉else␊
750␉␉␉{␊
751␉␉␉␉gPersonalityTail->tagNext = personalities->tag;␊
752␉␉␉}␊
753␊
754␉␉␉gPersonalityTail = personalities->tag;␊
755␉␉␉personalities = personalities->tagNext;␊
756␉␉}␊
757␉␉ret = 0;␊
758␊
759␉}while (0);␊
760␊
761␉if (realAddr)␊
762␉{␊
763␉␉free(realAddr);␊
764␉}␊
765␊
766␉if ( strlen(InjectorPlist) )␊
767␉{␊
768␉␉free( InjectorPlist );␊
769␉}␊
770␊
771␉if ( tmpExecutablePath )␊
772␉{␊
773␉␉free( tmpExecutablePath );␊
774␉}␊
775␊
776␉if ( tmpBundlePath )␊
777␉{␊
778␉␉free( tmpBundlePath );␊
779␉}␊
780␉return ret;␊
781}␊
782␊
783//==========================================================================␊
784// LoadDriverPList␊
785long LoadDriverPList( char *dirSpec, char *name, long bundleType )␊
786{␊
787␉long␉␉length, executablePathLength, bundlePathLength;␊
788␉ModulePtr␉module;␊
789␉TagPtr␉␉personalities;␊
790␉char␉␉*buffer = 0;␊
791␉char␉␉*tmpExecutablePath = 0;␊
792␉char␉␉*tmpBundlePath = 0;␊
793␉long␉␉ret = -1;␊
794␊
795␉do {␊
796␉// Save the driver path.␊
797 ␊
798␉if(name)␊
799␉{␊
800␉␉if (!strcmp(name, "FakeSMC.kext")) {␊
801␉␉␉FakeSMCLoaded = true;␊
802␉␉}␊
803␉␉snprintf(gFileSpec, 4096, "%s/%s/%s", dirSpec, name, (bundleType == kCFBundleType2) ? "Contents/MacOS/" : "");␊
804␉}␊
805␉else␊
806␉{␊
807␉␉snprintf(gFileSpec, 4096, "%s/%s", dirSpec, (bundleType == kCFBundleType2) ? "Contents/MacOS/" : "");␊
808␉}␊
809␉executablePathLength = strlen(gFileSpec) + 1;␊
810␊
811␉tmpExecutablePath = malloc(executablePathLength);␊
812␉if (tmpExecutablePath == 0) {␊
813␉␉break;␊
814␉}␊
815␉strlcpy(tmpExecutablePath, gFileSpec, executablePathLength);␊
816␊
817␉if(name)␊
818␉{␊
819␉␉snprintf(gFileSpec, 4096, "%s/%s", dirSpec, name);␊
820␉}␊
821␉else␊
822␉{␊
823␉␉strncpy(gFileSpec, dirSpec, 4096);␊
824␉}␊
825␉bundlePathLength = strlen(gFileSpec) + 1;␊
826␊
827␉tmpBundlePath = malloc(bundlePathLength);␊
828␉if (tmpBundlePath == 0)␊
829␉{␊
830␉␉break;␊
831␉}␊
832␊
833␉strlcpy(tmpBundlePath, gFileSpec, bundlePathLength);␊
834␊
835␉// Construct the file spec to the plist, then load it.␊
836␊
837␉if(name)␊
838␉{␊
839␉␉snprintf(gFileSpec, 4096, "%s/%s/%sInfo.plist", dirSpec, name, (bundleType == kCFBundleType2) ? "Contents/" : "");␊
840␉}␊
841␉else␊
842␉{␊
843␉␉snprintf(gFileSpec, 4096, "%s/%sInfo.plist", dirSpec, (bundleType == kCFBundleType2) ? "Contents/" : "");␊
844␉}␊
845␊
846␉length = LoadFile(gFileSpec);␊
847␊
848␉if (length == -1)␊
849␉{␊
850␉␉break;␊
851␉}␊
852␊
853␉length = length + 1;␊
854␉buffer = malloc(length);␊
855␊
856␉if (buffer == 0)␊
857␉{␊
858␉␉break;␊
859␉}␊
860␊
861␉strlcpy(buffer, (char *)kLoadAddr, length);␊
862␊
863␉// Parse the plist.␊
864␊
865␉ret = ParseXML(buffer, &module, &personalities, isKextForcedToLoad(name));␊
866␊
867␉if (ret != 0) {␊
868␉␉break;␊
869␉}␊
870␊
871␉if (!module) // cparm␊
872␉{␊
873␉␉ret = -1;␊
874␉␉break;␊
875␉} // Should never happen but it will make the compiler happy␊
876␊
877␉// Allocate memory for the driver path and the plist.␊
878␊
879␉module->executablePath = tmpExecutablePath;␊
880␉module->bundlePath = tmpBundlePath;␊
881␉module->bundlePathLength = bundlePathLength;␊
882␉module->plistAddr = malloc(length);␊
883␊
884␉if ((module->executablePath == 0) || (module->bundlePath == 0) || (module->plistAddr == 0))␊
885␉{␊
886␉␉verbose("%s: executablePath or bundlePath or plistAddr are 0\n", name);␊
887␉␉break;␊
888␉}␊
889␊
890␉// Save the driver path in the module.␊
891␉//strcpy(module->driverPath, tmpDriverPath);␊
892␉tmpExecutablePath = 0;␊
893␉tmpBundlePath = 0;␊
894␊
895␉// Add the plist to the module.␊
896␊
897␉strlcpy(module->plistAddr, (char *)kLoadAddr, length);␊
898␉module->plistLength = length;␊
899␊
900␉// Add the module to the end of the module list.␊
901 ␊
902␉if (gModuleHead == 0) {␊
903␉␉gModuleHead = module;␊
904␉} else ␉{␊
905␉␉gModuleTail->nextModule = module;␊
906␉}␊
907␉gModuleTail = module;␊
908␊
909␉// Add the persionalities to the personality list.␊
910␊
911␉if (personalities) {␊
912␉␉personalities = personalities->tag;␊
913␉}␊
914␉while (personalities != 0)␊
915␉{␊
916␉␉if (gPersonalityHead == 0) {␊
917␉␉␉gPersonalityHead = personalities->tag;␊
918␉␉} else {␊
919␉␉␉gPersonalityTail->tagNext = personalities->tag;␊
920␉␉}␊
921␊
922␉␉gPersonalityTail = personalities->tag;␊
923␉␉personalities = personalities->tagNext;␊
924␉}␊
925 ␊
926␉ret = 0;␊
927␉}␊
928␉while (0);␊
929 ␊
930␉if ( buffer ) {␊
931␉␉free( buffer );␊
932␉}␊
933␉if ( tmpExecutablePath ) {␊
934␉␉free( tmpExecutablePath );␊
935␉}␊
936␉if ( tmpBundlePath ) {␊
937␉␉free( tmpBundlePath );␊
938␉}␊
939␉return ret;␊
940}␊
941␊
942//==========================================================================␊
943// LoadMatchedModules␊
944long LoadMatchedModules( void )␊
945{␊
946␉TagPtr␉prop;␊
947␉ModulePtr␉module;␊
948␉char␉␉*fileName, segName[32];␊
949␉DriverInfoPtr␉driver;␊
950␉long␉␉length, driverAddr, driverLength;␊
951␉void␉␉*executableAddr = 0;␊
952␉void␉␉*embedded = 0;␊
953␊
954␉module = gModuleHead;␊
955␊
956␉TagPtr KextsPatches = XMLGetProperty(bootInfo->kextConfig.dictionary, (const char*)"KextsPatches");␊
957␊
958␉while (module != 0)␊
959␉{␊
960␉␉if (module->willLoad)␊
961␉␉{␊
962␉␉␉prop = XMLGetProperty(module->dict, kPropCFBundleExecutable);␊
963␊
964␉␉␉if (prop != 0)␊
965␉␉␉{␊
966␉␉␉␉fileName = prop->string;␊
967␉␉␉␉snprintf(gFileSpec, 4096, "%s%s", module->executablePath, fileName);␊
968␊
969#if FAKESMC_SUPPORT␊
970␉␉␉␉if (!strcmp(fileName, "EmbeddedFakeSMC"))␊
971␉␉␉␉{␊
972␉␉␉␉␉verbose("\t Loading embedded FakeSMC: ");␊
973␉␉␉␉␉embedded = malloc(FakeSMC_un_len);␊
974␉␉␉␉␉size_t size = lzvn_decode(embedded, FakeSMC_un_len, FakeSMC, FakeSMC_lzvn_len );␊
975␊
976␉␉␉␉␉if (FakeSMC_un_len != size)␊
977␉␉␉␉␉{␊
978␉␉␉␉␉␉verbose("\n\t ERROR! FakeSMC size mismatch from lzvn (found: %zx, expected: %zx), failed!\n", size, FakeSMC_un_len);␊
979␉␉␉␉␉␉length = -1;␊
980␉␉␉␉␉}␊
981␉␉␉␉␉else␊
982␉␉␉␉␉{␊
983␉␉␉␉␉␉length = size;␊
984␉␉␉␉␉␉// no need to Thin this kext␊
985␉␉␉␉␉␉//memcpy((void *)kLoadAddr, embedded, length);␊
986␉␉␉␉␉␉//ThinFatFile(embedded, &length);␊
987␉␉␉␉␉␉executableAddr = (void *)embedded;␊
988␉␉␉␉␉␉verbose("%s!\n", ((length != -1) && executableAddr) ? "success" : "failed");␊
989␉␉␉␉␉}␊
990␉␉␉␉}␊
991␉␉␉␉else␊
992␉␉␉␉{␊
993#endif␊
994␉␉␉␉␉length = LoadThinFatFile(gFileSpec, &executableAddr);␊
995␉␉␉␉␉if (length == 0)␊
996␉␉␉␉␉{␊
997␉␉␉␉␉␉length = LoadFile(gFileSpec);␊
998␉␉␉␉␉␉executableAddr = (void *)kLoadAddr;␊
999␉␉␉␉␉}␊
1000#if FAKESMC_SUPPORT␊
1001␉␉}␊
1002#endif␊
1003//␉␉printf("%s length = %d addr = 0x%x\n", gFileSpec, length, driverModuleAddr); getchar();␊
1004␉␉␉}␊
1005␉␉␉else␊
1006␉␉␉{␊
1007␉␉␉␉length = 0;␊
1008␉␉␉}␊
1009␊
1010␉␉␉if ((length != -1) && executableAddr)␊
1011␉␉␉{␊
1012␉␉␉␉// patching kexts executable␊
1013␉␉␉␉if (!skipKextsPatcher)␊
1014␉␉␉␉{␊
1015␉␉␉␉␉// chameleon patches␊
1016␉␉␉␉␉patchBooterDefinedKext(fileName, executableAddr, (UInt32)length, 0);␊
1017␉␉␉␉␉// user's patches␊
1018␉␉␉␉␉if (KextsPatches && XMLIsDict(KextsPatches))␊
1019␉␉␉␉␉{␊
1020␉␉␉␉␉␉pach_binaryUsingDictionary(executableAddr, (UInt32)length, 0, fileName, KextsPatches);␊
1021␉␉␉␉␉}␊
1022␉␉␉␉}␊
1023␊
1024␉␉␉␉// Make make in the image area.␊
1025␊
1026␉␉␉␉execute_hook("LoadMatchedModules", module, &length, executableAddr, NULL);␊
1027␊
1028␉␉␉␉driverLength = sizeof(DriverInfo) + module->plistLength + length + module->bundlePathLength;␊
1029␉␉␉␉driverAddr = AllocateKernelMemory(driverLength);␊
1030␊
1031␉␉␉␉// Set up the DriverInfo.␊
1032␉␉␉␉driver = (DriverInfoPtr)driverAddr;␊
1033␉␉␉␉driver->plistAddr = (char *)(driverAddr + sizeof(DriverInfo));␊
1034␉␉␉␉driver->plistLength = module->plistLength;␊
1035␊
1036␉␉␉␉if (length != 0)␊
1037␉␉␉␉{␊
1038␉␉␉␉␉driver->executableAddr = (void *)(driverAddr + sizeof(DriverInfo) +␊
1039␉␉␉␉␉␉␉␉␉␉ module->plistLength);␊
1040␉␉␉␉␉driver->executableLength = length;␊
1041␉␉␉␉}␊
1042␉␉␉␉else␊
1043␉␉␉␉{␊
1044␉␉␉␉␉driver->executableAddr␉ = 0;␊
1045␉␉␉␉␉driver->executableLength = 0;␊
1046␉␉␉␉}␊
1047␊
1048␉␉␉␉driver->bundlePathAddr = (void *)(driverAddr + sizeof(DriverInfo) +␊
1049␉␉␉␉␉␉␉␉␉ module->plistLength + driver->executableLength);␊
1050␉␉␉␉driver->bundlePathLength = module->bundlePathLength;␊
1051␊
1052␉␉␉␉// Save the plist, module and bundle.␊
1053␉␉␉␉strlcpy(driver->plistAddr, module->plistAddr, driver->plistLength);␊
1054␊
1055␉␉␉␉if (length != 0)␊
1056␉␉␉␉{␊
1057␉␉␉␉␉memcpy(driver->executableAddr, executableAddr, length);␊
1058␉␉␉␉}␊
1059␊
1060␉␉␉␉strlcpy(driver->bundlePathAddr, module->bundlePath, module->bundlePathLength);␊
1061␊
1062␉␉␉␉// Add an entry to the memory map.␊
1063␉␉␉␉snprintf(segName, sizeof(segName), "Driver-%lx", (unsigned long)driver);␊
1064␉␉␉␉AllocateMemoryRange(segName, driverAddr, driverLength,␊
1065␉␉␉␉␉␉␉␉␉kBootDriverTypeKEXT);␊
1066␉␉␉}␊
1067␉␉}␊
1068␉␉module = module->nextModule;␊
1069␉}␊
1070␊
1071␉if(embedded)␊
1072␉{␊
1073␉␉free(embedded);␊
1074␉}␊
1075␉return 0;␊
1076}␊
1077␊
1078//==========================================================================␊
1079// MatchPersonalities␊
1080static long MatchPersonalities( void )␊
1081{␊
1082␉/* IONameMatch support not implemented */␊
1083␉return 0;␊
1084}␊
1085␊
1086//==========================================================================␊
1087// MatchLibraries␊
1088static long MatchLibraries( void )␊
1089{␊
1090␉TagPtr prop;␊
1091␉TagPtr prop2;␊
1092␉ModulePtr module;␊
1093␉ModulePtr module2;␊
1094␉long done;␊
1095␊
1096␉do {␊
1097␉␉done = 1;␊
1098␉␉module = gModuleHead;␊
1099 ␊
1100␉␉while (module != 0)␊
1101␉␉{␊
1102␉␉␉if (module->willLoad == 1)␊
1103␉␉␉{␊
1104␉␉␉␉prop = XMLGetProperty(module->dict, kPropOSBundleLibraries);␊
1105␊
1106␉␉␉␉if (prop != 0)␊
1107␉␉␉␉{␊
1108␉␉␉␉␉prop = prop->tag;␊
1109␊
1110␉␉␉␉␉while (prop != 0)␊
1111␉␉␉␉␉{␊
1112␉␉␉␉␉␉module2 = gModuleHead;␊
1113␊
1114␉␉␉␉␉␉while (module2 != 0)␊
1115␉␉␉␉␉␉{␊
1116␉␉␉␉␉␉␉prop2 = XMLGetProperty(module2->dict, kPropCFBundleIdentifier);␊
1117␊
1118␉␉␉␉␉␉␉if ((prop2 != 0) && (!strcmp(prop->string, prop2->string)))␊
1119␉␉␉␉␉␉␉{␊
1120␉␉␉␉␉␉␉␉if (module2->willLoad == 0)␊
1121␉␉␉␉␉␉␉␉{␊
1122␉␉␉␉␉␉␉␉␉module2->willLoad = 1;␊
1123␉␉␉␉␉␉␉␉}␊
1124␉␉␉␉␉␉␉␉break;␊
1125␉␉␉␉␉␉␉}␊
1126␉␉␉␉␉␉␉module2 = module2->nextModule;␊
1127␉␉␉␉␉␉}␊
1128␉␉␉␉␉␉prop = prop->tagNext;␊
1129␉␉␉␉␉}␊
1130␉␉␉␉}␊
1131␉␉␉␉module->willLoad = 2;␊
1132␉␉␉␉done = 0;␊
1133␉␉␉}␊
1134␉␉␉module = module->nextModule;␊
1135␉␉}␊
1136␉}␊
1137␉while (!done);␊
1138␊
1139␉return 0;␊
1140}␊
1141␊
1142//==========================================================================␊
1143// FindModule␊
1144␊
1145#if NOTDEF␊
1146static ModulePtr FindModule( char *name )␊
1147{␊
1148␉ModulePtr module;␊
1149␉TagPtr prop;␊
1150␊
1151␉module = gModuleHead;␊
1152␊
1153␉while (module != 0)␊
1154␉{␊
1155␉␉prop = GetProperty(module->dict, kPropCFBundleIdentifier);␊
1156␊
1157␉␉if ((prop != 0) && !strcmp(name, prop->string))␊
1158␉␉{␊
1159␉␉␉break;␊
1160␉␉}␊
1161␊
1162␉␉module = module->nextModule;␊
1163␉}␊
1164 ␊
1165␉return module;␊
1166}␊
1167#endif /* NOTDEF */␊
1168␊
1169//==========================================================================␊
1170// try to force loading kext.␊
1171// this not assure the kext will be loaded by the kernel for sure,␊
1172// but at least is forced loaded by the bootloader␊
1173bool isKextForcedToLoad(char *kext)␊
1174{␊
1175␉TagPtr ForceTag = NULL;␊
1176␊
1177␉if ((ForceTag = XMLCastArray(XMLGetProperty(bootInfo->kextConfig.dictionary, (const char *)"ForceToLoad"))))␊
1178␉{␊
1179␉␉unsigned long count = XMLTagCount(ForceTag);␊
1180␉␉if (count) {␊
1181␉␉␉for (unsigned i = count ; i-- > 0 ;) /* reversed iteration since xml.c add it reversed */␊
1182␉␉␉{␊
1183␉␉␉␉TagPtr index = XMLGetElement( ForceTag, i );␊
1184␉␉␉␉if(XMLIsString(index))␊
1185␉␉␉␉{␊
1186␉␉␉␉␉char *forced = XMLCastString(index);␊
1187␉␉␉␉␉char buffer[strlen(forced) + strlen(".kext") +1];␊
1188␉␉␉␉␉//snprintf(buffer, strlen(forced) + strlen(".kext") +1, "%s%s", forced, ".kext");␊
1189␊
1190␉␉␉␉␉sprintf(buffer, "%s%s", forced, ".kext");␊
1191␊
1192␉␉␉␉␉if (!strcmp(buffer, kext))␊
1193␉␉␉␉␉{␊
1194␉␉␉␉␉␉verbose("- %s forced loaded\n", kext);␊
1195␉␉␉␉␉␉return true;␊
1196␉␉␉␉␉}␊
1197␉␉␉␉}␊
1198␉␉␉}␊
1199␉␉}␊
1200␉}␊
1201␉return false;␊
1202}␊
1203␊
1204//==========================================================================␊
1205// ParseXML␊
1206static long ParseXML( char *buffer, ModulePtr *module, TagPtr *personalities, bool forceKextToLoad )␊
1207{␊
1208␉long␉␉length;␊
1209␉long␉␉pos = 0;␊
1210␉TagPtr␉␉moduleDict;␊
1211␉TagPtr␉␉required;␊
1212␉ModulePtr␉tmpModule;␊
1213␊
1214␉while (1)␊
1215␉{␊
1216␉␉length = XMLParseNextTag(buffer + pos, &moduleDict);␊
1217␉␉if (length == -1)␊
1218␉␉{␊
1219␉␉␉break;␊
1220␉␉}␊
1221␊
1222␉␉pos += length;␊
1223␊
1224␉␉if (moduleDict == 0)␊
1225␉␉{␊
1226␉␉␉continue;␊
1227␉␉}␊
1228␉␉if (moduleDict->type == kTagTypeDict)␊
1229␉␉{␊
1230␉␉␉break;␊
1231␉␉}␊
1232␉␉XMLFreeTag(moduleDict);␊
1233␉}␊
1234␊
1235␉if (length == -1)␊
1236␉{␊
1237␉␉return -1;␊
1238␉}␊
1239␊
1240␉required = XMLGetProperty(moduleDict, kPropOSBundleRequired);␊
1241␊
1242␉// if forceKextToLoad is true, the kext will be force to load even if OSBundleRequired has value set to "Safe Boot" instead of "Root"␊
1243␉if (!forceKextToLoad)␊
1244␉{␊
1245␉␉if ( (required == 0) || (required->type != kTagTypeString) || !strncmp(required->string, "Safe Boot", sizeof("Safe Boot")))␊
1246␉␉{␊
1247␉␉␉XMLFreeTag(moduleDict);␊
1248␉␉␉return -2;␊
1249␉␉}␊
1250␉}␊
1251␊
1252␉tmpModule = malloc(sizeof(Module));␊
1253␉if (tmpModule == 0)␊
1254␉{␊
1255␉␉XMLFreeTag(moduleDict);␊
1256␉␉return -1;␊
1257␉}␊
1258␉tmpModule->dict = moduleDict;␊
1259 ␊
1260␉// For now, load any module that has OSBundleRequired != "Safe Boot".␊
1261␊
1262␉tmpModule->willLoad = 1;␊
1263␊
1264␉*module = tmpModule;␊
1265 ␊
1266␉// Get the personalities.␊
1267␊
1268␉*personalities = XMLGetProperty(moduleDict, kPropIOKitPersonalities);␊
1269 ␊
1270␉return 0;␊
1271}␊
1272␊
1273#if NOTDEF␊
1274static char gPlatformName[64];␊
1275#endif␊
1276␊
1277long DecodeKernel(void *binary, entry_t *rentry, char **raddr, int *rsize)␊
1278{␊
1279␉long ret = 0;␊
1280␉compressed_kernel_header *kernel_header = (compressed_kernel_header *)binary;␊
1281␉u_int32_t uncompressed_size = 0, size = 0, adler32 = 0;␊
1282␉void *buffer = NULL;␊
1283␉unsigned long len = 0;␊
1284␊
1285/*#if 0␊
1286␉printf("kernel header:\n");␊
1287␉printf("signature: 0x%x\n", kernel_header->signature);␊
1288␉printf("compress_type: 0x%x\n", kernel_header->compress_type);␊
1289␉printf("adler32: 0x%x\n", kernel_header->adler32);␊
1290␉printf("uncompressed_size: 0x%x\n", kernel_header->uncompressed_size);␊
1291␉printf("compressed_size: 0x%x\n", kernel_header->compressed_size);␊
1292␉getchar();␊
1293#endif*/␊
1294␊
1295␉if (kernel_header->signature == OSSwapBigToHostConstInt32('comp'))␊
1296␉{␊
1297␉␉DBG("Decompressing Kernel Cache:\n");␊
1298␊
1299␉␉if ((kernel_header->compress_type != OSSwapBigToHostConstInt32('lzss')) &&␊
1300␉␉␉(kernel_header->compress_type != OSSwapBigToHostConstInt32('lzvn')))␊
1301␉␉{␊
1302␉␉␉error("\tERROR: kernel compression is bad!\n");␊
1303␉␉␉return -1;␊
1304␉␉}␊
1305␊
1306␉␉if (kernel_header->compress_type == OSSwapBigToHostConstInt32('lzss'))␊
1307␉␉{␊
1308␉␉␉verbose ("\t- Decompressing Kernel Using lzss\n");␊
1309␉␉}␊
1310␊
1311␉␉if (kernel_header->compress_type == OSSwapBigToHostConstInt32('lzvn'))␊
1312␉␉{␊
1313␉␉␉verbose ("\t- Decompressing Kernel Using lzvn\n");␊
1314␉␉}␊
1315␊
1316#if NOTDEF␊
1317␉␉if (kernel_header->platform_name[0] && strcmp(gPlatformName, kernel_header->platform_name))␊
1318␉␉{␊
1319␉␉␉return -1;␊
1320␉␉}␊
1321␊
1322␉␉if (kernel_header->root_path[0] && strcmp(gBootFile, kernel_header->root_path))␊
1323␉␉{␊
1324␉␉␉return -1;␊
1325␉␉}␊
1326#endif␊
1327␉␉uncompressed_size = OSSwapBigToHostInt32(kernel_header->uncompressed_size);␊
1328␉␉binary = buffer = malloc(uncompressed_size);␊
1329␊
1330␉␉// MinusZwei␊
1331␉␉size = 0;␊
1332␉␉switch (kernel_header->compress_type)␊
1333␉␉{␊
1334␉␉␉case OSSwapBigToHostConstInt32('lzvn'):␊
1335␉␉␉␉size = lzvn_decode(binary, uncompressed_size, &kernel_header->data[0], OSSwapBigToHostInt32(kernel_header->compressed_size));␊
1336␉␉␉␉break;␊
1337␊
1338␉␉␉case OSSwapBigToHostConstInt32('lzss'):␊
1339␉␉␉␉size = decompress_lzss((u_int8_t *)binary, uncompressed_size, &kernel_header->data[0], OSSwapBigToHostInt32(kernel_header->compressed_size));␊
1340␉␉␉␉break;␊
1341␊
1342␉␉␉default:␊
1343␉␉␉␉break;␊
1344␉␉}␊
1345␉␉// MinusZwei␊
1346␊
1347␉␉if (uncompressed_size != size)␊
1348␉␉{␊
1349␉␉␉if ( kernel_header->compress_type == OSSwapBigToHostConstInt32('lzvn'))␊
1350␉␉␉{␊
1351␉␉␉␉error("ERROR! Size mismatch from lzvn (found: %x, expected: %x).\n", size, uncompressed_size);␊
1352␉␉␉}␊
1353␊
1354␉␉␉if ( kernel_header->compress_type == OSSwapBigToHostConstInt32('lzss'))␊
1355␉␉␉{␊
1356␉␉␉␉error("ERROR! size mismatch from lzss (found: %x, expected: %x).\n", size, uncompressed_size);␊
1357␉␉␉}␊
1358␊
1359␉␉␉return -1;␊
1360␉␉}␊
1361␊
1362␉␉adler32 = Adler32(binary, uncompressed_size);␊
1363␉␉if (OSSwapBigToHostInt32(kernel_header->adler32) != adler32)␊
1364␉␉{␊
1365␉␉␉error("ERROR! Adler mismatch (found: %X, expected: %X).\n", adler32, OSSwapBigToHostInt32(kernel_header->adler32));␊
1366␉␉␉return -1;␊
1367␉␉}␊
1368␊
1369␉␉DBG("\n");␊
1370␉}␊
1371␉␊
1372␉ret = ThinFatFile(&binary, &len);␊
1373␉if (ret == 0 && len == 0 && archCpuType==CPU_TYPE_X86_64)␊
1374␉{␊
1375␉␉archCpuType=CPU_TYPE_I386;␊
1376␉␉ret = ThinFatFile(&binary, &len);␊
1377␉}␊
1378␊
1379␉// Bungo: scan binary for Darwin Kernel Version string␊
1380␉useDarwinVersion = true;␊
1381␉uint32_t offset = 0;␊
1382␉strncpy(gDarwinBuildVerStr, "Darwin Kernel Version", sizeof(gDarwinBuildVerStr));␊
1383␊
1384␉while ((offset < 0xFFFFFFFF - (uint32_t)binary - 256) && memcmp(binary + offset, gDarwinBuildVerStr, 21))␊
1385␉{␊
1386␉␉offset++;␊
1387␉}␊
1388␉if (offset < 0xFFFFFFFF - (uint32_t)binary - 256)␊
1389␉{␊
1390␉␉strncpy(gDarwinBuildVerStr, (char *)(binary + offset), sizeof(gDarwinBuildVerStr));␊
1391␉}␊
1392␉else␊
1393␉{␊
1394␉␉strcat(gDarwinBuildVerStr, ": Unknown");␊
1395␉␉useDarwinVersion = false;␊
1396␉}␊
1397␉// Micky1979 use Bungo gDarwinBuildVerStr and split into gDarwinMajor, gDarwinMinor and gDarwinRev␊
1398␉if (useDarwinVersion)␊
1399␉{␊
1400␉␉useDarwinVersion = false;␊
1401␉␉const char *pattern = strstr(gDarwinBuildVerStr, "Darwin Kernel Version ")+22;␊
1402␉␉const char *until = strstr(pattern, ":");␊
1403␉␉size_t vlen = until - pattern;␊
1404␉␉char *ver = (char *)malloc(sizeof(char)*(len+1));␊
1405␉␉strncpy(ver, pattern, vlen);␊
1406␉␉ver[vlen] = '\0';␊
1407␉␉char *delim;␊
1408␉␉char *temp;␊
1409␉␉gDarwinMajor = -1; gDarwinMinor = -1; gDarwinRev = -1;␊
1410␉␉if (ver != NULL)␊
1411␉␉{␊
1412␉␉␉temp = ver;␊
1413␉␉␉int count = 1;␊
1414␉␉␉while ((delim = strsep_c(&ver, ".")) != NULL)␊
1415␉␉␉{␊
1416␉␉␉␉switch (count)␊
1417␉␉␉␉{␊
1418␉␉␉␉␉case 1: gDarwinMajor = atoi(delim); break;␊
1419␉␉␉␉␉case 2: gDarwinMinor = atoi(delim); break;␊
1420␉␉␉␉␉case 3: gDarwinRev = atoi(delim); break;␊
1421␉␉␉␉␉default: break;␊
1422␉␉␉␉}␊
1423␉␉␉␉count ++;␊
1424␉␉␉}␊
1425␉␉␉free(temp);␊
1426␉␉}␊
1427␊
1428␉␉if (gDarwinMajor >= 0 && gDarwinMinor >= 0 && gDarwinRev >= 0)␊
1429␉␉{␊
1430␉␉␉useDarwinVersion = true;␊
1431␉␉}␊
1432␊
1433␉␉switch (gDarwinMajor)␊
1434␉␉{␊
1435␉␉␉case 10:␊
1436␉␉␉␉switch (gDarwinMinor)␊
1437␉␉␉␉{␊
1438␉␉␉␉␉case 0: kernelOSVer = 0xA060000; break;␊
1439␉␉␉␉␉case 1: kernelOSVer = 0xA060100; break;␊
1440␉␉␉␉␉case 2: kernelOSVer = 0xA060200; break;␊
1441␉␉␉␉␉case 3: kernelOSVer = 0xA060300; break;␊
1442␉␉␉␉␉case 4: kernelOSVer = 0xA060400; break;␊
1443␉␉␉␉␉case 5: kernelOSVer = 0xA060500; break;␊
1444␉␉␉␉␉case 6: kernelOSVer = 0xA060600; break;␊
1445␉␉␉␉␉case 7: kernelOSVer = 0xA060700; break;␊
1446␉␉␉␉␉case 8: kernelOSVer = 0xA060800; break;␊
1447␉␉␉␉␉default:kernelOSVer = 0xA060800; break; //Last known kernel␊
1448␉␉␉␉}␊
1449␉␉␉␉break;␊
1450␉␉␉case 11:␊
1451␉␉␉␉switch (gDarwinMinor)␊
1452␉␉␉␉{␊
1453␉␉␉␉␉case 0: kernelOSVer = 0xA070000; break;␊
1454␉␉␉␉␉case 1: kernelOSVer = 0xA070100; break;␊
1455␉␉␉␉␉case 2: kernelOSVer = 0xA070200; break;␊
1456␉␉␉␉␉case 3: kernelOSVer = 0xA070300; break;␊
1457␉␉␉␉␉case 4:␊
1458␉␉␉␉␉␉switch (gDarwinRev)␊
1459␉␉␉␉␉␉{␊
1460␉␉␉␉␉␉␉case 0: kernelOSVer = 0xA070400; break;␊
1461␉␉␉␉␉␉␉case 1: kernelOSVer = 0xA070400; break;␊
1462␉␉␉␉␉␉␉case 2: kernelOSVer = 0xA070500; break;␊
1463␉␉␉␉␉␉␉default:kernelOSVer = 0xA070500; break; //Last known kernel␊
1464␉␉␉␉␉␉}␊
1465␉␉␉␉␉default:kernelOSVer = 0xA070500; break; //Last known kernel␊
1466␉␉␉␉}␊
1467␉␉␉␉break;␊
1468␉␉␉case 12:␊
1469␉␉␉␉switch (gDarwinMinor)␊
1470␉␉␉␉{␊
1471␉␉␉␉␉case 0: kernelOSVer = 0xA080000; break;␊
1472␉␉␉␉␉case 1: kernelOSVer = 0xA080100; break;␊
1473␉␉␉␉␉case 2: kernelOSVer = 0xA080200; break;␊
1474␉␉␉␉␉case 3: kernelOSVer = 0xA080300; break;␊
1475␉␉␉␉␉case 4: kernelOSVer = 0xA080400; break;␊
1476␉␉␉␉␉case 5: kernelOSVer = 0xA080500; break; // 10.8.5␊
1477␉␉␉␉␉case 6: kernelOSVer = 0xA080500; break; // 10.8.5 update␊
1478␉␉␉␉␉default:kernelOSVer = 0xA080500; break; //Last known kernel␊
1479␉␉␉␉}␊
1480␉␉␉␉break;␊
1481␉␉␉case 13:␊
1482␉␉␉␉switch (gDarwinMinor)␊
1483␉␉␉␉{␊
1484␉␉␉␉␉case 0: kernelOSVer = 0xA090000;␊
1485␉␉␉␉␉switch (gDarwinRev)␊
1486␉␉␉␉␉{␊
1487␉␉␉␉␉␉case 0: kernelOSVer = 0xA090000; break;␊
1488␉␉␉␉␉␉case 1: kernelOSVer = 0xA090000; break; // never exist (or released)␊
1489␉␉␉␉␉␉case 2: kernelOSVer = 0xA090100; break;␊
1490␉␉␉␉␉␉default:kernelOSVer = 0xA090100; break; //Last known kernel␊
1491␉␉␉␉␉}␊
1492␉␉␉␉␉␉break;␊
1493␉␉␉␉␉case 1: kernelOSVer = 0xA090100; break; // never exist (or released)␊
1494␉␉␉␉␉case 2: kernelOSVer = 0xA090200; break;␊
1495␉␉␉␉␉case 3: kernelOSVer = 0xA090300; break;␊
1496␉␉␉␉␉case 4: kernelOSVer = 0xA090400; break;␊
1497␉␉␉␉␉case 5: kernelOSVer = 0xA090500; break;␊
1498␉␉␉␉␉default:kernelOSVer = 0xA090500; break; //Last known kernel␊
1499␉␉␉␉}␊
1500␉␉␉␉break;␊
1501␉␉␉case 14:␊
1502␉␉␉␉switch (gDarwinMinor)␊
1503␉␉␉␉{␊
1504␉␉␉␉␉case 0: kernelOSVer = 0xA0A0000; break; // same kernel of 10.10.1␊
1505␉␉␉␉␉case 1: kernelOSVer = 0xA0A0100; break; // same kernel of 10.10␊
1506␉␉␉␉␉case 2: kernelOSVer = 0xA0A0200; break;␊
1507␉␉␉␉␉case 3: kernelOSVer = 0xA0A0300; break;␊
1508␉␉␉␉␉case 4: kernelOSVer = 0xA0A0400; break;␊
1509␉␉␉␉␉case 5: kernelOSVer = 0xA0A0500; break;␊
1510␉␉␉␉␉default:kernelOSVer = 0xA0A0500; break; //Last known kernel␊
1511␉␉␉␉}␊
1512␉␉␉␉break;␊
1513␉␉␉case 15: /* El Capitan */␊
1514␉␉␉␉switch (gDarwinMinor)␊
1515␉␉␉␉{␊
1516␉␉␉␉␉case 0: kernelOSVer = 0xA0B0000; break;␊
1517␉␉␉␉␉case 1: kernelOSVer = 0xA0B0100; break;␊
1518␉␉␉␉␉case 2: kernelOSVer = 0xA0B0200; break;␊
1519␉␉␉␉␉case 3: kernelOSVer = 0xA0B0300; break;␊
1520␉␉␉␉␉case 4: kernelOSVer = 0xA0B0400; break;␊
1521␉␉␉␉␉case 5: kernelOSVer = 0xA0B0500; break;␊
1522␉␉␉␉␉case 6: kernelOSVer = 0xA0B0600; break;␊
1523␉␉␉␉␉default:kernelOSVer = 0xA0B0600; break; //Last known kernel (add here updates)␊
1524␉␉␉␉}␊
1525␉␉␉␉break;␊
1526␉␉␉case 16: /* Sierra */␊
1527␉␉␉␉switch (gDarwinMinor)␊
1528␉␉␉␉{␊
1529␉␉␉␉␉case 0: kernelOSVer = 0xA0C0000; break;␊
1530␉␉␉␉␉case 1: kernelOSVer = 0xA0C0100; break;␊
1531␉␉␉␉␉case 2: kernelOSVer = 0xA0C0200; break;␊
1532␉␉␉␉␉case 3: kernelOSVer = 0xA0C0200; break;␊
1533␉␉␉␉␉case 4: kernelOSVer = 0xA0C0300; break;␊
1534␉␉␉␉␉case 5: kernelOSVer = 0xA0C0400; break;␊
1535␉␉␉␉␉case 6: kernelOSVer = 0xA0C0500; break;␊
1536␉␉␉␉␉case 7: kernelOSVer = 0xA0C0600; break;␊
1537//␉␉␉␉␉case 8: kernelOSVer = 0xA0C0700; break;␊
1538␉␉␉␉␉default:kernelOSVer = 0xA0C0600; break; //Last known kernel (add here updates)␊
1539␉␉␉␉}␊
1540␉␉␉␉break;␊
1541//␉␉␉case 17: /* High Sierra */␊
1542//␉␉␉␉switch (gDarwinMinor)␊
1543//␉␉␉␉{␊
1544//␉␉␉␉␉case 0: kernelOSVer = 0xA0C0000; break;␊
1545//␉␉␉␉␉case 1: kernelOSVer = 0xA0C0100; break;␊
1546//␉␉␉␉␉case 2: kernelOSVer = 0xA0C0200; break;␊
1547//␉␉␉␉␉case 3: kernelOSVer = 0xA0C0200; break;␊
1548//␉␉␉␉␉case 4: kernelOSVer = 0xA0C0300; break;␊
1549//␉␉␉␉␉case 5: kernelOSVer = 0xA0C0400; break;␊
1550//␉␉␉␉␉case 6: kernelOSVer = 0xA0C0500; break;␊
1551//␉␉␉␉␉case 7: kernelOSVer = 0xA0C0600; break;␊
1552//␉␉␉␉␉case 8: kernelOSVer = 0xA0C0700; break;␊
1553//␉␉␉␉␉default:kernelOSVer = 0xA0C0600; break; //Last known kernel (add here updates)␊
1554//␉␉␉␉}␊
1555//␉␉␉␉break;␊
1556␉␉␉default:␊
1557␉␉␉␉kernelOSVer = 0xA0C0600;␊
1558␉␉␉␉break; //Last known kernel is Sierra 10.12.6␊
1559␉␉␉}␊
1560␉␉}␊
1561␉␉else␊
1562␉␉{␊
1563␉␉␉switch (MacOSVerCurrent)␊
1564␉␉␉{␊
1565␉␉␉// Snow␊
1566␉␉␉case 0xA060000: gDarwinMajor = 10; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.6␊
1567␉␉␉case 0xA060100: gDarwinMajor = 10; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.6.1␊
1568␉␉␉case 0xA060200: gDarwinMajor = 10; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.6.2␊
1569␉␉␉case 0xA060300: gDarwinMajor = 10; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.6.3␊
1570␉␉␉case 0xA060400: gDarwinMajor = 10; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.6.4␊
1571␉␉␉case 0xA060500: gDarwinMajor = 10; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.6.5␊
1572␉␉␉case 0xA060600: gDarwinMajor = 10; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.6.6␊
1573␉␉␉case 0xA060700: gDarwinMajor = 10; gDarwinMinor = 7; gDarwinRev = 0; break; // 10.6.7␊
1574␉␉␉case 0xA060800: gDarwinMajor = 10; gDarwinMinor = 8; gDarwinRev = 0; break; // 10.6.8␊
1575␉␉␉// Lion␊
1576␉␉␉case 0xA070000: gDarwinMajor = 11; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.7␊
1577␉␉␉case 0xA070100: gDarwinMajor = 11; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.7.1␊
1578␉␉␉case 0xA070200: gDarwinMajor = 11; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.7.2␊
1579␉␉␉case 0xA070300: gDarwinMajor = 11; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.7.3␊
1580␉␉␉case 0xA070400: gDarwinMajor = 11; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.7.4␊
1581␉␉␉case 0xA070500: gDarwinMajor = 11; gDarwinMinor = 4; gDarwinRev = 2; break; // 10.7.5␊
1582␉␉␉// ML␊
1583␉␉␉case 0xA080000: gDarwinMajor = 12; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.8␊
1584␉␉␉case 0xA080100: gDarwinMajor = 12; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.8.1␊
1585␉␉␉case 0xA080200: gDarwinMajor = 12; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.8.2␊
1586␉␉␉case 0xA080300: gDarwinMajor = 12; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.8.3␊
1587␉␉␉case 0xA080400: gDarwinMajor = 12; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.8.4␊
1588␉␉␉case 0xA080500: gDarwinMajor = 12; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.8.5␊
1589␉␉␉// Mavericks␊
1590␉␉␉case 0xA090000: gDarwinMajor = 13; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.9␊
1591␉␉␉case 0xA090100: gDarwinMajor = 13; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.9.1␊
1592␉␉␉case 0xA090200: gDarwinMajor = 13; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.9.2␊
1593␉␉␉case 0xA090300: gDarwinMajor = 13; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.9.3␊
1594␉␉␉case 0xA090400: gDarwinMajor = 13; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.9.4␊
1595␉␉␉case 0xA090500: gDarwinMajor = 13; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.9.5␊
1596␉␉␉// Yosemite␊
1597␉␉␉case 0xA0A0000: gDarwinMajor = 14; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.10␊
1598␉␉␉case 0xA0A0100: gDarwinMajor = 14; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.10.1␊
1599␉␉␉case 0xA0A0200: gDarwinMajor = 14; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.10.2␊
1600␉␉␉case 0xA0A0300: gDarwinMajor = 14; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.10.3␊
1601␉␉␉case 0xA0A0400: gDarwinMajor = 14; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.10.4␊
1602␉␉␉case 0xA0A0500: gDarwinMajor = 14; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.10.5␊
1603␉␉␉// El Capitan␊
1604␉␉␉case 0xA0B0000: gDarwinMajor = 15; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.11␊
1605␉␉␉case 0xA0B0100: gDarwinMajor = 15; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.11.1␊
1606␉␉␉case 0xA0B0200: gDarwinMajor = 15; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.11.2␊
1607␉␉␉case 0xA0B0300: gDarwinMajor = 15; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.11.3␊
1608␉␉␉case 0xA0B0400: gDarwinMajor = 15; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.11.4␊
1609␉␉␉case 0xA0B0500: gDarwinMajor = 15; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.11.5␊
1610␉␉␉case 0xA0B0600: gDarwinMajor = 15; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.11.6␊
1611␉␉␉// Sierra␊
1612␉␉␉case 0xA0C0000: gDarwinMajor = 16; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.12␊
1613␉␉␉case 0xA0C0100: gDarwinMajor = 16; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.12.1␊
1614␉␉␉case 0xA0C0200: gDarwinMajor = 16; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.12.2␊
1615␉␉␉case 0xA0C0300: gDarwinMajor = 16; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.12.3␊
1616␉␉␉case 0xA0C0400: gDarwinMajor = 16; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.12.4␊
1617␉␉␉case 0xA0C0500: gDarwinMajor = 16; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.12.5␊
1618␉␉␉case 0xA0C0600: gDarwinMajor = 16; gDarwinMinor = 7; gDarwinRev = 0; break; // 10.12.6␊
1619//␉␉␉case 0xA0C0700: gDarwinMajor = 16; gDarwinMinor = x; gDarwinRev = x; break; // 10.12.7␊
1620␉␉␉// High Sierra␊
1621␊
1622␉␉␉// default = last known kernel␊
1623␉␉␉default: gDarwinMajor = 16; gDarwinMinor = 7; gDarwinRev = 0; break; // 10.12.6;␊
1624␉␉}␊
1625␉}␊
1626␊
1627␉// Notify modules that the kernel has been decompressed, thinned and is about to be decoded␊
1628␉execute_hook("DecodeKernel", (void *)binary, NULL, NULL, NULL);␊
1629␊
1630/* ================================================================ */␊
1631␊
1632␉ret = DecodeMachO(binary, uncompressed_size, rentry, raddr, rsize);␊
1633␉if (ret < 0 && archCpuType == CPU_TYPE_X86_64)␊
1634␉{␊
1635␉␉archCpuType = CPU_TYPE_I386;␊
1636␉␉ret = DecodeMachO(binary, uncompressed_size, rentry, raddr, rsize);␊
1637␉}␊
1638␊
1639␉return ret;␊
1640}␊
1641

Archive Download this file

Revision: 2897