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␊
636␉embedded = malloc(FakeSMCInfo_plist_un_len); // don't free, will be done in LoadEmbeddedKext␊
637␉if (embedded == NULL) {␊
638␉␉return;␊
639␉}␊
640␊
641␊
642␉size_t size = lzvn_decode(embedded,␊
643 FakeSMCInfo_plist_un_len,␊
644 FakeSMCInfo_plist,␊
645 FakeSMCInfo_plist_lzvn_len);␊
646␊
647␉if (FakeSMCInfo_plist_un_len != size)␊
648␉{␊
649␉␉verbose("\n\t ERROR! FakeSMC size mismatch from lzvn (found: %zx, expected: %zx), failed!\n", size, FakeSMCInfo_plist_un_len);␊
650␉␉free(embedded);␊
651␉}␊
652␉else␊
653␉{␊
654␉␉LoadEmbeddedKext((char *)embedded, size, "EmbeddedFakeSMC" );␊
655␉}␊
656}␊
657#endif␊
658␊
659//==========================================================================␊
660// LoadEmbeddedKext␊
661long LoadEmbeddedKext( char *InjectorPlist, size_t length, char *name )␊
662{␊
663␉long␉␉executablePathLength, bundlePathLength;␊
664␉ModulePtr␉module;␊
665␉TagPtr␉␉personalities;␊
666␉char␉␉*tmpExecutablePath = 0;␊
667␉char␉␉*tmpBundlePath = 0;␊
668␉char␉␉*realAddr = NULL;␊
669␉long␉␉ret = -1;␊
670␊
671␉do {␊
672␉␉snprintf(gFileSpec, 4096, "%s/%s.kext/%s", "/System/Library/Extensions", name, "Contents/MacOS/");␊
673␉␉executablePathLength = strlen(gFileSpec) + 1;␊
674␊
675␉␉tmpExecutablePath = malloc(executablePathLength);␊
676␊
677␉␉if (tmpExecutablePath == 0)␊
678␉␉{␊
679␉␉␉break;␊
680␉␉}␊
681␊
682␉␉strlcpy(tmpExecutablePath, gFileSpec, executablePathLength);␊
683␉␉snprintf(gFileSpec, 4096, "%s/%s.kext", "/System/Library/Extensions", name);␊
684␉␉bundlePathLength = strlen(gFileSpec) + 1;␊
685␊
686␉␉tmpBundlePath = malloc(bundlePathLength);␊
687␊
688␉␉if (tmpBundlePath == 0)␊
689␉␉{␊
690␉␉␉break;␊
691␉␉}␊
692␊
693␉␉strlcpy(tmpBundlePath, gFileSpec, bundlePathLength);␊
694␊
695␉␉// Construct the file spec to the plist, then load it.␊
696␉␉snprintf(gFileSpec, 4096, "%s/%s.kext/Contents/Info.plist", "/System/Library/Extensions", name);␊
697␊
698␉␉// bug, after ParseXML something weired happened to InjectorPlist. Making a copy␊
699␉␉realAddr = malloc(length);␊
700␉␉strlcpy(realAddr, InjectorPlist, length);␊
701␉␉ret = ParseXML((char *)InjectorPlist, &module, &personalities, true);␊
702␊
703␉␉if (ret != 0)␊
704␉␉{␊
705␉␉␉break;␊
706␉␉}␊
707␊
708␉␉if (!module) // cparm␊
709␉␉{␊
710␉␉␉ret = -1;␊
711␉␉␉break;␊
712␉␉} // Should never happen but it will make the compiler happy␊
713␊
714␉␉// Allocate memory for the driver path and the plist.␊
715␉␉module->executablePath = tmpExecutablePath;␊
716␉␉module->bundlePath = tmpBundlePath;␊
717␉␉module->bundlePathLength = bundlePathLength;␊
718␊
719␉␉module->plistAddr = malloc(length);␊
720␊
721␉␉if ((module->executablePath == 0) || (module->bundlePath == 0) || (module->plistAddr == 0))␊
722␉␉{␊
723␉␉␉verbose("(executablePath or bundlePath or plistAddr are 0) ");␊
724␉␉␉ret = -1;␊
725␉␉␉break;␊
726␉␉}␊
727␊
728␉␉tmpExecutablePath = 0;␊
729␉␉tmpBundlePath = 0;␊
730␊
731␉␉strlcpy(module->plistAddr, realAddr, length);␊
732␉␉module->plistLength = length;␊
733␉␉// Add the module to the end of the module list.␊
734␊
735␉␉if (gModuleHead == 0)␊
736␉␉{␊
737␉␉␉gModuleHead = module;␊
738␉␉}␊
739␉␉else␊
740␉␉{␊
741␉␉␉gModuleTail->nextModule = module;␊
742␉␉}␊
743␉␉gModuleTail = module;␊
744␊
745␉␉// Add the persionalities to the personality list.␊
746␉␉if (personalities)␊
747␉␉{␊
748␉␉␉personalities = personalities->tag;␊
749␉␉}␊
750␉␉while (personalities != 0)␊
751␉␉{␊
752␉␉␉if (gPersonalityHead == 0)␊
753␉␉␉{␊
754␉␉␉␉gPersonalityHead = personalities->tag;␊
755␉␉␉}␊
756␉␉␉else␊
757␉␉␉{␊
758␉␉␉␉gPersonalityTail->tagNext = personalities->tag;␊
759␉␉␉}␊
760␊
761␉␉␉gPersonalityTail = personalities->tag;␊
762␉␉␉personalities = personalities->tagNext;␊
763␉␉}␊
764␉␉ret = 0;␊
765␊
766␉}while (0);␊
767␊
768␉if (realAddr)␊
769␉{␊
770␉␉free(realAddr);␊
771␉}␊
772␊
773␉if ( strlen(InjectorPlist) )␊
774␉{␊
775␉␉free( InjectorPlist );␊
776␉}␊
777␊
778␉if ( tmpExecutablePath )␊
779␉{␊
780␉␉free( tmpExecutablePath );␊
781␉}␊
782␊
783␉if ( tmpBundlePath )␊
784␉{␊
785␉␉free( tmpBundlePath );␊
786␉}␊
787␉return ret;␊
788}␊
789␊
790//==========================================================================␊
791// LoadDriverPList␊
792long LoadDriverPList( char *dirSpec, char *name, long bundleType )␊
793{␊
794␉long␉␉length, executablePathLength, bundlePathLength;␊
795␉ModulePtr␉module;␊
796␉TagPtr␉␉personalities;␊
797␉char␉␉*buffer = 0;␊
798␉char␉␉*tmpExecutablePath = 0;␊
799␉char␉␉*tmpBundlePath = 0;␊
800␉long␉␉ret = -1;␊
801␊
802␉do {␊
803␉// Save the driver path.␊
804 ␊
805␉if(name)␊
806␉{␊
807␉␉if (!strcmp(name, "FakeSMC.kext")) {␊
808␉␉␉FakeSMCLoaded = true;␊
809␉␉}␊
810␉␉snprintf(gFileSpec, 4096, "%s/%s/%s", dirSpec, name, (bundleType == kCFBundleType2) ? "Contents/MacOS/" : "");␊
811␉}␊
812␉else␊
813␉{␊
814␉␉snprintf(gFileSpec, 4096, "%s/%s", dirSpec, (bundleType == kCFBundleType2) ? "Contents/MacOS/" : "");␊
815␉}␊
816␉executablePathLength = strlen(gFileSpec) + 1;␊
817␊
818␉tmpExecutablePath = malloc(executablePathLength);␊
819␉if (tmpExecutablePath == 0) {␊
820␉␉break;␊
821␉}␊
822␉strlcpy(tmpExecutablePath, gFileSpec, executablePathLength);␊
823␊
824␉if(name)␊
825␉{␊
826␉␉snprintf(gFileSpec, 4096, "%s/%s", dirSpec, name);␊
827␉}␊
828␉else␊
829␉{␊
830␉␉strncpy(gFileSpec, dirSpec, 4096);␊
831␉}␊
832␉bundlePathLength = strlen(gFileSpec) + 1;␊
833␊
834␉tmpBundlePath = malloc(bundlePathLength);␊
835␉if (tmpBundlePath == 0)␊
836␉{␊
837␉␉break;␊
838␉}␊
839␊
840␉strlcpy(tmpBundlePath, gFileSpec, bundlePathLength);␊
841␊
842␉// Construct the file spec to the plist, then load it.␊
843␊
844␉if(name)␊
845␉{␊
846␉␉snprintf(gFileSpec, 4096, "%s/%s/%sInfo.plist", dirSpec, name, (bundleType == kCFBundleType2) ? "Contents/" : "");␊
847␉}␊
848␉else␊
849␉{␊
850␉␉snprintf(gFileSpec, 4096, "%s/%sInfo.plist", dirSpec, (bundleType == kCFBundleType2) ? "Contents/" : "");␊
851␉}␊
852␊
853␉length = LoadFile(gFileSpec);␊
854␊
855␉if (length == -1)␊
856␉{␊
857␉␉break;␊
858␉}␊
859␊
860␉length = length + 1;␊
861␉buffer = malloc(length);␊
862␊
863␉if (buffer == 0)␊
864␉{␊
865␉␉break;␊
866␉}␊
867␊
868␉strlcpy(buffer, (char *)kLoadAddr, length);␊
869␊
870␉// Parse the plist.␊
871␊
872␉ret = ParseXML(buffer, &module, &personalities, isKextForcedToLoad(name));␊
873␊
874␉if (ret != 0) {␊
875␉␉break;␊
876␉}␊
877␊
878␉if (!module) // cparm␊
879␉{␊
880␉␉ret = -1;␊
881␉␉break;␊
882␉} // Should never happen but it will make the compiler happy␊
883␊
884␉// Allocate memory for the driver path and the plist.␊
885␊
886␉module->executablePath = tmpExecutablePath;␊
887␉module->bundlePath = tmpBundlePath;␊
888␉module->bundlePathLength = bundlePathLength;␊
889␉module->plistAddr = malloc(length);␊
890␊
891␉if ((module->executablePath == 0) || (module->bundlePath == 0) || (module->plistAddr == 0))␊
892␉{␊
893␉␉verbose("%s: executablePath or bundlePath or plistAddr are 0\n", name);␊
894␉␉break;␊
895␉}␊
896␊
897␉// Save the driver path in the module.␊
898␉//strcpy(module->driverPath, tmpDriverPath);␊
899␉tmpExecutablePath = 0;␊
900␉tmpBundlePath = 0;␊
901␊
902␉// Add the plist to the module.␊
903␊
904␉strlcpy(module->plistAddr, (char *)kLoadAddr, length);␊
905␉module->plistLength = length;␊
906␊
907␉// Add the module to the end of the module list.␊
908 ␊
909␉if (gModuleHead == 0) {␊
910␉␉gModuleHead = module;␊
911␉} else ␉{␊
912␉␉gModuleTail->nextModule = module;␊
913␉}␊
914␉gModuleTail = module;␊
915␊
916␉// Add the persionalities to the personality list.␊
917␊
918␉if (personalities) {␊
919␉␉personalities = personalities->tag;␊
920␉}␊
921␉while (personalities != 0)␊
922␉{␊
923␉␉if (gPersonalityHead == 0) {␊
924␉␉␉gPersonalityHead = personalities->tag;␊
925␉␉} else {␊
926␉␉␉gPersonalityTail->tagNext = personalities->tag;␊
927␉␉}␊
928␊
929␉␉gPersonalityTail = personalities->tag;␊
930␉␉personalities = personalities->tagNext;␊
931␉}␊
932 ␊
933␉ret = 0;␊
934␉}␊
935␉while (0);␊
936 ␊
937␉if ( buffer ) {␊
938␉␉free( buffer );␊
939␉}␊
940␉if ( tmpExecutablePath ) {␊
941␉␉free( tmpExecutablePath );␊
942␉}␊
943␉if ( tmpBundlePath ) {␊
944␉␉free( tmpBundlePath );␊
945␉}␊
946␉return ret;␊
947}␊
948␊
949//==========================================================================␊
950// LoadMatchedModules␊
951long LoadMatchedModules( void )␊
952{␊
953␉TagPtr␉prop;␊
954␉ModulePtr␉module;␊
955␉char␉␉*fileName, segName[32];␊
956␉DriverInfoPtr␉driver;␊
957␉long␉␉length, driverAddr, driverLength;␊
958␉void␉␉*executableAddr = 0;␊
959␉void␉␉*embedded = 0;␊
960␊
961␉module = gModuleHead;␊
962␊
963␉TagPtr KextsPatches = XMLGetProperty(bootInfo->kextConfig.dictionary, (const char*)"KextsPatches");␊
964␊
965␉while (module != 0)␊
966␉{␊
967␉␉if (module->willLoad)␊
968␉␉{␊
969␉␉␉prop = XMLGetProperty(module->dict, kPropCFBundleExecutable);␊
970␊
971␉␉␉if (prop != 0)␊
972␉␉␉{␊
973␉␉␉␉fileName = prop->string;␊
974␉␉␉␉snprintf(gFileSpec, 4096, "%s%s", module->executablePath, fileName);␊
975␊
976#if FAKESMC_SUPPORT␊
977␉␉␉␉if (!strcmp(fileName, "EmbeddedFakeSMC"))␊
978␉␉␉␉{␊
979␉␉␉␉␉verbose("\t Loading embedded FakeSMC: ");␊
980␉␉␉␉␉embedded = malloc(FakeSMC_un_len);␊
981␉␉␉␉␉size_t size = lzvn_decode(embedded, FakeSMC_un_len, FakeSMC, FakeSMC_lzvn_len );␊
982␊
983␉␉␉␉␉if (FakeSMC_un_len != size)␊
984␉␉␉␉␉{␊
985␉␉␉␉␉␉verbose("\n\t ERROR! FakeSMC size mismatch from lzvn (found: %zx, expected: %zx), failed!\n", size, FakeSMC_un_len);␊
986␉␉␉␉␉␉length = -1;␊
987␉␉␉␉␉}␊
988␉␉␉␉␉else␊
989␉␉␉␉␉{␊
990␉␉␉␉␉␉length = size;␊
991␉␉␉␉␉␉// no need to Thin this kext␊
992␉␉␉␉␉␉//memcpy((void *)kLoadAddr, embedded, length);␊
993␉␉␉␉␉␉//ThinFatFile(embedded, &length);␊
994␉␉␉␉␉␉executableAddr = (void *)embedded;␊
995␉␉␉␉␉␉verbose("%s!\n", ((length != -1) && executableAddr) ? "success" : "failed");␊
996␉␉␉␉␉}␊
997␉␉␉␉}␊
998␉␉␉␉else␊
999␉␉␉␉{␊
1000#endif␊
1001␉␉␉␉␉length = LoadThinFatFile(gFileSpec, &executableAddr);␊
1002␉␉␉␉␉if (length == 0)␊
1003␉␉␉␉␉{␊
1004␉␉␉␉␉␉length = LoadFile(gFileSpec);␊
1005␉␉␉␉␉␉executableAddr = (void *)kLoadAddr;␊
1006␉␉␉␉␉}␊
1007#if FAKESMC_SUPPORT␊
1008␉␉}␊
1009#endif␊
1010//␉␉printf("%s length = %d addr = 0x%x\n", gFileSpec, length, driverModuleAddr); getchar();␊
1011␉␉␉}␊
1012␉␉␉else␊
1013␉␉␉{␊
1014␉␉␉␉length = 0;␊
1015␉␉␉}␊
1016␊
1017␉␉␉if ((length != -1) && executableAddr)␊
1018␉␉␉{␊
1019␉␉␉␉// patching kexts executable␊
1020␉␉␉␉if (!skipKextsPatcher)␊
1021␉␉␉␉{␊
1022␉␉␉␉␉// chameleon patches␊
1023␉␉␉␉␉patchBooterDefinedKext(fileName, executableAddr, (UInt32)length, 0);␊
1024␉␉␉␉␉// user's patches␊
1025␉␉␉␉␉if (KextsPatches && XMLIsDict(KextsPatches))␊
1026␉␉␉␉␉{␊
1027␉␉␉␉␉␉pach_binaryUsingDictionary(executableAddr, (UInt32)length, 0, fileName, KextsPatches);␊
1028␉␉␉␉␉}␊
1029␉␉␉␉}␊
1030␊
1031␉␉␉␉// Make make in the image area.␊
1032␊
1033␉␉␉␉execute_hook("LoadMatchedModules", module, &length, executableAddr, NULL);␊
1034␊
1035␉␉␉␉driverLength = sizeof(DriverInfo) + module->plistLength + length + module->bundlePathLength;␊
1036␉␉␉␉driverAddr = AllocateKernelMemory(driverLength);␊
1037␊
1038␉␉␉␉// Set up the DriverInfo.␊
1039␉␉␉␉driver = (DriverInfoPtr)driverAddr;␊
1040␉␉␉␉driver->plistAddr = (char *)(driverAddr + sizeof(DriverInfo));␊
1041␉␉␉␉driver->plistLength = module->plistLength;␊
1042␊
1043␉␉␉␉if (length != 0)␊
1044␉␉␉␉{␊
1045␉␉␉␉␉driver->executableAddr = (void *)(driverAddr + sizeof(DriverInfo) +␊
1046␉␉␉␉␉␉␉␉␉␉ module->plistLength);␊
1047␉␉␉␉␉driver->executableLength = length;␊
1048␉␉␉␉}␊
1049␉␉␉␉else␊
1050␉␉␉␉{␊
1051␉␉␉␉␉driver->executableAddr␉ = 0;␊
1052␉␉␉␉␉driver->executableLength = 0;␊
1053␉␉␉␉}␊
1054␊
1055␉␉␉␉driver->bundlePathAddr = (void *)(driverAddr + sizeof(DriverInfo) +␊
1056␉␉␉␉␉␉␉␉␉ module->plistLength + driver->executableLength);␊
1057␉␉␉␉driver->bundlePathLength = module->bundlePathLength;␊
1058␊
1059␉␉␉␉// Save the plist, module and bundle.␊
1060␉␉␉␉strlcpy(driver->plistAddr, module->plistAddr, driver->plistLength);␊
1061␊
1062␉␉␉␉if (length != 0)␊
1063␉␉␉␉{␊
1064␉␉␉␉␉memcpy(driver->executableAddr, executableAddr, length);␊
1065␉␉␉␉}␊
1066␊
1067␉␉␉␉strlcpy(driver->bundlePathAddr, module->bundlePath, module->bundlePathLength);␊
1068␊
1069␉␉␉␉// Add an entry to the memory map.␊
1070␉␉␉␉snprintf(segName, sizeof(segName), "Driver-%lx", (unsigned long)driver);␊
1071␉␉␉␉AllocateMemoryRange(segName, driverAddr, driverLength,␊
1072␉␉␉␉␉␉␉␉␉kBootDriverTypeKEXT);␊
1073␉␉␉}␊
1074␉␉}␊
1075␉␉module = module->nextModule;␊
1076␉}␊
1077␊
1078␉if(embedded)␊
1079␉{␊
1080␉␉free(embedded);␊
1081␉}␊
1082␉return 0;␊
1083}␊
1084␊
1085//==========================================================================␊
1086// MatchPersonalities␊
1087static long MatchPersonalities( void )␊
1088{␊
1089␉/* IONameMatch support not implemented */␊
1090␉return 0;␊
1091}␊
1092␊
1093//==========================================================================␊
1094// MatchLibraries␊
1095static long MatchLibraries( void )␊
1096{␊
1097␉TagPtr prop;␊
1098␉TagPtr prop2;␊
1099␉ModulePtr module;␊
1100␉ModulePtr module2;␊
1101␉long done;␊
1102␊
1103␉do {␊
1104␉␉done = 1;␊
1105␉␉module = gModuleHead;␊
1106 ␊
1107␉␉while (module != 0)␊
1108␉␉{␊
1109␉␉␉if (module->willLoad == 1)␊
1110␉␉␉{␊
1111␉␉␉␉prop = XMLGetProperty(module->dict, kPropOSBundleLibraries);␊
1112␊
1113␉␉␉␉if (prop != 0)␊
1114␉␉␉␉{␊
1115␉␉␉␉␉prop = prop->tag;␊
1116␊
1117␉␉␉␉␉while (prop != 0)␊
1118␉␉␉␉␉{␊
1119␉␉␉␉␉␉module2 = gModuleHead;␊
1120␊
1121␉␉␉␉␉␉while (module2 != 0)␊
1122␉␉␉␉␉␉{␊
1123␉␉␉␉␉␉␉prop2 = XMLGetProperty(module2->dict, kPropCFBundleIdentifier);␊
1124␊
1125␉␉␉␉␉␉␉if ((prop2 != 0) && (!strcmp(prop->string, prop2->string)))␊
1126␉␉␉␉␉␉␉{␊
1127␉␉␉␉␉␉␉␉if (module2->willLoad == 0)␊
1128␉␉␉␉␉␉␉␉{␊
1129␉␉␉␉␉␉␉␉␉module2->willLoad = 1;␊
1130␉␉␉␉␉␉␉␉}␊
1131␉␉␉␉␉␉␉␉break;␊
1132␉␉␉␉␉␉␉}␊
1133␉␉␉␉␉␉␉module2 = module2->nextModule;␊
1134␉␉␉␉␉␉}␊
1135␉␉␉␉␉␉prop = prop->tagNext;␊
1136␉␉␉␉␉}␊
1137␉␉␉␉}␊
1138␉␉␉␉module->willLoad = 2;␊
1139␉␉␉␉done = 0;␊
1140␉␉␉}␊
1141␉␉␉module = module->nextModule;␊
1142␉␉}␊
1143␉}␊
1144␉while (!done);␊
1145␊
1146␉return 0;␊
1147}␊
1148␊
1149//==========================================================================␊
1150// FindModule␊
1151␊
1152#if NOTDEF␊
1153static ModulePtr FindModule( char *name )␊
1154{␊
1155␉ModulePtr module;␊
1156␉TagPtr prop;␊
1157␊
1158␉module = gModuleHead;␊
1159␊
1160␉while (module != 0)␊
1161␉{␊
1162␉␉prop = GetProperty(module->dict, kPropCFBundleIdentifier);␊
1163␊
1164␉␉if ((prop != 0) && !strcmp(name, prop->string))␊
1165␉␉{␊
1166␉␉␉break;␊
1167␉␉}␊
1168␊
1169␉␉module = module->nextModule;␊
1170␉}␊
1171 ␊
1172␉return module;␊
1173}␊
1174#endif /* NOTDEF */␊
1175␊
1176//==========================================================================␊
1177// try to force loading kext.␊
1178// this not assure the kext will be loaded by the kernel for sure,␊
1179// but at least is forced loaded by the bootloader␊
1180bool isKextForcedToLoad(char *kext)␊
1181{␊
1182␉TagPtr ForceTag = NULL;␊
1183␊
1184␉if ((ForceTag = XMLCastArray(XMLGetProperty(bootInfo->kextConfig.dictionary, (const char *)"ForceToLoad"))))␊
1185␉{␊
1186␉␉unsigned long count = XMLTagCount(ForceTag);␊
1187␉␉if (count) {␊
1188␉␉␉for (unsigned i = count ; i-- > 0 ;) /* reversed iteration since xml.c add it reversed */␊
1189␉␉␉{␊
1190␉␉␉␉TagPtr index = XMLGetElement( ForceTag, i );␊
1191␉␉␉␉if(XMLIsString(index))␊
1192␉␉␉␉{␊
1193␉␉␉␉␉char *forced = XMLCastString(index);␊
1194␉␉␉␉␉char buffer[strlen(forced) + strlen(".kext") +1];␊
1195␉␉␉␉␉//snprintf(buffer, strlen(forced) + strlen(".kext") +1, "%s%s", forced, ".kext");␊
1196␊
1197␉␉␉␉␉sprintf(buffer, "%s%s", forced, ".kext");␊
1198␊
1199␉␉␉␉␉if (!strcmp(buffer, kext))␊
1200␉␉␉␉␉{␊
1201␉␉␉␉␉␉verbose("- %s forced loaded\n", kext);␊
1202␉␉␉␉␉␉return true;␊
1203␉␉␉␉␉}␊
1204␉␉␉␉}␊
1205␉␉␉}␊
1206␉␉}␊
1207␉}␊
1208␉return false;␊
1209}␊
1210␊
1211//==========================================================================␊
1212// ParseXML␊
1213static long ParseXML( char *buffer, ModulePtr *module, TagPtr *personalities, bool forceKextToLoad )␊
1214{␊
1215␉long␉␉length;␊
1216␉long␉␉pos = 0;␊
1217␉TagPtr␉␉moduleDict;␊
1218␉TagPtr␉␉required;␊
1219␉TagPtr␉␉identifier;␊
1220␉ModulePtr␉tmpModule;␊
1221␊
1222␉while (1)␊
1223␉{␊
1224␉␉length = XMLParseNextTag(buffer + pos, &moduleDict);␊
1225␉␉if (length == -1)␊
1226␉␉{␊
1227␉␉␉break;␊
1228␉␉}␊
1229␊
1230␉␉pos += length;␊
1231␊
1232␉␉if (moduleDict == 0)␊
1233␉␉{␊
1234␉␉␉continue;␊
1235␉␉}␊
1236␉␉if (moduleDict->type == kTagTypeDict)␊
1237␉␉{␊
1238␉␉␉break;␊
1239␉␉}␊
1240␉␉XMLFreeTag(moduleDict);␊
1241␉}␊
1242␊
1243␉if (length == -1)␊
1244␉{␊
1245␉␉return -1;␊
1246␉}␊
1247␊
1248␉required = XMLGetProperty(moduleDict, kPropOSBundleRequired);␊
1249␊
1250␉// if forceKextToLoad is true, the kext will be force to load even if OSBundleRequired has value set to "Safe Boot" instead of "Root"␊
1251␉if (!forceKextToLoad)␊
1252␉{␊
1253␉␉if ( (required == 0) || (required->type != kTagTypeString) || !strncmp(required->string, "Safe Boot", sizeof("Safe Boot")))␊
1254␉␉{␊
1255␉␉␉identifier = XMLGetProperty(moduleDict, "CFBundleIdentifier");␊
1256␊
1257␉␉␉if (strcmp(identifier->string, "com.apple.driver.AppleSMC") == 0)␊
1258␉␉␉{␊
1259//␉␉␉␉verbose("\tForced load of: AppleSMC.kext");␊
1260␉␉␉}␊
1261␉␉␉else␊
1262␉␉␉{␊
1263␉␉␉␉XMLFreeTag(moduleDict);␊
1264␉␉␉␉return -2;␊
1265␉␉␉}␊
1266␉␉}␊
1267␉}␊
1268␊
1269␉tmpModule = malloc(sizeof(Module));␊
1270␉if (tmpModule == 0)␊
1271␉{␊
1272␉␉XMLFreeTag(moduleDict);␊
1273␉␉return -1;␊
1274␉}␊
1275␉tmpModule->dict = moduleDict;␊
1276 ␊
1277␉// For now, load any module that has OSBundleRequired != "Safe Boot".␊
1278␊
1279␉tmpModule->willLoad = 1;␊
1280␊
1281␉*module = tmpModule;␊
1282 ␊
1283␉// Get the personalities.␊
1284␊
1285␉*personalities = XMLGetProperty(moduleDict, kPropIOKitPersonalities);␊
1286 ␊
1287␉return 0;␊
1288}␊
1289␊
1290#if NOTDEF␊
1291static char gPlatformName[64];␊
1292#endif␊
1293␊
1294long DecodeKernel(void *binary, entry_t *rentry, char **raddr, int *rsize)␊
1295{␊
1296␉long ret = 0;␊
1297␉compressed_kernel_header *kernel_header = (compressed_kernel_header *)binary;␊
1298␉u_int32_t uncompressed_size = 0, size = 0, adler32 = 0;␊
1299␉void *buffer = NULL;␊
1300␉unsigned long len = 0;␊
1301␊
1302/*#if 0␊
1303␉printf("kernel header:\n");␊
1304␉printf("signature: 0x%x\n", kernel_header->signature);␊
1305␉printf("compress_type: 0x%x\n", kernel_header->compress_type);␊
1306␉printf("adler32: 0x%x\n", kernel_header->adler32);␊
1307␉printf("uncompressed_size: 0x%x\n", kernel_header->uncompressed_size);␊
1308␉printf("compressed_size: 0x%x\n", kernel_header->compressed_size);␊
1309␉getchar();␊
1310#endif*/␊
1311␊
1312␉if (kernel_header->signature == OSSwapBigToHostConstInt32('comp'))␊
1313␉{␊
1314␉␉DBG("Decompressing Kernel Cache:\n");␊
1315␊
1316␉␉if ((kernel_header->compress_type != OSSwapBigToHostConstInt32('lzss')) &&␊
1317␉␉␉(kernel_header->compress_type != OSSwapBigToHostConstInt32('lzvn')))␊
1318␉␉{␊
1319␉␉␉error("\tERROR: kernel compression is bad!\n");␊
1320␉␉␉return -1;␊
1321␉␉}␊
1322␊
1323␉␉if (kernel_header->compress_type == OSSwapBigToHostConstInt32('lzss'))␊
1324␉␉{␊
1325␉␉␉verbose ("\t- Decompressing Kernel Using lzss\n");␊
1326␉␉}␊
1327␊
1328␉␉if (kernel_header->compress_type == OSSwapBigToHostConstInt32('lzvn'))␊
1329␉␉{␊
1330␉␉␉verbose ("\t- Decompressing Kernel Using lzvn\n");␊
1331␉␉}␊
1332␊
1333#if NOTDEF␊
1334␉␉if (kernel_header->platform_name[0] && strcmp(gPlatformName, kernel_header->platform_name))␊
1335␉␉{␊
1336␉␉␉return -1;␊
1337␉␉}␊
1338␊
1339␉␉if (kernel_header->root_path[0] && strcmp(gBootFile, kernel_header->root_path))␊
1340␉␉{␊
1341␉␉␉return -1;␊
1342␉␉}␊
1343#endif␊
1344␉␉uncompressed_size = OSSwapBigToHostInt32(kernel_header->uncompressed_size);␊
1345␉␉binary = buffer = malloc(uncompressed_size);␊
1346␊
1347␉␉// MinusZwei␊
1348␉␉size = 0;␊
1349␉␉switch (kernel_header->compress_type)␊
1350␉␉{␊
1351␉␉␉case OSSwapBigToHostConstInt32('lzvn'):␊
1352␉␉␉␉size = lzvn_decode(binary, uncompressed_size, &kernel_header->data[0], OSSwapBigToHostInt32(kernel_header->compressed_size));␊
1353␉␉␉␉break;␊
1354␊
1355␉␉␉case OSSwapBigToHostConstInt32('lzss'):␊
1356␉␉␉␉size = decompress_lzss((u_int8_t *)binary, uncompressed_size, &kernel_header->data[0], OSSwapBigToHostInt32(kernel_header->compressed_size));␊
1357␉␉␉␉break;␊
1358␊
1359␉␉␉default:␊
1360␉␉␉␉break;␊
1361␉␉}␊
1362␉␉// MinusZwei␊
1363␊
1364␉␉if (uncompressed_size != size)␊
1365␉␉{␊
1366␉␉␉if ( kernel_header->compress_type == OSSwapBigToHostConstInt32('lzvn'))␊
1367␉␉␉{␊
1368␉␉␉␉error("ERROR! Size mismatch from lzvn (found: %x, expected: %x).\n", size, uncompressed_size);␊
1369␉␉␉}␊
1370␊
1371␉␉␉if ( kernel_header->compress_type == OSSwapBigToHostConstInt32('lzss'))␊
1372␉␉␉{␊
1373␉␉␉␉error("ERROR! size mismatch from lzss (found: %x, expected: %x).\n", size, uncompressed_size);␊
1374␉␉␉}␊
1375␊
1376␉␉␉return -1;␊
1377␉␉}␊
1378␊
1379␉␉adler32 = Adler32(binary, uncompressed_size);␊
1380␉␉if (OSSwapBigToHostInt32(kernel_header->adler32) != adler32)␊
1381␉␉{␊
1382␉␉␉error("ERROR! Adler mismatch (found: %X, expected: %X).\n", adler32, OSSwapBigToHostInt32(kernel_header->adler32));␊
1383␉␉␉return -1;␊
1384␉␉}␊
1385␊
1386␉␉DBG("\n");␊
1387␉}␊
1388␉␊
1389␉ret = ThinFatFile(&binary, &len);␊
1390␉if (ret == 0 && len == 0 && archCpuType==CPU_TYPE_X86_64)␊
1391␉{␊
1392␉␉archCpuType=CPU_TYPE_I386;␊
1393␉␉ret = ThinFatFile(&binary, &len);␊
1394␉}␊
1395␊
1396␉// Bungo: scan binary for Darwin Kernel Version string␊
1397␉useDarwinVersion = true;␊
1398␉uint32_t offset = 0;␊
1399␉strncpy(gDarwinBuildVerStr, "Darwin Kernel Version", sizeof(gDarwinBuildVerStr));␊
1400␊
1401␉while ((offset < 0xFFFFFFFF - (uint32_t)binary - 256) && memcmp(binary + offset, gDarwinBuildVerStr, 21))␊
1402␉{␊
1403␉␉offset++;␊
1404␉}␊
1405␉if (offset < 0xFFFFFFFF - (uint32_t)binary - 256)␊
1406␉{␊
1407␉␉strncpy(gDarwinBuildVerStr, (char *)(binary + offset), sizeof(gDarwinBuildVerStr));␊
1408␉}␊
1409␉else␊
1410␉{␊
1411␉␉strcat(gDarwinBuildVerStr, ": Unknown");␊
1412␉␉useDarwinVersion = false;␊
1413␉}␊
1414␉// Micky1979 use Bungo gDarwinBuildVerStr and split into gDarwinMajor, gDarwinMinor and gDarwinRev␊
1415␉if (useDarwinVersion)␊
1416␉{␊
1417␉␉useDarwinVersion = false;␊
1418␉␉const char *pattern = strstr(gDarwinBuildVerStr, "Darwin Kernel Version ")+22;␊
1419␉␉const char *until = strstr(pattern, ":");␊
1420␉␉size_t vlen = until - pattern;␊
1421␉␉char *ver = (char *)malloc(sizeof(char)*(len+1));␊
1422␉␉strncpy(ver, pattern, vlen);␊
1423␉␉ver[vlen] = '\0';␊
1424␉␉char *delim;␊
1425␉␉char *temp;␊
1426␉␉gDarwinMajor = -1; gDarwinMinor = -1; gDarwinRev = -1;␊
1427␉␉if (ver != NULL)␊
1428␉␉{␊
1429␉␉␉temp = ver;␊
1430␉␉␉int count = 1;␊
1431␉␉␉while ((delim = strsep_c(&ver, ".")) != NULL)␊
1432␉␉␉{␊
1433␉␉␉␉switch (count)␊
1434␉␉␉␉{␊
1435␉␉␉␉␉case 1: gDarwinMajor = atoi(delim); break;␊
1436␉␉␉␉␉case 2: gDarwinMinor = atoi(delim); break;␊
1437␉␉␉␉␉case 3: gDarwinRev = atoi(delim); break;␊
1438␉␉␉␉␉default: break;␊
1439␉␉␉␉}␊
1440␉␉␉␉count ++;␊
1441␉␉␉}␊
1442␉␉␉free(temp);␊
1443␉␉}␊
1444␊
1445␉␉if (gDarwinMajor >= 0 && gDarwinMinor >= 0 && gDarwinRev >= 0)␊
1446␉␉{␊
1447␉␉␉useDarwinVersion = true;␊
1448␉␉}␊
1449␊
1450␉␉switch (gDarwinMajor)␊
1451␉␉{␊
1452␉␉␉case 10:␊
1453␉␉␉␉switch (gDarwinMinor)␊
1454␉␉␉␉{␊
1455␉␉␉␉␉case 0: kernelOSVer = 0xA060000; break;␊
1456␉␉␉␉␉case 1: kernelOSVer = 0xA060100; break;␊
1457␉␉␉␉␉case 2: kernelOSVer = 0xA060200; break;␊
1458␉␉␉␉␉case 3: kernelOSVer = 0xA060300; break;␊
1459␉␉␉␉␉case 4: kernelOSVer = 0xA060400; break;␊
1460␉␉␉␉␉case 5: kernelOSVer = 0xA060500; break;␊
1461␉␉␉␉␉case 6: kernelOSVer = 0xA060600; break;␊
1462␉␉␉␉␉case 7: kernelOSVer = 0xA060700; break;␊
1463␉␉␉␉␉case 8: kernelOSVer = 0xA060800; break;␊
1464␉␉␉␉␉default:kernelOSVer = 0xA060800; break; //Last known kernel␊
1465␉␉␉␉}␊
1466␉␉␉␉break;␊
1467␉␉␉case 11:␊
1468␉␉␉␉switch (gDarwinMinor)␊
1469␉␉␉␉{␊
1470␉␉␉␉␉case 0: kernelOSVer = 0xA070000; break;␊
1471␉␉␉␉␉case 1: kernelOSVer = 0xA070100; break;␊
1472␉␉␉␉␉case 2: kernelOSVer = 0xA070200; break;␊
1473␉␉␉␉␉case 3: kernelOSVer = 0xA070300; break;␊
1474␉␉␉␉␉case 4:␊
1475␉␉␉␉␉␉switch (gDarwinRev)␊
1476␉␉␉␉␉␉{␊
1477␉␉␉␉␉␉␉case 0: kernelOSVer = 0xA070400; break;␊
1478␉␉␉␉␉␉␉case 1: kernelOSVer = 0xA070400; break;␊
1479␉␉␉␉␉␉␉case 2: kernelOSVer = 0xA070500; break;␊
1480␉␉␉␉␉␉␉default:kernelOSVer = 0xA070500; break; //Last known kernel␊
1481␉␉␉␉␉␉}␊
1482␉␉␉␉␉default:kernelOSVer = 0xA070500; break; //Last known kernel␊
1483␉␉␉␉}␊
1484␉␉␉␉break;␊
1485␉␉␉case 12:␊
1486␉␉␉␉switch (gDarwinMinor)␊
1487␉␉␉␉{␊
1488␉␉␉␉␉case 0: kernelOSVer = 0xA080000; break;␊
1489␉␉␉␉␉case 1: kernelOSVer = 0xA080100; break;␊
1490␉␉␉␉␉case 2: kernelOSVer = 0xA080200; break;␊
1491␉␉␉␉␉case 3: kernelOSVer = 0xA080300; break;␊
1492␉␉␉␉␉case 4: kernelOSVer = 0xA080400; break;␊
1493␉␉␉␉␉case 5: kernelOSVer = 0xA080500; break; // 10.8.5␊
1494␉␉␉␉␉case 6: kernelOSVer = 0xA080500; break; // 10.8.5 update␊
1495␉␉␉␉␉default:kernelOSVer = 0xA080500; break; //Last known kernel␊
1496␉␉␉␉}␊
1497␉␉␉␉break;␊
1498␉␉␉case 13:␊
1499␉␉␉␉switch (gDarwinMinor)␊
1500␉␉␉␉{␊
1501␉␉␉␉␉case 0: kernelOSVer = 0xA090000;␊
1502␉␉␉␉␉switch (gDarwinRev)␊
1503␉␉␉␉␉{␊
1504␉␉␉␉␉␉case 0: kernelOSVer = 0xA090000; break;␊
1505␉␉␉␉␉␉case 1: kernelOSVer = 0xA090000; break; // never exist (or released)␊
1506␉␉␉␉␉␉case 2: kernelOSVer = 0xA090100; break;␊
1507␉␉␉␉␉␉default:kernelOSVer = 0xA090100; break; //Last known kernel␊
1508␉␉␉␉␉}␊
1509␉␉␉␉␉␉break;␊
1510␉␉␉␉␉case 1: kernelOSVer = 0xA090100; break; // never exist (or released)␊
1511␉␉␉␉␉case 2: kernelOSVer = 0xA090200; break;␊
1512␉␉␉␉␉case 3: kernelOSVer = 0xA090300; break;␊
1513␉␉␉␉␉case 4: kernelOSVer = 0xA090400; break;␊
1514␉␉␉␉␉case 5: kernelOSVer = 0xA090500; break;␊
1515␉␉␉␉␉default:kernelOSVer = 0xA090500; break; //Last known kernel␊
1516␉␉␉␉}␊
1517␉␉␉␉break;␊
1518␉␉␉case 14:␊
1519␉␉␉␉switch (gDarwinMinor)␊
1520␉␉␉␉{␊
1521␉␉␉␉␉case 0: kernelOSVer = 0xA0A0000; break; // same kernel of 10.10.1␊
1522␉␉␉␉␉case 1: kernelOSVer = 0xA0A0100; break; // same kernel of 10.10␊
1523␉␉␉␉␉case 2: kernelOSVer = 0xA0A0200; break;␊
1524␉␉␉␉␉case 3: kernelOSVer = 0xA0A0300; break;␊
1525␉␉␉␉␉case 4: kernelOSVer = 0xA0A0400; break;␊
1526␉␉␉␉␉case 5: kernelOSVer = 0xA0A0500; break;␊
1527␉␉␉␉␉default:kernelOSVer = 0xA0A0500; break; //Last known kernel␊
1528␉␉␉␉}␊
1529␉␉␉␉break;␊
1530␉␉␉case 15: /* El Capitan */␊
1531␉␉␉␉switch (gDarwinMinor)␊
1532␉␉␉␉{␊
1533␉␉␉␉␉case 0: kernelOSVer = 0xA0B0000; break;␊
1534␉␉␉␉␉case 1: kernelOSVer = 0xA0B0100; break;␊
1535␉␉␉␉␉case 2: kernelOSVer = 0xA0B0200; break;␊
1536␉␉␉␉␉case 3: kernelOSVer = 0xA0B0300; break;␊
1537␉␉␉␉␉case 4: kernelOSVer = 0xA0B0400; break;␊
1538␉␉␉␉␉case 5: kernelOSVer = 0xA0B0500; break;␊
1539␉␉␉␉␉case 6: kernelOSVer = 0xA0B0600; break;␊
1540␉␉␉␉␉default:kernelOSVer = 0xA0B0600; break; //Last known kernel (add here updates)␊
1541␉␉␉␉}␊
1542␉␉␉␉break;␊
1543␉␉␉case 16: /* Sierra */␊
1544␉␉␉␉switch (gDarwinMinor)␊
1545␉␉␉␉{␊
1546␉␉␉␉␉case 0: kernelOSVer = 0xA0C0000; break;␊
1547␉␉␉␉␉case 1: kernelOSVer = 0xA0C0100; break;␊
1548␉␉␉␉␉case 2: kernelOSVer = 0xA0C0200; break;␊
1549␉␉␉␉␉case 3: kernelOSVer = 0xA0C0200; break;␊
1550␉␉␉␉␉case 4: kernelOSVer = 0xA0C0300; break;␊
1551␉␉␉␉␉case 5: kernelOSVer = 0xA0C0400; break;␊
1552␉␉␉␉␉case 6: kernelOSVer = 0xA0C0500; break;␊
1553␉␉␉␉␉case 7: kernelOSVer = 0xA0C0600; break;␊
1554␉␉␉␉␉default:kernelOSVer = 0xA0C0600; break; //Last known kernel (add here updates)␊
1555␉␉␉␉}␊
1556␉␉␉␉break;␊
1557␉␉␉case 17: /* High Sierra */␊
1558␉␉␉␉switch (gDarwinMinor)␊
1559␉␉␉␉{␊
1560␉␉␉␉␉case 0: kernelOSVer = 0xA0D0000; break;␊
1561␉␉␉␉␉case 1: kernelOSVer = 0xA0D0100; break; // 17.2.0␊
1562␉␉␉␉␉case 2: kernelOSVer = 0xA0D0200; break;␊
1563␉␉␉␉␉case 3: kernelOSVer = 0xA0D0300; break;␊
1564␉␉␉␉␉case 4: kernelOSVer = 0xA0D0400; break;␊
1565␉␉␉␉␉case 5: kernelOSVer = 0xA0D0500; break;␊
1566␉␉␉␉␉case 6: kernelOSVer = 0xA0D0600; break;␊
1567␉␉␉␉␉case 7: kernelOSVer = 0xA0D0700; break;␊
1568␉␉␉␉␉default:kernelOSVer = 0xA0D0700; break; //Last known kernel (add here updates)␊
1569␉␉␉␉}␊
1570␉␉␉␉break;␊
1571␉␉␉case 18: /* Mojave */␊
1572␉␉␉␉switch (gDarwinMinor)␊
1573␉␉␉␉{␊
1574␉␉␉␉␉case 0: kernelOSVer = 0xA0E0000; break;␊
1575␉␉␉␉␉case 1: kernelOSVer = 0xA0E0100; break;␊
1576␉␉␉␉␉case 2: kernelOSVer = 0xA0E0200; break;␊
1577␉␉␉␉␉case 3: kernelOSVer = 0xA0E0300; break;␊
1578␉␉␉␉␉case 4: kernelOSVer = 0xA0E0400; break;␊
1579␉␉␉␉␉case 5: kernelOSVer = 0xA0E0500; break;␊
1580␉␉␉␉␉case 6: kernelOSVer = 0xA0E0600; break;␊
1581␉␉␉␉␉case 7: kernelOSVer = 0xA0E0700; break;␊
1582␉␉␉␉␉default:kernelOSVer = 0xA0E0700; break; //Last known kernel (add here updates)␊
1583␉␉␉␉}␊
1584␉␉␉␉break;␊
1585␉␉␉case 19: /* Catalina */␊
1586␉␉␉␉switch (gDarwinMinor)␊
1587␉␉␉␉{␊
1588␉␉␉␉␉case 0: kernelOSVer = 0xA0F0000; break;␊
1589//␉␉␉␉␉case 1: kernelOSVer = 0xA0F0100; break;␊
1590//␉␉␉␉␉case 2: kernelOSVer = 0xA0F0200; break;␊
1591//␉␉␉␉␉case 3: kernelOSVer = 0xA0F0300; break;␊
1592//␉␉␉␉␉case 4: kernelOSVer = 0xA0F0400; break;␊
1593//␉␉␉␉␉case 5: kernelOSVer = 0xA0F0500; break;␊
1594//␉␉␉␉␉case 6: kernelOSVer = 0xA0F0600; break;␊
1595//␉␉␉␉␉case 7: kernelOSVer = 0xA0F0700; break;␊
1596␉␉␉␉␉default:kernelOSVer = 0xA0F0000; break; //Last known kernel (add here updates)␊
1597␉␉␉␉}␊
1598␉␉␉␉break;␊
1599␉␉␉default:␊
1600␉␉␉␉kernelOSVer = 0xA0F0000;␊
1601␉␉␉␉break; //Last known kernel is Sierra 10.15␊
1602␉␉␉}␊
1603␉␉}␊
1604␉␉else␊
1605␉␉{␊
1606␉␉␉switch (MacOSVerCurrent)␊
1607␉␉␉{␊
1608␉␉␉// Snow␊
1609␉␉␉case 0xA060000: gDarwinMajor = 10; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.6␊
1610␉␉␉case 0xA060100: gDarwinMajor = 10; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.6.1␊
1611␉␉␉case 0xA060200: gDarwinMajor = 10; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.6.2␊
1612␉␉␉case 0xA060300: gDarwinMajor = 10; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.6.3␊
1613␉␉␉case 0xA060400: gDarwinMajor = 10; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.6.4␊
1614␉␉␉case 0xA060500: gDarwinMajor = 10; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.6.5␊
1615␉␉␉case 0xA060600: gDarwinMajor = 10; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.6.6␊
1616␉␉␉case 0xA060700: gDarwinMajor = 10; gDarwinMinor = 7; gDarwinRev = 0; break; // 10.6.7␊
1617␉␉␉case 0xA060800: gDarwinMajor = 10; gDarwinMinor = 8; gDarwinRev = 0; break; // 10.6.8␊
1618␉␉␉// Lion␊
1619␉␉␉case 0xA070000: gDarwinMajor = 11; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.7␊
1620␉␉␉case 0xA070100: gDarwinMajor = 11; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.7.1␊
1621␉␉␉case 0xA070200: gDarwinMajor = 11; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.7.2␊
1622␉␉␉case 0xA070300: gDarwinMajor = 11; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.7.3␊
1623␉␉␉case 0xA070400: gDarwinMajor = 11; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.7.4␊
1624␉␉␉case 0xA070500: gDarwinMajor = 11; gDarwinMinor = 4; gDarwinRev = 2; break; // 10.7.5␊
1625␉␉␉// ML␊
1626␉␉␉case 0xA080000: gDarwinMajor = 12; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.8␊
1627␉␉␉case 0xA080100: gDarwinMajor = 12; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.8.1␊
1628␉␉␉case 0xA080200: gDarwinMajor = 12; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.8.2␊
1629␉␉␉case 0xA080300: gDarwinMajor = 12; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.8.3␊
1630␉␉␉case 0xA080400: gDarwinMajor = 12; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.8.4␊
1631␉␉␉case 0xA080500: gDarwinMajor = 12; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.8.5␊
1632␉␉␉// Mavericks␊
1633␉␉␉case 0xA090000: gDarwinMajor = 13; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.9␊
1634␉␉␉case 0xA090100: gDarwinMajor = 13; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.9.1␊
1635␉␉␉case 0xA090200: gDarwinMajor = 13; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.9.2␊
1636␉␉␉case 0xA090300: gDarwinMajor = 13; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.9.3␊
1637␉␉␉case 0xA090400: gDarwinMajor = 13; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.9.4␊
1638␉␉␉case 0xA090500: gDarwinMajor = 13; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.9.5␊
1639␉␉␉// Yosemite␊
1640␉␉␉case 0xA0A0000: gDarwinMajor = 14; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.10␊
1641␉␉␉case 0xA0A0100: gDarwinMajor = 14; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.10.1␊
1642␉␉␉case 0xA0A0200: gDarwinMajor = 14; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.10.2␊
1643␉␉␉case 0xA0A0300: gDarwinMajor = 14; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.10.3␊
1644␉␉␉case 0xA0A0400: gDarwinMajor = 14; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.10.4␊
1645␉␉␉case 0xA0A0500: gDarwinMajor = 14; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.10.5␊
1646␉␉␉// El Capitan␊
1647␉␉␉case 0xA0B0000: gDarwinMajor = 15; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.11␊
1648␉␉␉case 0xA0B0100: gDarwinMajor = 15; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.11.1␊
1649␉␉␉case 0xA0B0200: gDarwinMajor = 15; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.11.2␊
1650␉␉␉case 0xA0B0300: gDarwinMajor = 15; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.11.3␊
1651␉␉␉case 0xA0B0400: gDarwinMajor = 15; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.11.4␊
1652␉␉␉case 0xA0B0500: gDarwinMajor = 15; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.11.5␊
1653␉␉␉case 0xA0B0600: gDarwinMajor = 15; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.11.6␊
1654␉␉␉// Sierra␊
1655␉␉␉case 0xA0C0000: gDarwinMajor = 16; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.12␊
1656␉␉␉case 0xA0C0100: gDarwinMajor = 16; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.12.1␊
1657␉␉␉case 0xA0C0200: gDarwinMajor = 16; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.12.2␊
1658␉␉␉case 0xA0C0300: gDarwinMajor = 16; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.12.3␊
1659␉␉␉case 0xA0C0400: gDarwinMajor = 16; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.12.4␊
1660␉␉␉case 0xA0C0500: gDarwinMajor = 16; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.12.5␊
1661␉␉␉case 0xA0C0600: gDarwinMajor = 16; gDarwinMinor = 7; gDarwinRev = 0; break; // 10.12.6␊
1662␉␉␉// High Sierra␊
1663␉␉␉case 0xA0D0000: gDarwinMajor = 17; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.13␊
1664␉␉␉case 0xA0D0100: gDarwinMajor = 17; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.13.1␊
1665␉␉␉case 0xA0D0200: gDarwinMajor = 17; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.13.2␊
1666␉␉␉case 0xA0D0300: gDarwinMajor = 17; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.13.3␊
1667␉␉␉case 0xA0D0400: gDarwinMajor = 17; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.13.4␊
1668␉␉␉case 0xA0D0500: gDarwinMajor = 17; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.13.5␊
1669␉␉␉case 0xA0D0600: gDarwinMajor = 17; gDarwinMinor = 7; gDarwinRev = 0; break; // 10.13.6␊
1670␉␉␉// Mojave␊
1671␉␉␉case 0xA0E0000: gDarwinMajor = 18; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.14␊
1672␉␉␉case 0xA0E0100: gDarwinMajor = 18; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.14.1␊
1673␉␉␉case 0xA0E0200: gDarwinMajor = 18; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.14.2␊
1674␉␉␉case 0xA0E0300: gDarwinMajor = 18; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.14.3␊
1675␉␉␉case 0xA0E0400: gDarwinMajor = 18; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.14.4␊
1676␉␉␉case 0xA0E0500: gDarwinMajor = 18; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.14.5␊
1677␉␉␉case 0xA0E0600: gDarwinMajor = 18; gDarwinMinor = 7; gDarwinRev = 0; break; // 10.14.6␊
1678␉␉␉// Catalina␊
1679␉␉␉case 0xA0F0000: gDarwinMajor = 19; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.15␊
1680//␉␉␉case 0xA0F0100: gDarwinMajor = 19; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.15.1␊
1681␊
1682␉␉␉// default = last known kernel␊
1683␉␉␉default: gDarwinMajor = 19; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.15␊
1684␉␉}␊
1685␉}␊
1686␊
1687␉// Notify modules that the kernel has been decompressed, thinned and is about to be decoded␊
1688␉execute_hook("DecodeKernel", (void *)binary, NULL, NULL, NULL);␊
1689␊
1690/* ================================================================ */␊
1691␊
1692␉ret = DecodeMachO(binary, uncompressed_size, rentry, raddr, rsize);␊
1693␉if (ret < 0 && archCpuType == CPU_TYPE_X86_64)␊
1694␉{␊
1695␉␉archCpuType = CPU_TYPE_I386;␊
1696␉␉ret = DecodeMachO(binary, uncompressed_size, rentry, raddr, rsize);␊
1697␉}␊
1698␊
1699␉return ret;␊
1700}␊
1701

Archive Download this file

Revision: 2922